PKPSiteService.inc.php

<?php
namespace PKP\Services;
 
use \Application;
use \DAORegistry;
use \Services;
use \PKP\Services\interfaces\EntityPropertyInterface;
 
class PKPSiteService implements EntityPropertyInterface {
 
   public function getProperties($site, $props, $args = null) {
      $request = $args['request'];
      $router = $request->getRouter();
      $dispatcher = $request->getDispatcher();
 
      $values = array();
      foreach ($props as $prop) {
         $values[$prop] = $site->getData($prop);
      }
 
      $values = Services::get('schema')->addMissingMultilingualValues(SCHEMA_SITE, $values, $site->getSupportedLocales());
 
      \HookRegistry::call('Site::getProperties', array(&$values, $site, $props, $args));
 
      ksort($values);
 
      return $values;
   }
 
   public function getSummaryProperties($site, $args = null) {
      return $this->getFullProperties($site, $args);
   }
 
   public function getFullProperties($site, $args = null) {
      $props = Services::get('schema')->getFullProps(SCHEMA_SITE);
 
      return $this->getProperties($site, $props, $args);
   }
 
   public function validate($props, $allowedLocales, $primaryLocale) {
      \AppLocale::requireComponents(
         LOCALE_COMPONENT_PKP_ADMIN,
         LOCALE_COMPONENT_APP_ADMIN,
         LOCALE_COMPONENT_PKP_MANAGER,
         LOCALE_COMPONENT_APP_MANAGER
      );
      $schemaService = Services::get('schema');
 
      import('lib.pkp.classes.validation.ValidatorFactory');
      $validator = \ValidatorFactory::make(
         $props,
         $schemaService->getValidationRules(SCHEMA_SITE, $allowedLocales),
         [
            'primaryLocale.regex' => __('validator.localeKey'),
            'supportedLocales.regex' => __('validator.localeKey'),
         ]
      );
 
      // Check required fields
      \ValidatorFactory::required(
         $validator,
         VALIDATE_ACTION_EDIT,
         $schemaService->getRequiredProps(SCHEMA_PUBLICATION),
         $schemaService->getMultilingualProps(SCHEMA_PUBLICATION),
         $allowedLocales,
         $primaryLocale
      );
 
      // Check for input from disallowed locales
      \ValidatorFactory::allowedLocales(
         $validator,
         $schemaService->getMultilingualProps(SCHEMA_SITE),
         $allowedLocales
      );
 
      // If a new file has been uploaded, check that the temporary file exists and
      // the current user owns it
      $user = Application::get()->getRequest()->getUser();
      \ValidatorFactory::temporaryFilesExist(
         $validator,
         ['pageHeaderTitleImage', 'styleSheet'],
         ['pageHeaderTitleImage'],
         $props,
         $allowedLocales,
         $user ? $user->getId() : null
      );
 
      // If sidebar blocks are passed, ensure the block plugin exists and is
      // enabled
      $validator->after(function($validator) use ($props) {
         if (!empty($props['sidebar']) && !$validator->errors()->get('sidebar')) {
            $plugins = \PluginRegistry::loadCategory('blocks', true);
            foreach ($props['sidebar'] as $pluginName) {
               if (empty($plugins[$pluginName])) {
                  $validator->errors()->add('sidebar', __('manager.setup.layout.sidebar.invalidBlock', ['name' => $pluginName]));
               }
            }
         }
      });
 
      // Ensure the theme plugin is installed and enabled
      $validator->after(function($validator) use ($props) {
         if (!empty($props['themePluginPath']) && !$validator->errors()->get('themePluginPath')) {
            $plugins = \PluginRegistry::loadCategory('themes', true);
            $found = false;
            foreach ($plugins as $plugin) {
               if ($props['themePluginPath'] === $plugin->getDirName()) {
                  $found = true;
                  break;
               }
            }
            if (!$found) {
               $validator->errors()->add('themePluginPath', __('manager.setup.theme.notFound'));
            }
         }
      });
 
      if ($validator->fails()) {
         $errors = $schemaService->formatValidationErrors($validator->errors(), $schemaService->get(SCHEMA_SITE), $allowedLocales);
      }
 
      \HookRegistry::call('Site::validate', array(&$errors, $props, $allowedLocales, $primaryLocale));
 
      return $errors;
   }
 
   public function edit($site, $params, $request) {
      $siteDao = DAORegistry::getDAO('SiteDAO'); /* @var $siteDao SiteDAO */
 
      // Move uploaded files into place and update the params
      $userId = $request->getUser() ? $request->getUser()->getId() : null;
      $supportedLocales = $site->getSupportedLocales();
      if (array_key_exists('pageHeaderTitleImage', $params)) {
         foreach ($supportedLocales as $localeKey) {
            if (!array_key_exists($localeKey, $params['pageHeaderTitleImage'])) {
               continue;
            }
            $params['pageHeaderTitleImage'][$localeKey] = $this->_saveFileParam($site, $params['pageHeaderTitleImage'][$localeKey], 'pageHeaderTitleImage', $userId, $localeKey, true);
         }
      }
      if (array_key_exists('styleSheet', $params)) {
         $params['styleSheet'] = $this->_saveFileParam($site, $params['styleSheet'], 'styleSheet', $userId);
      }
 
      $newSite = $siteDao->newDataObject();
      $newSite->_data = array_merge($site->_data, $params);
 
      \HookRegistry::call('Site::edit', array($newSite, $site, $params, $request));
 
      $siteDao->updateObject($newSite);
      $newSite = $siteDao->getSite();
 
      return $newSite;
   }
 
   public function moveTemporaryFile($context, $temporaryFile, $fileNameBase, $userId, $localeKey = '') {
      import('classes.file.PublicFileManager');
      $publicFileManager = new \PublicFileManager();
      import('lib.pkp.classes.file.TemporaryFileManager');
      $temporaryFileManager = new \TemporaryFileManager();
 
      $fileName = $fileNameBase;
      if ($localeKey) {
         $fileName .= '_' . $localeKey;
      }
 
      $extension = $publicFileManager->getDocumentExtension($temporaryFile->getFileType());
      if (!$extension) {
         $extension = $publicFileManager->getImageExtension($temporaryFile->getFileType());
      }
      $fileName .= $extension;
 
      if (!$publicFileManager->copyFile($temporaryFile->getFilePath(), $publicFileManager->getSiteFilesPath() . '/' . $fileName)) {
         return false;
      }
 
      $temporaryFileManager->deleteById($temporaryFile->getId(), $userId);
 
      return $fileName;
   }
 
   protected function _saveFileParam($site, $value, $settingName, $userId, $localeKey = '', $isImage = false) {
      import('lib.pkp.classes.file.TemporaryFileManager');
      $temporaryFileManager = new \TemporaryFileManager();
 
      // If the value is null, clean up any existing file in the system
      if (is_null($value)) {
         $setting = $site->getData($settingName, $localeKey);
         if ($setting) {
            $fileName = $isImage ? $setting['uploadName'] : $setting;
            import('classes.file.PublicFileManager');
            $publicFileManager = new \PublicFileManager();
            $publicFileManager->removeSiteFile($fileName);
         }
         return null;
      }
 
      // Check if there is something to upload
      if (empty($value['temporaryFileId'])) {
         return $value;
      }
 
      $temporaryFile = $temporaryFileManager->getFile((int) $value['temporaryFileId'], $userId);
      $fileName = $this->moveTemporaryFile($site, $temporaryFile, $settingName, $userId, $localeKey);
 
      if ($fileName) {
         // Get the details for image uploads
         if ($isImage) {
            import('classes.file.PublicFileManager');
            $publicFileManager = new \PublicFileManager();
 
            list($width, $height) = getimagesize($publicFileManager->getSiteFilesPath() . '/' . $fileName);
            $altText = !empty($value['altText']) ? $value['altText'] : '';
 
            return [
               'originalFilename' => $temporaryFile->getOriginalFileName(),
               'uploadName' => $fileName,
               'width' => $width,
               'height' => $height,
               'dateUploaded' => \Core::getCurrentDate(),
               'altText' => $altText,
            ];
         } else {
            return [
               'originalFilename' => $temporaryFile->getOriginalFileName(),
               'uploadName' => $fileName,
               'dateUploaded' => \Core::getCurrentDate(),
            ];
         }
      }
 
      return false;
   }
}