/** @return DirItem */
private function makeTmpDirItem()
{
$path = DirManager::uploads()->cdToHashFolder()->absDirPath();
$tmpFilePath = tempnam($path, 'upload_');
check_condition($tmpFilePath, 'Не удаётся создать временный файл');
return DirItem::inst($tmpFilePath);
}
/**
* Процесс выполняет периодические задачи cron
*
* @param array $argv
*/
function executeProcess(array $argv)
{
$SYNC_DIR = 'd:/Zona Downloads/Архив пранкоты/';
$lists = DirManager::inst(__DIR__)->getDirContent('m3u', PsConst::EXT_M3U);
$filesCopied = DirItem::inst(__DIR__, 'all_copied', 'list')->remove()->touch();
$filesSkipped = DirItem::inst(__DIR__, 'all_skipped', 'list')->remove()->touch();
$destDir = DirManager::inst(__DIR__, 'dest')->clearDir()->makePath();
/* @var $list DirItem */
foreach ($lists as $name => $list) {
$name = mb_convert_encoding($name, 'UTF-8', 'cp1251');
dolog("+ {$name}");
foreach ($list->getFileLines() as $newFile) {
$newFile = mb_convert_encoding($newFile, 'UTF-8', 'UTF-8');
if (starts_with($newFile, '#')) {
dolog(" - {$newFile}");
continue;
//---
}
$absPath = next_level_dir($SYNC_DIR, $newFile);
$absPath = iconv('UTF-8', 'cp1251', $absPath);
$isFile = is_file($absPath);
dolog(" + {$newFile} ? {}", var_export($isFile, true));
if (!$isFile) {
$filesSkipped->writeLineToFile($absPath);
continue;
//---
}
$fileName = iconv('UTF-8', 'cp1251', basename($newFile));
copy($absPath, $destDir->absFilePath(null, $fileName));
$filesCopied->writeLineToFile($absPath);
}
//print_r($list->getFileLines());
}
}
function smarty_function_linkup_js($params, Smarty_Internal_Template &$smarty)
{
$params = ArrayAdapter::inst($params);
$dir = $params->str('dir');
$name = $params->str('name');
$di = DirManager::resources('scripts')->getDirItem($dir, $name, 'js');
echo $di->isFile() ? PsHtml::linkJs($di) : '';
}
private function generateImpl()
{
$images = DirManager::inst('ps-addon/crop')->getDirContent('oboi', DirItemFilter::FILES);
for ($i = 0; $i < rand(2000, 3000); $i++) {
$img = $images[array_rand($images)];
echo PsHtml::img(array('src' => PsImgEditor::resize($img, '60x60', null)));
}
}
private function doClean(DirItem $srcDi)
{
foreach (DirManager::autogen()->getSubDirNames('images') as $dim) {
$cacheKey = md5("[{$srcDi}]:[{$dim}]");
$this->CAHCE->remove($cacheKey);
DirManager::autogen()->getHashedDirItem("images/{$dim}", $cacheKey, $cacheKey, SYSTEM_IMG_TYPE)->remove();
}
}
/** @return DirItem */
private function getAvatarImg()
{
if (!isset($this->avatars)) {
$this->avatars = array_values(DirManager::images('avatars')->getDirContent(null, DirItemFilter::IMAGES));
check_condition($this->avatars, 'No avatar images');
}
return $this->avatars[rand(0, count($this->avatars) - 1)];
}
function smarty_function_linkup_css($params, Smarty_Internal_Template &$smarty)
{
$params = ArrayAdapter::inst($params);
$dir = $params->str('dir');
$name = $params->str('name');
$media = $params->str('media');
$di = DirManager::resources('css')->getDirItem($dir, $name, 'css');
echo $di->isFile() ? PsHtml::linkCss($di, $media) : '';
}
/**
* Процесс строит скрипты для вставки ячеек в БД
*
* @param array $argv
*/
function executeProcess(array $argv)
{
$DM = DirManager::inst(array(__DIR__, 'output'));
$customNum = $argv[1];
dolog('Processing mosaic demo, custom num={}', $customNum);
/* @var $dir DirItem */
foreach ($DM->getDirContent(null, DirItemFilter::DIRS) as $dir) {
if (is_inumeric($customNum) && $customNum != $dir->getName()) {
continue;
//----
}
$imgDM = DirManager::inst($dir->getAbsPath());
$imgDI = end($imgDM->getDirContent(null, DirItemFilter::IMAGES));
$map = $imgDM->getDirItem(null, 'map', 'txt')->getFileAsProps();
$demoDM = DirManager::inst($imgDM->absDirPath(), 'demo');
$demoDM->clearDir();
dolog("Building map for: [{}].", $imgDI->getRelPath());
//CELLS BINDING
$dim = $imgDM->getDirItem(null, 'settings', 'txt')->getFileAsProps();
$dim = $dim['dim'];
$dim = explode('x', $dim);
$cw = 1 * $dim[0];
$ch = 1 * $dim[1];
$sourceImg = SimpleImage::inst()->load($imgDI);
$w = $sourceImg->getWidth();
$h = $sourceImg->getHeight();
$destImg = SimpleImage::inst()->create($w, $h, MosaicImage::BG_COLOR);
dolog("Img size: [{$w} x {$h}].");
check_condition($w > 0 && !($w % $cw), 'Bad width');
check_condition($h > 0 && !($h % $ch), 'Bad height');
$totalCells = count($map);
$lengtn = strlen("{$totalCells}");
//dolog("Cells cnt: [$xcells x $ycells], total: $totalCells.");
//СТРОИМ КАРТИНКИ
$secundomer = Secundomer::startedInst();
//$encoder = new PsGifEncoder();
for ($cellCnt = 0; $cellCnt <= $totalCells; $cellCnt++) {
$name = pad_zero_left($cellCnt, $lengtn);
$copyTo = $demoDM->absFilePath(null, $name, 'jpg');
if ($cellCnt > 0) {
$cellParams = $map[$cellCnt];
$cellParams = explode('x', $cellParams);
$xCell = $cellParams[0];
$yCell = $cellParams[1];
$x = ($xCell - 1) * $cw;
$y = ($yCell - 1) * $ch;
$destImg->copyFromAnother($sourceImg, $x, $y, $x, $y, $cw, $ch);
}
$destImg->save($copyTo);
dolog("[{$totalCells}] {$copyTo}");
}
//$encoder->saveToFile($demoDM->absFilePath(null, 'animation'));
$secundomer->stop();
dolog('Execution time: ' . $secundomer->getTotalTime());
}
}
/**
* Собирает статистику по переданному профайлеру или по всем профайлерам сразу.
* Достигается это путём разбора файла, относящегося к профайлеру.
*/
public function getStats($profilerId = null)
{
$result = array();
$files = $profilerId ? $this->getProfilerDi($profilerId) : $this->dirManager->getDirContent(null, PsConst::EXT_TXT);
/** @var DirItem */
foreach (to_array($files) as $file) {
$result[$file->getNameNoExt()] = $this->parseProfiler($file);
}
return $result;
}
/**
* Возвращает названия всех классов в директории
*/
public static function getDirClassNames($__DIR__, $subDir, $parent)
{
$classes = array();
foreach (DirManager::inst($__DIR__)->getDirContent($subDir, PsConst::EXT_PHP, DirManager::DC_NAMES_NO_EXT) as $name) {
if (PsUtil::isInstanceOf($name, $parent)) {
$classes[] = $name;
}
}
return $classes;
}
/**
* Получает ссылку на файл с конфигом .ini
*/
private static function getIniDi($scope)
{
switch ($scope) {
case ENTITY_SCOPE_SDK:
return DirManager::inst(PS_DIR_INCLUDES)->getDirItem(DirManager::DIR_CONFIG, self::getConfigName());
case ENTITY_SCOPE_PROJ:
return DirManager::inst(PS_DIR_ADDON)->getDirItem(DirManager::DIR_CONFIG, self::getConfigName());
}
PsUtil::raise('Invalid scope [{}] for method {}::{}', $scope, __CLASS__, __FUNCTION__);
}
private function __construct()
{
$this->CLASS = get_called_class();
$this->CACHE = new SimpleDataCache();
$this->DBTYPE = $this->isStoreToDb() ? $this->CLASS : null;
$this->DIR_MANAGER = DirManager::inst(array(ConfigIni::uploadsDirRel(), $this->CLASS));
$this->LOGGER = PsLogger::inst($this->CLASS);
$this->LOGGER->info('Instance created. Work with db ? {}. Is autonomous ? {}.', var_export($this->isStoreToDb(), true), var_export($this->isAutonomous(), true));
$this->LOGGER->info('Upload dir: [{}].', $this->DIR_MANAGER->relDirPath());
$this->LOGGER->info();
}
/** @return CssSprite */
public static function inst($spritable)
{
//Если строка, значит передано название поддиректории в папке www/resources/sprites
$spritable = is_string($spritable) ? DirManager::sprites($spritable)->getDirItem() : $spritable;
check_condition($spritable instanceof Spritable, 'Элемент для построения спрайта не является подклассом Spritable');
$name = $spritable->getSpriteName();
if (array_key_exists($name, self::$sprites)) {
return self::$sprites[$name];
}
if ($spritable instanceof DirItem) {
check_condition($spritable->isDir(), "Некорректная директория {$spritable} для построения спрайта");
}
return self::$sprites[$name] = new CssSprite($name, $spritable);
}
public function __construct()
{
/**
* Подключаем cache lite
*/
PsLibs::inst()->CacheLite();
/*
* Конфигурируем
*/
$liteOptions = array('readControl' => true, 'writeControl' => true, 'readControlType' => 'md5', 'automaticSerialization' => true, 'cacheDir' => DirManager::autogen('cache-lite')->absDirPath(), 'lifeTime' => ConfigIni::cacheFileLifetime() * 60, 'caching' => true);
if (PsLogger::isEnabled()) {
PsLogger::inst(__CLASS__)->info('Lite options: {}', print_r($liteOptions, true));
}
$this->IMPL = new Cache_Lite($liteOptions);
}
public function closeAndWriteFinalLog()
{
$date = date(DF_PS);
$this->doAppend($this->fileCommon, self::SEPARATOR . " {$this->sessionNUM}. [{$date}] " . self::SEPARATOR);
//Если номер сессии логирования всё ещё является последним - перенесём логи в папку lastsession
if (PsSequence::LOG()->isCurrent($this->sessionNUM)) {
$DM = PsLogger::DM('lastsession');
$DM->clearDir();
$files = $this->sessionDM->getDirContent(null, PsConst::EXT_TXT);
/** @var DirItem */
foreach ($files as $logDI) {
$logDI->copyTo($DM->absFilePath(null, $logDI->getName()));
}
}
}
/**
* Метод для очистки кучи перед выполнением тестов
*/
public static function cleanScrap($absPath = null)
{
$dm = DirManager::inst($absPath ? $absPath : DirManagerTestHelper::scrapAbsPath());
/* @var $di DirItem */
foreach ($dm->getDirContent() as $name => $di) {
if ($di->isDir()) {
self::cleanScrap($di->getAbsPath());
}
if (array_key_exists($name, self::$SCRAP)) {
continue;
//---
}
$di->remove();
}
}
private function executeImpl($lifeTimeOnCall, $__FUNCTION__)
{
if ($this->called) {
return $this->executed;
//---
}
$this->called = true;
$LOGGER = PsLogger::inst(__CLASS__);
$LOGGER->info("Function [{$__FUNCTION__}] called.");
$needProcess = false;
$LOCKFILE = DirManager::autogen('service')->getDirItem(null, __CLASS__, 'lock');
if ($LOCKFILE->isFile()) {
$lifeTime = $LOCKFILE->getFileLifetime();
$needProcess = !$lifeTime || !$lifeTimeOnCall || $lifeTime >= $lifeTimeOnCall;
$LOGGER->info('{} process. Lock file modified {} seconds ago. Process delay: {} seconds.', $needProcess ? 'Need' : 'Not need', $lifeTime, $lifeTimeOnCall);
} else {
$needProcess = true;
$LOGGER->info('Need process. Lock file is not exists.');
}
if (!$needProcess) {
return $this->executed;
//---
}
$locked = PsLock::lock(__CLASS__, false);
$LOGGER->info('External process lock {} execution.', $locked ? 'acquired, start' : 'not acquired, skip');
if ($locked) {
$LOCKFILE->touch();
PsUtil::startUnlimitedMode();
//Отпустим лок, так как внутри он может потребоваться для выполнения других действий, например для перестройки спрайтов
PsLock::unlock();
//Начинаем выполнение
$this->executed = true;
$job = new ExternalProcessJob();
PsProfiler::inst(__CLASS__)->start(__FUNCTION__);
$job->execute();
$secundomer = PsProfiler::inst(__CLASS__)->stop();
if ($secundomer) {
$LOGGER->info("{$secundomer}");
}
}
return $this->executed;
}
/**
* Метод выполняет фактическое получение лока
*/
private function doLock($lockname, $wait)
{
PsCheck::notEmptyString($lockname);
if ($this->lockName == $lockname) {
$this->lockCnt++;
$this->LOGGER->info('Lock ident [{}] counter inreased to {}.', $lockname, $this->lockCnt);
return true;
}
check_condition($lockname, 'Lock ident cannot be empty');
check_condition(!$this->lockName, "Lock [{$lockname}] cannot be set, previous lock [{$this->lockName}] is active");
$filename = md5($lockname);
$this->LOGGER->info("Trying to get lock with ident [{$lockname}], mode: {}. Lock file name=[{$filename}].", $wait ? 'WAIT' : 'NOWAIT');
/**
* Храним в auto-no-del, а не в autogen, так как можем потерять локи при удалении autogen
* или вообще не иметь возможности удалить папку autogen.
*/
$di = DirManager::autoNoDel('locks')->getDirItem(null, $filename, 'lock');
/*
* Файл будет создан при открытии
*/
$fp = fopen($di->getAbsPath(), 'a+');
do {
$this->LOGGER->info('Locking file...');
if (flock($fp, $wait ? LOCK_EX : LOCK_EX | LOCK_NB)) {
$this->lockCnt = 1;
$this->lockFile = $fp;
$this->lockName = $lockname;
$this->LOGGER->info('Lock acquired!');
return true;
}
//Мы не получили блокировку...
if ($wait) {
$this->LOGGER->info('Lock not acquired, sleep for 1 sec');
sleep(1);
}
} while ($wait);
@fclose($fp);
$this->LOGGER->info("Lock not setted.\n");
return false;
}
protected function __construct()
{
PsLibs::inst()->Smarty();
/*
* Начиная с версии 5.4 в функции htmlentities параметр encoding был изменён на UTF-8,
* до этого момента после применения данного метода к тексту шаблона мы будем получать кракозябру.
*/
SmartyCompilerException::$escape = is_phpver_is_or_greater(5, 4);
//Получим и сконфигурируем экземпляр Smarty
$this->smarty = new Smarty();
$this->smarty->compile_check = true;
$this->smarty->force_compile = false;
//$this->smarty->caching = TRUE;
/*
* УПРАВЛЯЮЩИЕ ДИРЕКТОРИИ
*/
//Директории с шаблонами .tpl : PSSmarty::template('common/citata.tpl');
$this->smarty->setTemplateDir(ConfigIni::smartyTemplates());
//Директория, в которую складываются скомпилированные шаблоны
$this->smarty->setCompileDir(DirManager::autogen('/smarty/templates_c/')->absDirPath());
//Директория, в которую складываются кеши
$this->smarty->setCacheDir(DirManager::autogen('/smarty/cache/')->absDirPath());
//Директория с конфигами
$this->smarty->setConfigDir(PATH_BASE_DIR . PS_DIR_INCLUDES . '/smarty/configs/');
//Директории с плагинами - блочными функциями, функциями, модификатор
$this->smarty->addPluginsDir(ConfigIni::smartyPlugins());
/*
* Импортируем константы некоторых классов, чтобы на них можно было ссылаться через
* {$smarty.const.CONST_NAME}
*/
//PsConstJs::defineAllConsts();
/*
* ПОДКЛЮЧИМ ФИЛЬТРЫ
*/
PSSmartyFilter::inst()->bind($this->smarty);
/*
* ПОДКЛЮЧАЕМ ПЛАГИНЫ
*/
PSSmartyPlugin::inst()->bind($this->smarty);
}
/**
* Конвертирует картинки в .png
*
* @param array $argv
*/
function executeProcess(array $argv)
{
$SRC_DIR = 'source';
$OUT_DIR = 'output';
$dm = DirManager::inst(__DIR__);
//Создадим $SRC_DIR
$dm->makePath($SRC_DIR);
//Перенесём все картинки из корня в $SRC_DIR
$items = $dm->getDirContent(null, DirItemFilter::IMAGES);
/* @var $img DirItem */
foreach ($items as $img) {
$img->copyTo($dm->absFilePath($SRC_DIR, $img->getName()))->remove();
}
//Очистим $OUT_DIR
$dm->clearDir($OUT_DIR)->makePath($OUT_DIR);
//Список картинок
$items = $dm->getDirContent($SRC_DIR, DirItemFilter::IMAGES);
/* @var $img DirItem */
foreach ($items as $img) {
SimpleImage::inst()->load($img)->resizeSmart(36, 36)->save($dm->absFilePath($OUT_DIR, $img->getNameNoExt(), 'png'), IMAGETYPE_PNG)->close();
}
}
public function saveCommentsFormules2Zip()
{
$formules = $this->getAllComments();
if (empty($formules)) {
return null;
//---
}
$zipDi = DirManager::inst('admin/stuff', 'zip')->getDirItem(null, 'posts-comments', 'zip')->remove();
$zip = $zipDi->startZip();
$totalSize = 0;
/** @var $imgDi DirItem */
foreach ($formules as $imgDi) {
$imgDi->setData('class', 'TeX');
$totalSize += $imgDi->getSize();
$name = $imgDi->getName();
$path = 'formules/f' . $name[0] . '/f' . $name[1] . '/f' . $name[2] . '/';
$zip->addFile($imgDi->getAbsPath(), $imgDi->getRelPath());
$zip->addFile($imgDi->getAbsPath() . '.tex', $imgDi->getRelPath() . '.tex');
}
$zip->close();
return array('zip' => $zipDi, 'formules' => $formules, 'imagesSize' => $totalSize);
}
/**
* Непосредственное наполнение
*/
private function doFill($filterName = null)
{
$this->LOGGER->info("Loading full content of dir [{}] with [{}] filter.", $this->PATH, PsUtil::toString($filterName));
$this->PROFILER->start('doFill');
/*
* На данный момент у нас все директории собраны, остаётся только пробежаться по ним
* и взять всё необходимое.
* При этом нужно выполнить array_values, так как getDirContent возвращает ассоциативный массив,
* а файлы в директориях могут повторяться.
*/
$RESULT = array();
foreach ($this->DIRS as $dirPath) {
$items = DirManager::inst($dirPath)->getDirContent(null, $filterName);
$RESULT = array_merge($RESULT, array_values($items));
}
$this->LOGGER->info('Loading finished, items count: {}. Taken time: {}sec.', count($RESULT), $this->PROFILER->stop()->getTime());
$this->LOGGER->info('');
return $RESULT;
}
/** @return DirItem */
private function diDst()
{
return DirManager::autogen('mosaic')->getDirItem(null, $this->id, 'jpg');
}
/**
* КОНСТРУКТОР
*/
private function __construct()
{
$this->LOGGER = self::getLogger();
$this->AUTOLOAD = array($this, 'load');
$this->COMMON_EXCLUDED_DI = DirManager::autogen('classpath')->getDirItem(null, 'excluded');
$this->registerBaseDir(self::DIR_KIT, false);
//TODO
$this->registerBaseDir(self::DIR_CLASSES, false);
//TODO
$this->registerBaseDir('kit', false);
}
/**
* КОНСТРУКТОР
*/
private function __construct()
{
$this->LOGGER = self::getLogger();
$this->AUTOLOAD = array($this, 'load');
$this->COMMON_EXCLUDED_DI = DirManager::autogen('classpath')->getDirItem(null, 'excluded');
$this->SDK_SRC_DIR = PS_DIR_INCLUDES . DIR_SEPARATOR . DirManager::DIR_SRC . DIR_SEPARATOR;
/*
* Директория src/common должна быть подключена всегда
*/
$this->registerBaseDir($this->SDK_SRC_DIR . DirManager::DIR_COMMON);
/*
* Если проект, то подключим проектные общие ресурсы
*/
if (ConfigIni::isProject()) {
$this->registerBaseDir(ConfigIni::projectSrcCommonDir(), false);
}
}
function executeProcess(array $argv)
{
PsConnectionPool::assertDisconnectied();
/*
* СОЗДАЁМ SQL
*
* Нам нужны настройки таблиц, которые неоткуда взять, кроме как из базы, поэтому для экспорта данных нужна БД.
* Все данные из "редактируемых" таблиц также загружаются из этой БД.
*/
$DB = DirManager::inst(__DIR__ . '/temp');
$SDK = DirManager::inst(__DIR__ . '/temp/sdk');
//Почистим файлы для удаления
dolog('Clearing not .sql/.txt from temp dir');
/* @var $item DirItem */
foreach ($DB->getDirContentFull(null, DirItemFilter::FILES) as $item) {
if (!$item->checkExtension(array(PsConst::EXT_TXT, PsConst::EXT_SQL))) {
dolog('[-] {}', $item->remove()->getRelPath());
}
}
dolog();
/*
* SDK
*/
//dolog('Processing objects.sql');
/* @var $DIR DirManager */
foreach (array(ENTITY_SCOPE_SDK => $SDK, ENTITY_SCOPE_PROJ => $DB) as $scope => $DM) {
dolog();
dolog('***************************************************************');
dolog('>>> Processing scope [{}], dir: [{}]', $scope, $DM->absDirPath());
$SCHEMA = $DM->getDirItem(null, 'schema.sql');
if (!$SCHEMA->isFile()) {
dolog('schema.sql is not exists, skipping');
continue;
//---
}
$DM_SYSOBJECTS = DirManager::inst($DM->absDirPath(), 'sysobjects');
/*
* Очищаем папку, в которой будет содержимое для автосгенерированных файлов
*/
$DM_AUTO = DirManager::inst($DM_SYSOBJECTS->absDirPath(), 'auto')->clearDir();
/*
* Создадим ссылку на файл с данными, выгруженными из таблиц
*/
$DI_AUTO_DATA = $DM_AUTO->getDirItem(null, 'data.sql');
/*
* Сначала сделаем триггеры на таблицы, от которых зависит кеш и к которым привязаны фолдинги.
*/
LOGBOX_INIT();
LOGBOX('Making cache and folding table triggers');
$DM_AUTO_TRIGGERS = $DM_AUTO->getDirItem('triggers')->makePath();
$DI_AUTO_TRIGGERS_SQL = $DM_AUTO->getDirItem(null, 'triggers', 'sql')->getSqlFileBuilder();
$triggerPattern = $SDK->getDirItem('sysobjects/patterns', 'ta_iud_pattern.sql')->getFileContents();
//BUILDIAN AND ADDING TRIGGERS
foreach (PsTriggersAware::getTriggeredTables($scope) as $table) {
foreach (PsTriggersAware::getActions() as $action) {
$actions = PsTriggersAware::getTriggerActions($table, $scope, $action);
if (empty($actions)) {
continue;
//---
}
$name = 'ta' . strtolower(first_char($action)) . '_' . $table;
$trigger = str_replace('<%NAME%>', $name, $triggerPattern);
$trigger = str_replace('<%TABLE%>', $table, $trigger);
$trigger = str_replace('<%ACTION%>', $action, $trigger);
$trigger = str_replace('<%CALL%>', implode("\n", $actions), $trigger);
dolog("+ {$name}");
foreach ($actions as $_action) {
dolog($_action);
}
$DI_AUTO_TRIGGERS_SQL->appendFile($DM_AUTO_TRIGGERS->getDirItem(null, $name, 'sql')->putToFile($trigger));
}
}
//Все автоматически сгенерированные триггеры положим в отдельный файл
$DI_AUTO_TRIGGERS_SQL->save();
$autoTriggers = DirManager::inst($DM_AUTO_TRIGGERS->getAbsPath())->getDirContent(null, PsConst::EXT_SQL);
dolog('Triggers made: {}', count($autoTriggers));
/*
* objects.sql
*/
$OBJECTS_SQL = $DM_AUTO->getDirItem(null, 'objects.sql')->getSqlFileBuilder();
/*
* Добавляем автосгенерированные триггеры
*/
LOGBOX('Processing objects.sql');
if (empty($autoTriggers)) {
dolog('No auto triggers');
} else {
dolog('Adding {} auto triggers', count($autoTriggers));
$OBJECTS_SQL->appendMlComment('AUTO TRIGGERS SECTION');
/* @var $triggerDi DirItem */
foreach ($autoTriggers as $triggerDi) {
dolog('+ {}', $triggerDi->getName());
$OBJECTS_SQL->appendFile($triggerDi);
}
}
/*
* Получаем строки с включениями
*/
$ALL = $DM_SYSOBJECTS->getDirItem(null, 'all.txt')->getFileLines(false);
if (empty($ALL)) {
dolog('No includes');
} else {
dolog('Adding {} includes from all.txt', count($ALL));
$OBJECTS_SQL->appendMlComment('INCLUDES SECTION');
foreach ($ALL as $include) {
dolog('+ {}', $include);
$OBJECTS_SQL->appendFile($DM_SYSOBJECTS->getDirItem($include));
}
}
$OBJECTS_SQL->save();
/*
* Создаём скрипты инициализации для схем
*/
foreach (PsConnectionParams::getDefaultConnectionNames() as $connection) {
if (PsConnectionParams::has($connection, $scope)) {
$props = PsConnectionParams::get($connection, $scope);
$database = $props->database();
if (empty($database)) {
continue;
//Не задана БД - пропускаем (для root)
}
LOGBOX('Making schema script for {}', $props);
$SCHEMA_SQL = $DM_AUTO->getDirItem('schemas', $database, 'sql')->makePath()->getSqlFileBuilder();
//DROP+USE
$SCHEMA_SQL->clean();
$SCHEMA_SQL->appendLine("DROP DATABASE IF EXISTS {$database};");
$SCHEMA_SQL->appendLine("CREATE DATABASE {$database} CHARACTER SET utf8 COLLATE utf8_general_ci;");
$SCHEMA_SQL->appendLine("USE {$database};");
if ($scope == ENTITY_SCOPE_PROJ) {
dolog('+ SDK PART');
//Добавим секцию в лог
$SCHEMA_SQL->appendMlComment('>>> SDK');
//CREATE CHEMA SCRIPT
$SCHEMA_SQL->appendFile($SDK->getDirItem(null, 'schema.sql'));
//OBJECTS SCRIPT
$SCHEMA_SQL->appendFile($SDK->getDirItem('sysobjects/auto', 'objects.sql'));
//Добавим секцию в лог
$SCHEMA_SQL->appendMlComment('<<< SDK');
}
//CREATE CHEMA SCRIPT
$SCHEMA_SQL->appendFile($SCHEMA);
//OBJECTS SCRIPT
$SCHEMA_SQL->appendFile($OBJECTS_SQL->getDi());
//CREATE USER
$grant = "grant all on {}.* to '{}'@'{}' identified by '{}';";
$SCHEMA_SQL->appendMlComment('Grants');
$SCHEMA_SQL->appendLine(PsStrings::replaceWithBraced($grant, $database, $props->user(), $props->host(), $props->password()));
/*
* Мы должны создать тестовую схему, чтобы убедиться, что всё хорошо и сконфигурировать db.ini
*/
if ($connection == PsConnectionParams::CONN_TEST) {
dolog('Making physical schema {}', $props);
$rootProps = PsConnectionParams::get(PsConnectionParams::CONN_ROOT);
dolog('Root connection props: {}', $rootProps);
$rootProps->execureShell($SCHEMA_SQL->getDi());
dolog('Connecting to [{}]', $props);
PsConnectionPool::configure($props);
$tables = PsTable::all();
/*
* Нам нужно определить новый список таблиц SDK, чтобы по ним
* провести валидацию новых db.ini.
*
* Если мы обрабатываем проект, то SDK-шный db.ini уже готов и
* можем положиться на него. Если мы подготавливаем SDK-шный db.ini,
* но новый список таблиц возмём из развёрнутой тестовой БД.
*/
$sdkTableNames = $scope == ENTITY_SCOPE_SDK ? array_keys($tables) : DbIni::getSdkTables();
if ($scope == ENTITY_SCOPE_PROJ) {
//Уберём из всех таблиц - SDK`шные
array_remove_keys($tables, $sdkTableNames);
}
$scopeTableNames = array_keys($tables);
sort($scopeTableNames);
/*
* Составим список таблиц.
* Он нам особенно не нужен, но всёже будем его формировать для наглядности - какие таблицы добавились.
*/
$tablesDi = $DM_AUTO->getDirItem(null, 'tables.txt')->putToFile(implode("\n", $scopeTableNames));
dolog('Tables: {} saved to {}', print_r($scopeTableNames, true), $tablesDi->getAbsPath());
/*
* Загружаем полный список таблиц схемы и на основе имеющихся db.ini файлов строим новые, добавляя/удаляя
* таблицы, добавленные/удалённые из схемы.
*/
$dbIniProps = PsDbIniHelper::makeDbIniForSchema($scope, $tables);
dolog('db.ini props: {}', print_r($dbIniProps, true));
$dbIniErrors = PsDbIniHelper::validateAndSaveDbIniTableProps($scope, $dbIniProps, $sdkTableNames);
if ($dbIniErrors) {
PsUtil::raise('db.ini errors for {}: {}', $scope, print_r($dbIniErrors, true));
}
/*
* Для проекта выгружаем данные, хранящиеся в файлах
*/
if ($scope == ENTITY_SCOPE_PROJ) {
dolog('Exporting tables data from files');
$DM_AUTO->getDirItem('data')->makePath();
$AUTO_DATA_SQL = $DI_AUTO_DATA->touch()->getSqlFileBuilder();
//Пробегаемся по таблицам
foreach (DbIni::getTables() as $tableName) {
$table = PsTable::inst($tableName);
if ($table->isFilesync()) {
$fileData = $table->exportFileAsInsertsSql();
if ($fileData) {
dolog(' + {}', $tableName);
$AUTO_DATA_SQL->appendFile($DM_AUTO->getDirItem('data', $tableName, 'sql')->putToFile($fileData));
} else {
dolog(' - {}', $tableName);
}
}
}
$AUTO_DATA_SQL->save();
/*
* Вставим данные в тестовую схему
*/
dolog('Inserting data to test schema.');
$props->execureShell($DI_AUTO_DATA);
}
/*
* Теперь ещё создадим тестовые объекты.
* Мы уверены, что для SDK тестовая часть есть всегда.
*/
$TEST_SCHEMA_SQL = $DM_AUTO->getDirItem('test', 'schema', 'sql')->makePath()->getSqlFileBuilder();
if ($scope == ENTITY_SCOPE_PROJ) {
dolog('+ SDK TEST PART');
//Добавим секцию в лог
$TEST_SCHEMA_SQL->appendMlComment('>>> SDK');
//CREATE CHEMA SCRIPT
$TEST_SCHEMA_SQL->appendFile($SDK->getDirItem('sysobjects/auto/test', 'schema.sql'));
//Добавим секцию в лог
$TEST_SCHEMA_SQL->appendMlComment('<<< SDK');
}
$TEST_SCHEMA_SQL->appendFile($DM_SYSOBJECTS->getDirItem('test', 'schema.sql'), false);
$TEST_SCHEMA_SQL->appendFile($DM_SYSOBJECTS->getDirItem('test', 'data.sql'), false);
$TEST_SCHEMA_SQL->save();
/*
* На тестовой схеме прогоняем скрипты с тестовыми данными
*/
dolog('Making test schema objects.');
$props->execureShell($TEST_SCHEMA_SQL->getDi());
}
#end conn== TEST
/*
* Если были сгенерированы данные из файлов - добавляем их
*/
if ($DI_AUTO_DATA->isFile() && $DI_AUTO_DATA->getSize() > 0) {
dolog('Append data inserts to {}', $SCHEMA_SQL->getDi()->getName());
$SCHEMA_SQL->appendFile($DI_AUTO_DATA);
}
//SAVE .sql
$SCHEMA_SQL->save();
}
}
}
dolog('Database schemas successfully exported');
}
public function __construct(DirItem $dir)
{
$this->LOGGER = Autoload::getLogger();
$this->classesDir = $dir;
$this->classPathFile = DirManager::autogen('classpath')->getDirItem(null, unique_from_path($dir->getRelPath()));
}
private function getImages(ArrayAdapter $params, $FNAME)
{
$dir = $params->str('dir');
$name = $params->get('name');
//НЕПОСРЕДСТВЕННО КАРТИНКА
if ($name instanceof DirItem) {
return $name;
}
/*
* FOLDING
*/
$FCW = FoldedContextWatcher::getInstance();
$folding = null;
$ident = $params->get('ident');
//Тип фолдинга. Он может быть передан либо в параметре 'group', либо по префиксу смарти-функции, например: postimg (post-название типа фолдинга).
$foldingType = $params->get('group');
$foldingType = $foldingType ? $foldingType : (starts_with($FNAME, 'img') ? null : array_get_value(0, explode('img', $FNAME)));
//Подтип фолдинга, например: is - подтип фолдингов для фолдингов с типом post (выпуск журнала среди всех постов).
$foldingSubType = $params->get('type');
if ($params->has('post')) {
/* @var $post AbstractPost */
$post = $params->get('post');
$ident = $post->getIdent();
$folding = Handlers::getInstance()->getPostsProcessorByPostType($post->getPostType())->getFolding();
} else {
if ($foldingType) {
$hasSubtype = FoldedStorage::isFoldingHasSubtype($foldingType);
if ($hasSubtype && !$foldingSubType) {
//У фолдинга есть подтип, но в параметрах он не передан - определим фолдинг по контексту
$folding = $FCW->getFoldedEntityEnsureType($foldingType)->getFolding();
} else {
$folding = FoldedStorageInsts::byTypeStype($foldingType, $foldingSubType);
}
} else {
if ($foldingSubType) {
//Если передан только тип, то считаем, что имеется ввиду фолдинг поста
$folding = Handlers::getInstance()->getPostsProcessorByPostType($foldingSubType)->getFolding();
}
}
}
if ($folding && !$ident) {
//У нас есть фолдинг, но нет идентификатора сущности - определим её из контекста
$ident = $FCW->getFoldedEntityEnsureType($folding->getFoldingType())->getIdent();
}
if (!$dir && !$name && $ident && $folding) {
/*
* Не передано название картинки, но передан идентификатор сущности - показываем cover.
* TODO - подумать, возможно имеет смысл сделать возможность показывать любую картинку в заданном размере.
*/
return $folding->getCover($ident, $params->str('dim'));
}
/*
* Берём путь "как есть", если:
* 1. Передан специальный параметр asis
* 2. Передана dir, и она начинается с '/'
* 3. Не передана dir, но при этом name начинается с '/'
* 4. dir или name указывают на адрес в интернете
*/
$asis = $params->bool('asis') || starts_with($dir, DIR_SEPARATOR) || !$dir && starts_with($name, DIR_SEPARATOR) || PsUrl::isHttp($dir) || PsUrl::isHttp($name);
if ($asis) {
if (!$dir) {
return $name;
}
if (starts_with($name, DIR_SEPARATOR)) {
return cut_string_end($dir, DIR_SEPARATOR) . $name;
}
return ($name ? ensure_ends_with($dir, DIR_SEPARATOR) : $dir) . $name;
}
/** @var DirManager */
$DM = null;
/*
* Теперь определим DirManager. Мы его можем взять:
*/
if ($folding) {
//1. Из ресурсов фолдинга
$DM = $folding->getResourcesDm($ident, 'src');
} else {
//2. Обычный resources->images, если фолдинг не установлен
$DM = DirManager::images();
}
/*
* Определим список показываемых картинок по атрибуту $name. Пример тега:
* {postimg type='tr' ident='matrix' name='mao.gif mu.png mu.png'}
* Просто разделим значение атрибута $name по точкам и пробелам и склеим в названия картинок.
*/
$NAMES = preg_split("/[. ]/", $name);
$DI = $DM ? $DM->getDirItem($dir, $name) : DirItem::inst($dir, $name);
if (count($NAMES) % 2 != 0 || $DI->isImg()) {
//Указано что-то непонятное - не чётное кол-во составных элементов
return $DI;
}
$IMAGES = array();
for ($i = 0; $i < count($NAMES); $i += 2) {
$imgName = $NAMES[$i] . '.' . $NAMES[$i + 1];
$IMAGES[] = $DM ? $DM->getDirItem($dir, $imgName) : DirItem::inst($dir, $imgName);
}
return $IMAGES;
}
/**
* Метод создаёт новый фолдинг
*/
public function makeNewFolding(ArrayAdapter $adapter)
{
$ifaces = $adapter->arr('ifaces');
$rtypes = $adapter->arr('rtypes');
$type = lowertrim($adapter->str('FoldingType'));
$subtype = lowertrim($adapter->str('FoldingSubType'));
$group = $adapter->str('FoldingGroup');
$classPrefix = $adapter->str('FoldingClassPrefix');
check_condition($type, 'Не передан тип фолдинга');
check_condition($group, 'Не передана группа для фолдинга');
check_condition($classPrefix, 'Не передан префикс для классов фолдинга');
//TODO - определять директорию для воздания менеджера фолдингов.
die('Folding dir is not deffined.');
$classesDi = DirItem::inst(array('sdk/kit', 'folded'), $group);
check_condition(!$classesDi->isDir(), "Директория {$classesDi} уже существует");
check_condition(!$classesDi->isFile(), "Элемент {$classesDi} не может быть файлом");
$rtypes = array_intersect(array_keys(PsUtil::getClassConsts('FoldedResources', 'RTYPE_')), $rtypes);
$rtypesArr = trim(implode(', self::', $rtypes));
$rtypesArr = $rtypesArr ? "self::{$rtypesArr}" : '';
$hasPhp = in_array('RTYPE_PHP', $rtypes);
$classesDm = DirManager::inst($classesDi->getRelPath())->makePath();
$resourcesPatternDmTo = DirManager::resources(array('folded', $group, FoldedResources::PATTERN_NAME));
check_condition(!$resourcesPatternDmTo->isDir(), "Целевая директория {$resourcesPatternDmTo} существует");
$resourcesPatternDmFrom = DirManager::resources(array('folded', FoldedResources::PATTERN_NAME));
check_condition($resourcesPatternDmFrom->isDir(), "Некорректна директория-источник {$resourcesPatternDmFrom}");
$interfaces = array();
foreach ($this->getFoldedInterfaces($ifaces) as $name => $ifaceClass) {
$ctt = $ifaceClass->getClassBody();
if ($ctt) {
$interfaces[] = "/****************\n\t * {$name}\n\t ****************/\n" . $ctt;
}
}
$smParams = $adapter->getData();
$smParams['rtypes'] = $rtypesArr;
$smParams['funique'] = FoldedResources::unique($type, $subtype);
$smParams['BaseClass'] = 'Base' . $classPrefix;
$smParams['ManagerClass'] = $classPrefix . 'Manager';
$smParams['ResourcesClass'] = $classPrefix . 'Resources';
$smParams['implements'] = $ifaces ? 'implements ' . implode(', ', $ifaces) . ' ' : '';
$smParams['interfaces'] = $interfaces ? implode("\n\n\t", $interfaces) : '';
try {
//КЛАССЫ
//Resources
$tpl = PSSmarty::template(DirItem::inst(array(__DIR__, 'tpls'), 'resources.tpl'), $smParams);
$di = $classesDm->getDirItem(null, $smParams['ResourcesClass'], 'php');
$di->writeToFile(trim($tpl->fetch()), true);
//Manager
$tpl = PSSmarty::template(DirItem::inst(array(__DIR__, 'tpls'), 'manager.tpl'), $smParams);
$di = $classesDm->getDirItem(null, $smParams['ManagerClass'], 'php');
$di->writeToFile(trim($tpl->fetch()), true);
if ($hasPhp) {
//BaseClass
$tpl = PSSmarty::template(DirItem::inst(array(__DIR__, 'tpls'), 'baseclass.tpl'), $smParams);
$di = $classesDm->getDirItem(null, $smParams['BaseClass'], 'php');
$di->writeToFile(trim($tpl->fetch()), true);
}
//ШАБЛОН ДЛЯ СУЩНОСТЕЙ
$resourcesPatternDmTo->makePath();
foreach ($rtypes as $rtype) {
$ext = FoldedResources::resourceTypeToExt(PsUtil::newReflectionClass('FoldedResources')->getConstant($rtype));
$diTo = $resourcesPatternDmTo->getDirItem(null, FoldedResources::PATTERN_NAME, $ext);
$diFrom = $resourcesPatternDmFrom->getDirItem(null, FoldedResources::PATTERN_NAME, $ext);
if ($ext == PsConst::EXT_PHP) {
$diTo->writeToFile(str_replace('eclassnamebase', $smParams['BaseClass'], $diFrom->getFileContents()));
continue;
}
$diFrom->copyTo($diTo);
}
} catch (Exception $ex) {
$classesDm->clearDir(null, true);
$resourcesPatternDmTo->clearDir(null, true);
throw $ex;
}
}
/**
* Основной метод, выполняющий загрузку содержимого тестовой страницы
*/
private function getContentImpl(RequestArrayAdapter $params, Smarty $smarty)
{
//Силовые упражнения
$exId = $params->int('ex_id');
if ($exId) {
//$ex = GymManager::getInstance()->getExercise($exId);
$tplPath = "gym/exercises/{$exId}.tpl";
return $smarty->templateExists($tplPath) ? $smarty->fetch($tplPath) : null;
}
//Специальные страницы
$pageType = $params->str('pagetype');
if ($pageType) {
$smParams = array();
switch ($pageType) {
case 'smarty':
foreach (array('blocks', 'functions', 'modifiers') as $type) {
$items = DirManager::smarty('plugins/' . $type)->getDirContentFull(null, PsConst::EXT_PHP);
/* @var $item DirItem */
foreach ($items as $item) {
//Название
$name = explode('.', $item->getName());
$name = $name[1];
//Первый комментарий
$tokens = token_get_all($item->getFileContents());
$comment = array(T_COMMENT, T_DOC_COMMENT);
$fileComment = '';
foreach ($tokens as $token) {
if (in_array($token[0], $comment)) {
$fileComment = trim($token[1]);
break;
}
}
$smParams[$type][] = array('name' => $name, 'comment' => $fileComment);
}
}
break;
case 'doubleimg':
$images = DirManager::images()->getDirContentFull(null, DirItemFilter::IMAGES);
$sorted = array();
/* @var $img DirItem */
foreach ($images as $img) {
$ident = $img->getSize() . 'x' . $img->getImageAdapter()->getWidth() . 'x' . $img->getImageAdapter()->getHeight();
$sorted[$ident][] = $img;
}
$result = array();
/* @var $img DirItem */
foreach ($sorted as $ident => $imgs) {
if (count($imgs) > 1) {
$result[$ident] = $imgs;
}
}
$smParams = array('images' => $result);
break;
case 'testmethods':
$smParams['methods'] = TestManagerCaller::getMethodsList();
break;
case 'imgbysize':
$images = DirManager::images()->getDirContentFull(null, DirItemFilter::IMAGES, array('GymExercises'));
DirItemSorter::inst()->sort($images, DirItemSorter::BY_SIZE);
$smParams = array('images' => $images);
break;
case 'formules':
$formules = TexImager::inst()->getAllFormules();
$totalSize = 0;
/* @var $formula DirItem */
foreach ($formules as $formula) {
$totalSize += $formula->getSize();
$formula->setData('class', 'TeX');
}
DirItemSorter::inst()->sort($formules, DirItemSorter::BY_SIZE);
$smParams = array('formules' => $formules, 'formules_size' => $totalSize);
break;
}
$content = $smarty->fetch("test/page_{$pageType}.tpl", $smParams);
if ($pageType) {
switch ($pageType) {
case 'patterns':
$out = array();
preg_match_all("/===(.*?)===/", $content, $out, PREG_PATTERN_ORDER);
$params = array();
for ($i = 0; $i < count($out[0]); $i++) {
$full = $out[0][$i];
$ctt = $out[1][$i];
$params[$full] = "<div class=\"demo-head\">{$ctt}</div>";
}
$content = PsStrings::replaceMap($content, $params);
}
}
return $content;
}
//Тестовая страница
$num = $params->int('num');
$num = $num ? $num : 1;
return $smarty->fetch("test/page{$num}.tpl");
}
