function index()
{
$this->validate();
PluginRegistry::loadCategory('oaiMetadataFormats', true);
$oai = new JournalOAI(new OAIConfig(Request::getRequestUrl(), Config::getVar('oai', 'repository_id')));
$oai->execute();
}
/**
* Constructor
**/
function CustomLocaleHandler($parentPluginName)
{
parent::Handler();
$this->addCheck(new HandlerValidatorJournal($this));
$this->addCheck(new HandlerValidatorRoles($this, true, null, null, array(ROLE_ID_SITE_ADMIN, ROLE_ID_MANAGER)));
$this->plugin = PluginRegistry::getPlugin('generic', $parentPluginName);
}
/**
* Constructor
* @param $plugin MedraExportPlugin
* @param $contextId integer
*/
function MedraSettingsForm($plugin, $contextId)
{
$this->_contextId = $contextId;
$this->_plugin = $plugin;
parent::Form($plugin->getTemplatePath() . 'settingsForm.tpl');
// DOI plugin settings action link
$pubIdPlugins = PluginRegistry::loadCategory('pubIds', true);
if (isset($pubIdPlugins['doipubidplugin'])) {
$application = PKPApplication::getApplication();
$request = $application->getRequest();
$dispatcher = $application->getDispatcher();
import('lib.pkp.classes.linkAction.request.AjaxModal');
$doiPluginSettingsLinkAction = new LinkAction('settings', new AjaxModal($dispatcher->url($request, ROUTE_COMPONENT, null, 'grid.settings.plugins.SettingsPluginGridHandler', 'manage', null, array('plugin' => 'doipubidplugin', 'category' => 'pubIds')), __('plugins.importexport.common.settings.DOIPluginSettings')), __('plugins.importexport.common.settings.DOIPluginSettings'), null);
$this->setData('doiPluginSettingsLinkAction', $doiPluginSettingsLinkAction);
}
// Add form validation checks.
$this->addCheck(new FormValidator($this, 'registrantName', FORM_VALIDATOR_REQUIRED_VALUE, 'plugins.importexport.medra.settings.form.registrantNameRequired'));
$this->addCheck(new FormValidator($this, 'fromCompany', FORM_VALIDATOR_REQUIRED_VALUE, 'plugins.importexport.medra.settings.form.fromCompanyRequired'));
$this->addCheck(new FormValidator($this, 'fromName', FORM_VALIDATOR_REQUIRED_VALUE, 'plugins.importexport.medra.settings.form.fromNameRequired'));
$this->addCheck(new FormValidatorEmail($this, 'fromEmail', FORM_VALIDATOR_REQUIRED_VALUE, 'plugins.importexport.medra.settings.form.fromEmailRequired'));
$this->addCheck(new FormValidatorInSet($this, 'exportIssuesAs', FORM_VALIDATOR_REQUIRED_VALUE, 'plugins.importexport.medra.settings.form.exportIssuesAs', array(O4DOI_ISSUE_AS_WORK, O4DOI_ISSUE_AS_MANIFESTATION)));
$this->addCheck(new FormValidatorInSet($this, 'publicationCountry', FORM_VALIDATOR_REQUIRED_VALUE, 'plugins.importexport.medra.settings.form.publicationCountry', array_keys($this->_getCountries())));
// The username is used in HTTP basic authentication and according to RFC2617 it therefore may not contain a colon.
$this->addCheck(new FormValidatorRegExp($this, 'username', FORM_VALIDATOR_OPTIONAL_VALUE, 'plugins.importexport.medra.settings.form.usernameRequired', '/^[^:]+$/'));
$this->addCheck(new FormValidatorPost($this));
}
/**
* Register the article's metadata with the SWORD deposit.
*/
function setMetadata()
{
$this->package->setCustodian($this->journal->getSetting('contactName'));
$this->package->setTitle(html_entity_decode($this->article->getTitle($this->journal->getPrimaryLocale()), ENT_QUOTES, 'UTF-8'));
$this->package->setAbstract(html_entity_decode(strip_tags($this->article->getAbstract($this->journal->getPrimaryLocale())), ENT_QUOTES, 'UTF-8'));
$this->package->setType($this->section->getIdentifyType($this->journal->getPrimaryLocale()));
// The article can be published or not. Support either.
if (is_a($this->article, 'PublishedArticle')) {
$doi = $this->article->getPubId('doi');
if ($doi !== null) {
$this->package->setIdentifier($doi);
}
}
foreach ($this->article->getAuthors() as $author) {
$creator = $author->getFullName(true);
$affiliation = $author->getAffiliation($this->journal->getPrimaryLocale());
if (!empty($affiliation)) {
$creator .= "; {$affiliation}";
}
$this->package->addCreator($creator);
}
// The article can be published or not. Support either.
if (is_a($this->article, 'PublishedArticle')) {
$plugin =& PluginRegistry::loadPlugin('citationFormats', 'bibtex');
$this->package->setCitation(html_entity_decode(strip_tags($plugin->fetchCitation($this->article, $this->issue, $this->journal)), ENT_QUOTES, 'UTF-8'));
}
}
/**
* Constructor.
*/
function OAIDAO()
{
parent::DAO();
$this->archiveDao =& DAORegistry::getDAO('ArchiveDAO');
$this->recordDao =& DAORegistry::getDAO('RecordDAO');
PluginRegistry::loadCategory('schemas');
}
/**
* @copydoc Form::fetch()
*/
function fetch($request)
{
$templateMgr = TemplateManager::getManager($request);
$pubIdPlugins = PluginRegistry::loadCategory('pubIds', true, $this->getContextId());
$templateMgr->assign(array('pubIdPlugins' => $pubIdPlugins, 'pubObject' => $this->getPubObject(), 'approval' => $this->getApproval(), 'confirmationText' => $this->getConfirmationText()));
return parent::fetch($request);
}
/**
* Get a public ID for this galley.
* @param $pubIdType string One of the NLM pub-id-type values or
* 'other::something' if not part of the official NLM list
* (see <http://dtd.nlm.nih.gov/publishing/tag-library/n-4zh0.html>).
* @param $preview boolean If true, generate a non-persisted preview only.
*/
function getPubId($pubIdType, $preview = false)
{
// FIXME: Move publisher-id to PID plug-in.
if ($pubIdType === 'publisher-id') {
$pubId = $this->getStoredPubId($pubIdType);
return $pubId ? $pubId : null;
}
// Retrieve the article.
$articleDao = DAORegistry::getDAO('ArticleDAO');
/* @var $articleDao ArticleDAO */
$article = $articleDao->getById($this->getArticleId(), null, true);
if (!$article) {
return null;
}
$pubIdPlugins = PluginRegistry::loadCategory('pubIds', true, $article->getJournalId());
foreach ($pubIdPlugins as $pubIdPlugin) {
if ($pubIdPlugin->getPubIdType() == $pubIdType) {
// If we already have an assigned ID, use it.
$storedId = $this->getStoredPubId($pubIdType);
if (!empty($storedId)) {
return $storedId;
}
return $pubIdPlugin->getPubId($this, $preview);
}
}
return null;
}
/**
* Perform plugin-specific management functions.
* @param $args array
* @param $request object
*/
function plugin($args, &$request)
{
$category = array_shift($args);
$plugin = array_shift($args);
$verb = array_shift($args);
$this->validate();
$this->setupTemplate(true);
$plugins =& PluginRegistry::loadCategory($category);
$message = $messageParams = null;
$pluginObject = null;
if (isset($plugins[$plugin])) {
$pluginObject = $plugins[$plugin];
}
if (is_null($pluginObject)) {
$request->redirect(null, null, 'plugins', array($category));
}
if (!$pluginObject->manage($verb, $args, $message, $messageParams, $request)) {
HookRegistry::call('PluginHandler::plugin', array($verb, $args, $message, $messageParams, $pluginObject));
if ($message) {
$user =& $request->getUser();
import('classes.notification.NotificationManager');
$notificationManager = new NotificationManager();
$notificationManager->createTrivialNotification($user->getId(), $message, $messageParams);
}
$request->redirect(null, null, 'plugins', array($category));
}
}
/**
* Fetch the HTML contents of the form.
* @param $request PKPRequest
* return string
*/
function fetch($request)
{
$monograph = $this->getMonograph();
$press = $request->getPress();
$templateMgr = TemplateManager::getManager($request);
$templateMgr->assign('submissionId', $monograph->getId());
$templateMgr->assign('representationId', (int) $this->getPublicationFormatId());
$templateMgr->assign('isPhysicalFormat', (bool) $this->getPhysicalFormat());
// included to load format-specific template
$templateMgr->assign('stageId', $this->getStageId());
$templateMgr->assign('formParams', $this->getFormParams());
$templateMgr->assign('submissionApproved', $monograph->getDatePublished());
$onixCodelistItemDao = DAORegistry::getDAO('ONIXCodelistItemDAO');
// Check if e-commerce is available
import('classes.payment.omp.OMPPaymentManager');
$ompPaymentManager = new OMPPaymentManager($request);
if ($ompPaymentManager->isConfigured()) {
$templateMgr->assign('paymentConfigured', true);
$templateMgr->assign('currency', $press->getSetting('currency'));
}
// get the lists associated with the select elements on these publication format forms.
$codes = array('productCompositionCodes' => 'List2', 'measurementUnitCodes' => 'List50', 'weightUnitCodes' => 'List95', 'measurementTypeCodes' => 'List48', 'productFormDetailCodes' => 'List175', 'productAvailabilityCodes' => 'List65', 'technicalProtectionCodes' => 'List144', 'returnableIndicatorCodes' => 'List66', 'countriesIncludedCodes' => 'List91');
foreach ($codes as $templateVarName => $list) {
$templateMgr->assign_by_ref($templateVarName, $onixCodelistItemDao->getCodes($list));
}
// consider public identifiers
$pubIdPlugins = PluginRegistry::loadCategory('pubIds', true);
$templateMgr->assign('pubIdPlugins', $pubIdPlugins);
// Notification options.
$notificationRequestOptions = array(NOTIFICATION_LEVEL_NORMAL => array(NOTIFICATION_TYPE_CONFIGURE_PAYMENT_METHOD => array(ASSOC_TYPE_PRESS, $press->getId()), NOTIFICATION_TYPE_FORMAT_NEEDS_APPROVED_SUBMISSION => array(ASSOC_TYPE_MONOGRAPH, $monograph->getId())), NOTIFICATION_LEVEL_TRIVIAL => array());
$templateMgr->assign('notificationRequestOptions', $notificationRequestOptions);
return parent::fetch($request);
}
function index($args, $request)
{
$this->validate();
PluginRegistry::loadCategory('oaiMetadataFormats', true);
$oai = new JournalOAI(new OAIConfig($request->url(null, 'oai'), Config::getVar('oai', 'repository_id')));
$oai->execute();
}
/**
* For 2.3 upgrade: Add initial plugin data to versions table
* @return boolean
*/
function addPluginVersions()
{
$versionDao =& DAORegistry::getDAO('VersionDAO');
import('site.VersionCheck');
$categories = PluginRegistry::getCategories();
foreach ($categories as $category) {
PluginRegistry::loadCategory($category, true);
$plugins = PluginRegistry::getPlugins($category);
foreach ($plugins as $plugin) {
$versionFile = $plugin->getPluginPath() . '/version.xml';
if (FileManager::fileExists($versionFile)) {
$versionInfo =& VersionCheck::parseVersionXML($versionFile);
$pluginVersion = $versionInfo['version'];
$pluginVersion->setCurrent(1);
$versionDao->insertVersion($pluginVersion);
} else {
$pluginVersion = new Version();
$pluginVersion->setMajor(1);
$pluginVersion->setMinor(0);
$pluginVersion->setRevision(0);
$pluginVersion->setBuild(0);
$pluginVersion->setDateInstalled(Core::getCurrentDate());
$pluginVersion->setCurrent(1);
$pluginVersion->setProductType('plugins.' . $category);
$pluginVersion->setProduct(basename($plugin->getPluginPath()));
$versionDao->insertVersion($pluginVersion);
}
}
}
}
/**
* Test locales.
*/
function execute()
{
// Flush the file cache just to be certain we're using
// the most recent stuff
import('cache.CacheManager');
$cacheManager =& CacheManager::getManager();
$cacheManager->flush('locale');
// Load plugins so that their locale data is included too
$plugins = array();
foreach (PluginRegistry::getCategories() as $category) {
echo "Loading plugin category \"{$category}\"...\n";
$morePlugins = PluginRegistry::loadCategory($category);
if (is_array($morePlugins)) {
$plugins += $morePlugins;
}
}
foreach (Locale::getAllLocales() as $locale => $name) {
if (!empty($this->locales) && !in_array($locale, $this->locales)) {
continue;
}
if ($locale != MASTER_LOCALE) {
echo "Testing locale \"{$name}\" ({$locale}) against reference locale " . MASTER_LOCALE . ".\n";
$this->testLocale($locale, MASTER_LOCALE, $plugins);
$this->testEmails($locale, MASTER_LOCALE);
}
}
}
/**
* Harvest archives.
*
* NB: This handler method is meant to be called by the parallel
* processing framework (see ProcessDAO::spawnProcesses()). Executing
* this handler in parallel will significantly improve harvesting
* performance.
*
* The 'harvesting_checking_max_processes' config parameter limits
* the number of parallel processes that can be started in parallel.
*
* @param $args array
* @param $request PKPRequest
*/
function harvest($args, $request)
{
// This is potentially a long running request. So
// give us unlimited execution time.
ini_set('max_execution_time', 0);
// Get the process id.
$processId = $args['authToken'];
// Run until all archives have been harvested.
$processDao = DAORegistry::getDAO('ProcessDAO');
$archiveDao = DAORegistry::getDAO('ArchiveDAO');
$plugins = PluginRegistry::loadCategory('harvesters');
do {
// Check that the process lease has not expired.
$continue = $processDao->canContinue($processId);
if ($continue) {
$process = $processDao->getObjectById($processId);
$archive = $archiveDao->getNextFlaggedArchive($request, $processId);
if (!$archive) {
$continue = false;
} else {
$plugin = $plugins[$archive->getHarvesterPluginName()];
$plugin->updateIndex($archive, $process->getAdditionalData());
}
}
} while ($continue);
// Free the process slot.
$processDao->deleteObjectById($processId);
// This request returns just a (private) status message.
return 'Done!';
}
/**
* Logs in to the system
*
* @param $username string The username
* @param $password strint The password
* @return string
*/
public function login($username, $password)
{
@session_destroy();
@session_start();
$password = md5($password);
$msg = "";
$pru = PluginRegistry::getInstance();
$login = $pru->getPlugin("Login Plugin");
$result = $login->SOAPLogin($username, $password);
return session_id();
switch ($result) {
case 200:
$msg = "Logged in successfully";
break;
case 402:
$msg = "There was an error while trying to login; your username is blocked";
break;
case 403:
$msg = "Incorrect username/password combination";
break;
case 500:
$msg = "There was an error on the server, please try later";
break;
default:
$msg = "Incorrect username/password combination";
break;
}
return $msg;
}
function index()
{
$this->validate();
PluginRegistry::loadCategory('schemas');
$oai = new ArchiveOAI(new OAIConfig(Request::getRequestUrl(), Config::getVar('oai', 'repository_id')));
$oai->execute();
}
/**
* Executes the metadata plug-in test.
* @param $pluginDir string
* @param $pluginName string
* @param $filterGroups array
* @param $controlledVocabs array
*/
protected function executeMetadataPluginTest($pluginDir, $pluginName, $filterGroups, $controlledVocabs)
{
// Make sure that the vocab xml configuration is valid.
$controlledVocabFile = 'plugins/metadata/' . $pluginDir . '/schema/' . METADATA_PLUGIN_VOCAB_DATAFILE;
$this->validateXmlConfig(array('./' . $controlledVocabFile, './lib/pkp/' . $controlledVocabFile));
// Delete vocab data so that we can re-install it.
$controlledVocabDao = DAORegistry::getDAO('ControlledVocabDAO');
/* @var $controlledVocabDao ControlledVocabDAO */
foreach ($controlledVocabs as $controlledVocabSymbolic) {
$controlledVocab = $controlledVocabDao->getBySymbolic($controlledVocabSymbolic, 0, 0);
if ($controlledVocab) {
$controlledVocabDao->deleteObject($controlledVocab);
}
}
// Reset the plug-in setting indicating that vocabs have already been installed.
$pluginSettingsDao = DAORegistry::getDAO('PluginSettingsDAO');
/* @var $pluginSettingsDao PluginSettingsDAO */
$pluginSettingsDao->updateSetting(0, $pluginName, METADATA_PLUGIN_VOCAB_INSTALLED_SETTING, false);
// Unregister the plug-in so that we're sure it will be registered again.
$plugins =& PluginRegistry::getPlugins();
unset($plugins['metadata'][$pluginName]);
$this->executePluginTest('metadata', $pluginDir, $pluginName, $filterGroups);
// Test whether the controlled vocabs have been installed.
foreach ($controlledVocabs as $controlledVocab) {
self::assertInstanceOf('ControlledVocab', $controlledVocabDao->getBySymbolic($controlledVocab, 0, 0));
}
}
/**
* @copydoc MultipleListsListbuilderHandler::setListsData()
*/
function setListsData($request, $filter)
{
$leftBlockPlugins = $disabledBlockPlugins = $rightBlockPlugins = array();
$plugins =& PluginRegistry::loadCategory('blocks');
foreach ($plugins as $key => $junk) {
if (!$plugins[$key]->getEnabled() || $plugins[$key]->getBlockContext() == '') {
if (count(array_intersect($plugins[$key]->getSupportedContexts(), array(BLOCK_CONTEXT_LEFT_SIDEBAR, BLOCK_CONTEXT_RIGHT_SIDEBAR))) > 0) {
$disabledBlockPlugins[$key] =& $plugins[$key];
}
} else {
switch ($plugins[$key]->getBlockContext()) {
case BLOCK_CONTEXT_LEFT_SIDEBAR:
$leftBlockPlugins[$key] =& $plugins[$key];
break;
case BLOCK_CONTEXT_RIGHT_SIDEBAR:
$rightBlockPlugins[$key] =& $plugins[$key];
break;
}
}
}
$lists =& $this->getLists();
$lists['leftContext']->setData($leftBlockPlugins);
$lists['rightContext']->setData($rightBlockPlugins);
$lists['unselected']->setData($disabledBlockPlugins);
}
/**
* @see MetadataDataObjectAdapter::extractMetadataFromDataObject()
* @param $monograph Monograph
* @return MetadataDescription
*/
function extractMetadataFromDataObject($monograph)
{
assert(is_a($monograph, 'Monograph'));
AppLocale::requireComponents(LOCALE_COMPONENT_APP_COMMON);
// Retrieve data that belongs to the publication format.
$oaiDao = DAORegistry::getDAO('OAIDAO');
/* @var $oaiDao OAIDAO */
$publishedMonographDao = DAORegistry::getDAO('PublishedMonographDAO');
$chapterDao = DAORegistry::getDAO('ChapterDAO');
$monograph = $publishedMonographDao->getById($monograph->getId());
$press = $oaiDao->getPress($monograph->getPressId());
$description = $this->instantiateMetadataDescription();
// Update status
// Is communicated via an attribute, so property value is empty
$description->addStatement('administrative_data/delivery/update_status[@type="urn_new"]', "");
$urn = "";
$scheme = "";
$pubIdPlugins = PluginRegistry::loadCategory('pubIds');
if (isset($pubIdPlugins) && array_key_exists('URNDNBPubIdPlugin', $pubIdPlugins) && $pubIdPlugins['URNDNBPubIdPlugin']->getEnabled() == true) {
$urn = $pubIdPlugins['URNDNBPubIdPlugin']->getPubId($monograph);
$namespaces = explode(':', $urn);
$numberOfNamespaces = min(sizeof($namespaces), 3);
$scheme = implode(":", array_slice($namespaces, 0, $numberOfNamespaces));
}
// URN
$description->addStatement('record/identifier', $urn . ' [@scheme="' . $scheme . '"]');
// URL
$url = Request::url($press->getPath(), 'catalog', 'book', array($monograph->getId()));
$description->addStatement('record/resource/identifier[@scheme="url", @type="frontpage", @role="primary"]', $url);
// URL Mime type
$description->addStatement('record/resource/format[@scheme="imt"]', "text/html");
return $description;
}
/**
* @see PKPTestCase::setUp()
*/
protected function setUp()
{
parent::setUp();
// Instantiate the plug-in for testing.
$this->mockRequest();
PluginRegistry::loadCategory('generic', true, 0);
$this->lucenePlugin = PluginRegistry::getPlugin('generic', 'luceneplugin');
}
/**
* Constructor
*/
function CustomLocaleHandler()
{
parent::Handler();
$this->addCheck(new HandlerValidatorConference($this));
$this->addCheck(new HandlerValidatorRoles($this, true, null, null, array(ROLE_ID_SITE_ADMIN, ROLE_ID_CONFERENCE_MANAGER)));
$plugin =& PluginRegistry::getPlugin('generic', 'CustomLocalePlugin');
$this->plugin =& $plugin;
}
/**
* Display status of deposit(s)
* @param array $args
* @param Request $request
*/
function status($args = array(), &$request)
{
$journal =& $request->getJournal();
$plnPlugin =& PluginRegistry::getPlugin('generic', PLN_PLUGIN_NAME);
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('pageHierarchy', array(array($router->url($request, null, 'about'), 'about.aboutTheJournal')));
$templateMgr->display($plnPlugin->getTemplatePath() . DIRECTORY_SEPARATOR . 'status.tpl');
}
function isTinyMCEInstalled()
{
$tinyMCEPlugin =& PluginRegistry::getPlugin('generic', 'TinyMCEPlugin');
if ($tinyMCEPlugin) {
return $tinyMCEPlugin->getEnabled();
}
return false;
}
/**
* Constructor
*/
function PayMethodSettingsForm()
{
parent::Form('payments/payMethodSettingsForm.tpl');
// Load the plugins.
$this->plugins =& PluginRegistry::loadCategory('paymethod');
// Add form checks
$this->addCheck(new FormValidatorInSet($this, 'paymentMethodPluginName', 'optional', 'manager.payment.paymentPluginInvalid', array_keys($this->plugins)));
}
/**
* Authenticate user credentials and mark the user as logged in in the current session.
* @param $username string
* @param $password string unencrypted password
* @param $reason string reference to string to receive the reason an account was disabled; null otherwise
* @param $remember boolean remember a user's session past the current browser session
* @return User the User associated with the login credentials, or false if the credentials are invalid
*/
static function login($username, $password, &$reason, $remember = false)
{
$implicitAuth = Config::getVar('security', 'implicit_auth');
$reason = null;
if ($implicitAuth) {
// Implicit auth
if (!Validation::isLoggedIn()) {
PluginRegistry::loadCategory('implicitAuth');
// Call the implicitAuth hook. It will set $user.
HookRegistry::call('ImplicitAuthPlugin::implicitAuth', array(&$user));
$valid = true;
} else {
$valid = false;
}
} else {
// Regular Auth
$userDao = DAORegistry::getDAO('UserDAO');
$user = $userDao->getByUsername($username, true);
if (!isset($user)) {
// User does not exist
return false;
}
if ($user->getAuthId()) {
$authDao = DAORegistry::getDAO('AuthSourceDAO');
$auth = $authDao->getPlugin($user->getAuthId());
} else {
$auth = null;
}
if ($auth) {
// Validate against remote authentication source
$valid = $auth->authenticate($username, $password);
if ($valid) {
$oldEmail = $user->getEmail();
$auth->doGetUserInfo($user);
if ($user->getEmail() != $oldEmail) {
// FIXME requires email addresses to be unique; if changed email already exists, ignore
if ($userDao->userExistsByEmail($user->getEmail())) {
$user->setEmail($oldEmail);
}
}
}
} else {
// Validate against user database
$rehash = null;
$valid = Validation::verifyPassword($username, $password, $user->getPassword(), $rehash);
if ($valid && !empty($rehash)) {
// update to new hashing algorithm
$user->setPassword($rehash);
}
}
}
if (!$valid) {
// Login credentials are invalid
return false;
} else {
return self::registerUserSession($user, $reason, $remember);
}
}
/**
* @copydoc Form::fetch()
*/
function fetch($request)
{
$templateMgr = TemplateManager::getManager($request);
$templateMgr->assign(array('pubIdPlugins' => PluginRegistry::loadCategory('pubIds', true, $this->getContextId()), 'pubObject' => $this->getPubObject(), 'stageId' => $this->getStageId(), 'formParams' => $this->getFormParams()));
// consider JavaScripts
$pubIdPluginHelper = new PKPPubIdPluginHelper();
$pubIdPluginHelper->addJavaScripts($this->getContextId(), $request, $templateMgr);
return parent::fetch($request);
}
function &getPlugin()
{
$plugins =& PluginRegistry::loadCategory('schemas');
$returner = null;
if (isset($plugins[$this->getPluginName()])) {
$returner =& $plugins[$this->getPluginName()];
}
return $returner;
}
public static function initBindings()
{
$NativeBinding = new NativeBinding();
self::$Bindings = array($NativeBinding);
self::$BindingsByName[$NativeBinding->getName()] = $NativeBinding;
PluginRegistry::ForEachBinding(function ($PluginInstance) {
UserProxy::registerInstance($PluginInstance);
});
}
/**
* @see ScheduledTask::executeActions()
*/
function executeActions()
{
$ofrPlugin =& PluginRegistry::getPlugin('generic', 'objectsforreviewplugin');
if ($ofrPlugin) {
$ofrPluginName = $ofrPlugin->getName();
// Get all journals
$journalDao =& DAORegistry::getDAO('JournalDAO');
$journals =& $journalDao->getJournals(true);
// Register the plugin DAOs and get the others
$ofrPlugin->registerDAOs();
$pluginSettingsDao =& DAORegistry::getDAO('PluginSettingsDAO');
$ofrAssignmentDao =& DAORegistry::getDAO('ObjectForReviewAssignmentDAO');
// For all journals
while ($journal =& $journals->next()) {
$journalId = $journal->getId();
// If the plugin is enabled
$pluginEnabled = $pluginSettingsDao->getSetting($journalId, $ofrPluginName, 'enabled');
if ($pluginEnabled) {
// Get plugin reminder settings
$enableDueReminderBefore = $pluginSettingsDao->getSetting($journalId, $ofrPluginName, 'enableDueReminderBefore');
$enableDueReminderAfter = $pluginSettingsDao->getSetting($journalId, $ofrPluginName, 'enableDueReminderAfter');
$beforeDays = $pluginSettingsDao->getSetting($journalId, $ofrPluginName, 'numDaysBeforeDueReminder');
$afterDays = $pluginSettingsDao->getSetting($journalId, $ofrPluginName, 'numDaysAfterDueReminder');
// If a reminder is set
if ($enableDueReminderBefore && $beforeDays > 0 || $enableDueReminderAfter && $afterDays > 0) {
// Retrieve all incomplete object for review assignments
$incompleteAssignments =& $ofrAssignmentDao->getIncompleteAssignmentsByContextId($journalId);
foreach ($incompleteAssignments as $incompleteAssignment) {
if ($incompleteAssignment->getDateDue() != null) {
$dueDate = strtotime($incompleteAssignment->getDateDue());
// Remind before:
// If there hasn't been any such reminder, this option is set and due date is in the future
if ($incompleteAssignment->getDateRemindedBefore() == null && $enableDueReminderBefore == 1 && time() < $dueDate) {
$nowToDueDate = $dueDate - time();
if ($nowToDueDate < 60 * 60 * 24 * $beforeDays) {
$this->sendReminder($incompleteAssignment, $journal, 'OFR_REVIEW_REMINDER');
}
}
// Remind after:
// If there hasn't been any such reminder, this option is set and due date is in the past
if ($incompleteAssignment->getDateRemindedAfter() == null && $enableDueReminderAfter == 1 && time() > $dueDate) {
$dueDateToNow = time() - $dueDate;
if ($dueDateToNow > 60 * 60 * 24 * $afterDays) {
$this->sendReminder($incompleteAssignment, $journal, 'OFR_REVIEW_REMINDER_LATE');
}
}
}
}
}
}
unset($journal);
}
return true;
} else {
return false;
}
}
/**
* Register this plugin for all the appropriate hooks.
*/
function register($category, $path)
{
$success = parent::register($category, $path);
if ($success) {
// Make sure postprocessors are loaded.
PluginRegistry::loadCategory('postprocessors');
HookRegistry::register('OAI::metadataFormats', array(&$this, 'callback_formatRequest'));
}
return $success;
}
/**
* tries to include the requested plugin and returns the plugin class name, or false if plugin not found.
* @param string $pluginName name of the plugin
* @return string class name or false if not found
*/
protected function _load($pluginName, $section)
{
$cleanName = FileUtils::sanitize($pluginName);
$className = strtolower("Plugins_{$cleanName}_{$section}");
if (M::resolve_class($className, 'plugins', function () use($cleanName) {
PluginRegistry::initPlugin($cleanName);
})) {
return $className;
}
}