PHP PKPString::html2text方法代码示例

 /**
  * Assign parameters to template
  * @param $paramArray array
  */
 function assignParams($paramArray = array())
 {
     $submission = $this->submission;
     $application = PKPApplication::getApplication();
     $request = $application->getRequest();
     parent::assignParams(array_merge(array('submissionTitle' => strip_tags($submission->getLocalizedTitle()), 'submissionId' => $submission->getId(), 'submissionAbstract' => PKPString::html2text($submission->getLocalizedAbstract()), 'authorString' => strip_tags($submission->getAuthorString())), $paramArray));
 }

 /**
  * @see OAIMetadataFormat#toXml
  */
 function toXml(&$record, $format = null)
 {
     $article = $record->getData('article');
     $journal = $record->getData('journal');
     $templateMgr = TemplateManager::getManager();
     $templateMgr->assign(array('journal' => $journal, 'article' => $article, 'issue' => $record->getData('issue'), 'section' => $record->getData('section')));
     $subjects = array_merge_recursive($this->stripAssocArray((array) $article->getDiscipline(null)), $this->stripAssocArray((array) $article->getSubject(null)));
     $templateMgr->assign(array('subject' => isset($subjects[$journal->getPrimaryLocale()]) ? $subjects[$journal->getPrimaryLocale()] : '', 'abstract' => PKPString::html2text($article->getAbstract($article->getLocale())), 'language' => AppLocale::get3LetterIsoFromLocale($article->getLocale())));
     return $templateMgr->fetch(dirname(__FILE__) . '/record.tpl');
 }

 /**
  * @copydoc NotificationManagerDelegate::getNotificationMessage()
  */
 public function getNotificationMessage($request, $notification)
 {
     assert($notification->getAssocType() == ASSOC_TYPE_QUERY);
     $queryDao = DAORegistry::getDAO('QueryDAO');
     $query = $queryDao->getById($notification->getAssocId());
     $headNote = $query->getHeadNote();
     assert($headNote);
     switch ($notification->getType()) {
         case NOTIFICATION_TYPE_NEW_QUERY:
             $user = $headNote->getUser();
             return __('submission.query.new', array('creatorName' => $user->getFullName(), 'noteContents' => substr(PKPString::html2text($headNote->getContents()), 0, 200), 'noteTitle' => substr($headNote->getTitle(), 0, 200)));
         case NOTIFICATION_TYPE_QUERY_ACTIVITY:
             $notes = $query->getReplies(null, NOTE_ORDER_ID, SORT_DIRECTION_DESC);
             $latestNote = $notes->next();
             $user = $latestNote->getUser();
             $notes->close();
             return __('submission.query.activity', array('responderName' => $user->getFullName(), 'noteContents' => substr(PKPString::html2text($latestNote->getContents()), 0, 200), 'noteTitle' => substr($headNote->getTitle(), 0, 200)));
         default:
             assert(false);
     }
 }

 /**
  * Send the email.
  * @return boolean
  */
 function send()
 {
     if (HookRegistry::call('Mail::send', array($this))) {
         return;
     }
     // Replace all the private parameters for this message.
     $mailBody = $this->getBody();
     if (is_array($this->privateParams)) {
         foreach ($this->privateParams as $name => $value) {
             $mailBody = str_replace($name, $value, $mailBody);
         }
     }
     require_once 'lib/pkp/lib/vendor/phpmailer/phpmailer/class.phpmailer.php';
     $mailer = new PHPMailer();
     $mailer->IsHTML(true);
     if (Config::getVar('email', 'smtp')) {
         $mailer->IsSMTP();
         $mailer->Port = Config::getVar('email', 'smtp_port');
         if (($s = Config::getVar('email', 'smtp_auth')) != '') {
             $mailer->SMTPSecure = $s;
             $mailer->SMTPAuth = true;
         }
         $mailer->Host = Config::getVar('email', 'smtp_server');
         $mailer->Username = Config::getVar('email', 'smtp_username');
         $mailer->Password = Config::getVar('email', 'smtp_password');
     }
     $mailer->CharSet = Config::getVar('i18n', 'client_charset');
     if (($t = $this->getContentType()) != null) {
         $mailer->ContentType = $t;
     }
     $mailer->XMailer = 'Public Knowledge Project Suite v2';
     $mailer->WordWrap = MAIL_WRAP;
     foreach ((array) $this->getHeaders() as $header) {
         $mailer->AddCustomHeader($header['key'], $mailer->SecureHeader($header['content']));
     }
     if (($s = $this->getEnvelopeSender()) != null) {
         $mailer->Sender = $s;
     }
     if (($f = $this->getFrom()) != null) {
         $mailer->SetFrom($f['email'], $f['name']);
     }
     if (($r = $this->getReplyTo()) != null) {
         $mailer->AddReplyTo($r['email'], $r['name']);
     }
     foreach ((array) $this->getRecipients() as $recipientInfo) {
         $mailer->AddAddress($recipientInfo['email'], $recipientInfo['name']);
     }
     foreach ((array) $this->getCcs() as $ccInfo) {
         $mailer->AddCC($ccInfo['email'], $ccInfo['name']);
     }
     foreach ((array) $this->getBccs() as $bccInfo) {
         $mailer->AddBCC($bccInfo['email'], $bccInfo['name']);
     }
     $mailer->Subject = $this->getSubject();
     $mailer->Body = $mailBody;
     $mailer->AltBody = PKPString::html2text($mailBody);
     $remoteAddr = $mailer->SecureHeader(Request::getRemoteAddr());
     if ($remoteAddr != '') {
         $mailer->AddCustomHeader("X-Originating-IP: {$remoteAddr}");
     }
     foreach ((array) $this->getAttachments() as $attachmentInfo) {
         $mailer->AddAttachment($attachmentInfo['path'], $attachmentInfo['filename'], 'base64', $attachmentInfo['content-type']);
     }
     try {
         $mailer->Send();
     } catch (phpmailerException $e) {
         error_log($mailer->ErrorInfo);
         return false;
     }
     return true;
 }

 /**
  * Create a description text node.
  * @param $doc DOMDocument
  * @param $locale string
  * @param $description string
  * @return DOMElement
  */
 function createOtherTextNode($doc, $locale, $description)
 {
     $deployment = $this->getDeployment();
     $otherTextNode = $doc->createElementNS($deployment->getNamespace(), 'OtherText');
     // Text Type
     $otherTextNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'TextTypeCode', O4DOI_TEXT_TYPE_MAIN_DESCRIPTION));
     // Text
     $language = AppLocale::get3LetterIsoFromLocale($locale);
     assert(!empty($language));
     $otherTextNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'Text', htmlspecialchars(PKPString::html2text($description), ENT_COMPAT, 'UTF-8')));
     $node->setAttribute('textformat', O4DOI_TEXTFORMAT_ASCII);
     $node->setAttribute('language', $language);
     return $otherTextNode;
 }

 /**
  * Import all free-text/review form reviews to paste into message
  * @param $args array
  * @param $request PKPRequest
  * @return JSONMessage JSON object
  */
 function importPeerReviews($args, $request)
 {
     // Retrieve the authorized submission.
     $submission = $this->getAuthorizedContextObject(ASSOC_TYPE_SUBMISSION);
     // Retrieve the current review round.
     $reviewRound = $this->getAuthorizedContextObject(ASSOC_TYPE_REVIEW_ROUND);
     // Retrieve peer reviews.
     $reviewAssignmentDao = DAORegistry::getDAO('ReviewAssignmentDAO');
     $submissionCommentDao = DAORegistry::getDAO('SubmissionCommentDAO');
     $reviewFormResponseDao = DAORegistry::getDAO('ReviewFormResponseDAO');
     $reviewFormElementDao = DAORegistry::getDAO('ReviewFormElementDAO');
     $reviewAssignments = $reviewAssignmentDao->getBySubmissionId($submission->getId(), $reviewRound->getId());
     $reviewIndexes = $reviewAssignmentDao->getReviewIndexesForRound($submission->getId(), $reviewRound->getId());
     AppLocale::requireComponents(LOCALE_COMPONENT_PKP_SUBMISSION);
     $body = '';
     $textSeparator = '------------------------------------------------------';
     foreach ($reviewAssignments as $reviewAssignment) {
         // If the reviewer has completed the assignment, then import the review.
         if ($reviewAssignment->getDateCompleted() != null && !$reviewAssignment->getCancelled()) {
             // Get the comments associated with this review assignment
             $submissionComments = $submissionCommentDao->getSubmissionComments($submission->getId(), COMMENT_TYPE_PEER_REVIEW, $reviewAssignment->getId());
             $body .= "<br><br>{$textSeparator}<br>";
             // If it is an open review, show reviewer's name.
             if ($reviewAssignment->getReviewMethod() == SUBMISSION_REVIEW_METHOD_OPEN) {
                 $body .= $reviewAssignment->getReviewerFullName() . "<br>\n";
             } else {
                 $body .= __('submission.comments.importPeerReviews.reviewerLetter', array('reviewerLetter' => PKPString::enumerateAlphabetically($reviewIndexes[$reviewAssignment->getId()]))) . "<br>\n";
             }
             while ($comment = $submissionComments->next()) {
                 // If the comment is viewable by the author, then add the comment.
                 if ($comment->getViewable()) {
                     $body .= PKPString::html2text($comment->getComments()) . "\n\n";
                 }
             }
             $body .= "<br>{$textSeparator}<br><br>";
             if ($reviewFormId = $reviewAssignment->getReviewFormId()) {
                 $reviewId = $reviewAssignment->getId();
                 $reviewFormElements = $reviewFormElementDao->getByReviewFormId($reviewFormId);
                 if (!$submissionComments) {
                     $body .= "{$textSeparator}\n";
                     $body .= __('submission.comments.importPeerReviews.reviewerLetter', array('reviewerLetter' => PKPString::enumerateAlphabetically($reviewIndexes[$reviewAssignment->getId()]))) . "\n\n";
                 }
                 while ($reviewFormElement = $reviewFormElements->next()) {
                     $body .= PKPString::html2text($reviewFormElement->getLocalizedQuestion()) . ": \n";
                     $reviewFormResponse = $reviewFormResponseDao->getReviewFormResponse($reviewId, $reviewFormElement->getId());
                     if ($reviewFormResponse) {
                         $possibleResponses = $reviewFormElement->getLocalizedPossibleResponses();
                         if (in_array($reviewFormElement->getElementType(), $reviewFormElement->getMultipleResponsesElementTypes())) {
                             if ($reviewFormElement->getElementType() == REVIEW_FORM_ELEMENT_TYPE_CHECKBOXES) {
                                 foreach ($reviewFormResponse->getValue() as $value) {
                                     $body .= "\t" . PKPString::html2text($possibleResponses[$value]) . "\n";
                                 }
                             } else {
                                 $body .= "\t" . PKPString::html2text($possibleResponses[$reviewFormResponse->getValue()]) . "\n";
                             }
                             $body .= "\n";
                         } else {
                             $body .= "\t" . PKPString::html2text($reviewFormResponse->getValue()) . "\n\n";
                         }
                     }
                 }
                 $body .= "{$textSeparator}\n\n";
             }
         }
     }
     if (empty($body)) {
         return new JSONMessage(false, __('editor.review.noReviews'));
     } else {
         return new JSONMessage(true, $body);
     }
 }

 /**
  * Create descriptions node list.
  * @param $doc DOMDocument
  * @param $issue Issue
  * @param $article PublishedArticle
  * @param $galley Alley
  * @param $galleyFile SubmissionFile
  * @param $objectLocalePrecedence array
  * @return DOMElement|null Can be null if a size
  *  cannot be identified for the given object.
  */
 function createDescriptionsNode($doc, $issue, $article, $galley, $galleyFile, $objectLocalePrecedence)
 {
     $deployment = $this->getDeployment();
     $descriptions = array();
     switch (true) {
         case isset($galley):
             if (is_a($galleyFile, 'SupplementaryFile')) {
                 $suppFileDesc = $this->getPrimaryTranslation($galleyFile->getDescription(null), $objectLocalePrecedence);
                 if (!empty($suppFileDesc)) {
                     $descriptions[DATACITE_DESCTYPE_OTHER] = $suppFileDesc;
                 }
             }
             break;
         case isset($article):
             $articleAbstract = $this->getPrimaryTranslation($article->getAbstract(null), $objectLocalePrecedence);
             if (!empty($articleAbstract)) {
                 $descriptions[DATACITE_DESCTYPE_ABSTRACT] = $articleAbstract;
             }
             break;
         case isset($issue):
             $issueDesc = $this->getPrimaryTranslation($issue->getDescription(null), $objectLocalePrecedence);
             if (!empty($issueDesc)) {
                 $descriptions[DATACITE_DESCTYPE_OTHER] = $issueDesc;
             }
             $descriptions[DATACITE_DESCTYPE_TOC] = $this->getIssueToc($issue, $objectLocalePrecedence);
             break;
         default:
             assert(false);
     }
     if (isset($article)) {
         // Articles and galleys.
         $descriptions[DATACITE_DESCTYPE_SERIESINFO] = $this->getIssueInformation($issue, $objectLocalePrecedence);
     }
     $descriptionsNode = null;
     if (!empty($descriptions)) {
         $descriptionsNode = $doc->createElementNS($deployment->getNamespace(), 'descriptions');
         foreach ($descriptions as $descType => $description) {
             $descriptionsNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'description', htmlspecialchars(PKPString::html2text($description), ENT_COMPAT, 'UTF-8')));
             $node->setAttribute('descriptionType', $descType);
         }
     }
     return $descriptionsNode;
 }

 /**
  * Create a contributor node.
  * @param $doc DOMDocument
  * @param $author Author
  * @param $objectLocalePrecedence array
  * @return DOMElement
  */
 function createContributorNode($doc, $author, $objectLocalePrecedence)
 {
     $deployment = $this->getDeployment();
     $contributorNode = $doc->createElementNS($deployment->getNamespace(), 'Contributor');
     // Sequence number
     $seq = $author->getSequence();
     assert(!empty($seq));
     $contributorNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'SequenceNumber', $seq));
     // Contributor role (mandatory)
     $contributorNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'ContributorRole', O4DOI_CONTRIBUTOR_ROLE_ACTUAL_AUTHOR));
     // Person name (mandatory)
     $personName = $author->getFullName();
     assert(!empty($personName));
     $contributorNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'PersonName', $personName));
     // Inverted person name
     $invertedPersonName = $author->getFullName(true);
     assert(!empty($invertedPersonName));
     $contributorNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'PersonNameInverted', $invertedPersonName));
     // Affiliation
     $affiliation = $this->getPrimaryTranslation($author->getAffiliation(null), $objectLocalePrecedence);
     if (!empty($affiliation)) {
         $affiliationNode = $doc->createElementNS($deployment->getNamespace(), 'ProfessionalAffiliation');
         $affiliationNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'Affiliation', $affiliation));
         $contributorNode->appendChild($affiliationNode);
     }
     // Biographical note
     $bioNote = $this->getPrimaryTranslation($author->getBiography(null), $objectLocalePrecedence);
     if (!empty($bioNote)) {
         $contributorNode->appendChild($node = $doc->createElementNS($deployment->getNamespace(), 'BiographicalNote', PKPString::html2text($bioNote)));
     }
     return $contributorNode;
 }

 /**
  * @see DOIExportDom::generate()
  */
 function &generate(&$object)
 {
     $falseVar = false;
     // Declare variables that will contain publication objects.
     $journal = $this->getJournal();
     $issue = null;
     /* @var $issue Issue */
     $article = null;
     /* @var $article PublishedArticle */
     $galley = null;
     /* @var $galley ArticleGalley */
     $articlesByIssue = null;
     $galleysByArticle = null;
     // Retrieve required publication objects (depends on the object to be exported).
     $pubObjects =& $this->retrievePublicationObjects($object);
     extract($pubObjects);
     // Identify an object implementing a SubmissionFile (if any).
     $submissionFile = $galley;
     // Identify the object locale.
     $objectLocalePrecedence = $this->getObjectLocalePrecedence($article, $galley);
     // The publisher is required.
     $publisher = $this->getPublisher($objectLocalePrecedence);
     // The publication date is required.
     $publicationDate = is_a($article, 'PublishedArticle') ? $article->getDatePublished() : null;
     if (empty($publicationDate)) {
         $publicationDate = $issue->getDatePublished();
     }
     assert(!empty($publicationDate));
     // Create the XML document and its root element.
     $doc =& $this->getDoc();
     $rootElement =& $this->rootElement();
     XMLCustomWriter::appendChild($doc, $rootElement);
     // DOI (mandatory)
     if (($identifierElement =& $this->_identifierElement($object)) === false) {
         return false;
     }
     XMLCustomWriter::appendChild($rootElement, $identifierElement);
     // Creators (mandatory)
     XMLCustomWriter::appendChild($rootElement, $this->_creatorsElement($object, $objectLocalePrecedence, $publisher));
     // Title (mandatory)
     XMLCustomWriter::appendChild($rootElement, $this->_titlesElement($object, $objectLocalePrecedence));
     // Publisher (mandatory)
     XMLCustomWriter::createChildWithText($this->getDoc(), $rootElement, 'publisher', $publisher);
     // Publication Year (mandatory)
     XMLCustomWriter::createChildWithText($this->getDoc(), $rootElement, 'publicationYear', date('Y', strtotime($publicationDate)));
     // Subjects
     if (!empty($article)) {
         $this->_appendNonMandatoryChild($rootElement, $this->_subjectsElement($article, $objectLocalePrecedence));
     }
     // Dates
     XMLCustomWriter::appendChild($rootElement, $this->_datesElement($issue, $article, $submissionFile, $publicationDate));
     // Language
     XMLCustomWriter::createChildWithText($this->getDoc(), $rootElement, 'language', AppLocale::get3LetterIsoFromLocale($objectLocalePrecedence[0]));
     // Resource Type
     $resourceTypeElement =& $this->_resourceTypeElement($object);
     XMLCustomWriter::appendChild($rootElement, $resourceTypeElement);
     // Alternate Identifiers
     $this->_appendNonMandatoryChild($rootElement, $this->_alternateIdentifiersElement($object, $issue, $article, $submissionFile));
     // Related Identifiers
     $this->_appendNonMandatoryChild($rootElement, $this->_relatedIdentifiersElement($object, $articlesByIssue, $galleysByArticle, $issue, $article));
     // Sizes
     $sizesElement =& $this->_sizesElement($object, $article);
     if ($sizesElement) {
         XMLCustomWriter::appendChild($rootElement, $sizesElement);
     }
     // Formats
     if (!empty($submissionFile)) {
         XMLCustomWriter::appendChild($rootElement, $this->_formatsElement($submissionFile));
     }
     // Rights
     $rights = $this->getPrimaryTranslation($journal->getSetting('copyrightNotice', null), $objectLocalePrecedence);
     if (!empty($rights)) {
         XMLCustomWriter::createChildWithText($this->getDoc(), $rootElement, 'rights', PKPString::html2text($rights));
     }
     // Descriptions
     $descriptionsElement =& $this->_descriptionsElement($issue, $article, $objectLocalePrecedence, $articlesByIssue);
     if ($descriptionsElement) {
         XMLCustomWriter::appendChild($rootElement, $descriptionsElement);
     }
     return $doc;
 }

 /**
  * Create a content item element.
  *
  * @param $author Author
  * @param $objectLocalePrecedence array
  *
  * @return XMLNode|DOMImplementation
  */
 function &_contributorElement(&$author, $objectLocalePrecedence)
 {
     $contributorElement =& XMLCustomWriter::createElement($this->getDoc(), 'Contributor');
     // Sequence number
     $seq = $author->getSequence();
     assert(!empty($seq));
     XMLCustomWriter::createChildWithText($this->getDoc(), $contributorElement, 'SequenceNumber', $seq);
     // Contributor role (mandatory)
     XMLCustomWriter::createChildWithText($this->getDoc(), $contributorElement, 'ContributorRole', O4DOI_CONTRIBUTOR_ROLE_ACTUAL_AUTHOR);
     // Person name (mandatory)
     $personName = $author->getFullName();
     assert(!empty($personName));
     XMLCustomWriter::createChildWithText($this->getDoc(), $contributorElement, 'PersonName', $personName);
     // Inverted person name
     $invertedPersonName = $author->getFullName(true);
     assert(!empty($invertedPersonName));
     XMLCustomWriter::createChildWithText($this->getDoc(), $contributorElement, 'PersonNameInverted', $invertedPersonName);
     // Affiliation
     $affiliation = $this->getPrimaryTranslation($author->getAffiliation(null), $objectLocalePrecedence);
     if (!empty($affiliation)) {
         $affiliationElement = XMLCustomWriter::createElement($this->getDoc(), 'ProfessionalAffiliation');
         XMLCustomWriter::createChildWithText($this->getDoc(), $affiliationElement, 'Affiliation', $affiliation);
         XMLCustomWriter::appendChild($contributorElement, $affiliationElement);
     }
     // Biographical note
     $bioNote = $this->getPrimaryTranslation($author->getBiography(null), $objectLocalePrecedence);
     if (!empty($bioNote)) {
         XMLCustomWriter::createChildWithText($this->getDoc(), $contributorElement, 'BiographicalNote', PKPString::html2text($bioNote));
     }
     return $contributorElement;
 }

 /**
  * Create an XML element with a text node.
  *
  * FIXME: Move this to XMLCustomWriter? I leave the decision up to PKP...
  *
  * @param $name string
  * @param $value string
  * @param $attributes array An array with the attribute names as array
  *  keys and attribute values as array values.
  *
  * @return XMLNode|DOMImplementation
  */
 function &createElementWithText($name, $value, $attributes = array())
 {
     $element =& XMLCustomWriter::createElement($this->getDoc(), $name);
     $elementContent =& XMLCustomWriter::createTextNode($this->getDoc(), PKPString::html2text($value));
     XMLCustomWriter::appendChild($element, $elementContent);
     foreach ($attributes as $attributeName => $attributeValue) {
         XMLCustomWriter::setAttribute($element, $attributeName, $attributeValue);
     }
     return $element;
 }

 /**
  * @copydoc Form::fetch()
  */
 function fetch($request)
 {
     $context = $request->getContext();
     $user = $request->getUser();
     // Get the review method options.
     $reviewAssignmentDao = DAORegistry::getDAO('ReviewAssignmentDAO');
     $reviewMethods = $reviewAssignmentDao->getReviewMethodsTranslationKeys();
     $submission = $this->getSubmission();
     $templateMgr = TemplateManager::getManager($request);
     $templateMgr->assign('reviewMethods', $reviewMethods);
     $templateMgr->assign('reviewerActions', $this->getReviewerFormActions());
     $reviewFormDao = DAORegistry::getDAO('ReviewFormDAO');
     $reviewForms = array(0 => __('editor.article.selectReviewForm'));
     $reviewFormsIterator = $reviewFormDao->getActiveByAssocId(Application::getContextAssocType(), $context->getId());
     while ($reviewForm = $reviewFormsIterator->next()) {
         $reviewForms[$reviewForm->getId()] = $reviewForm->getLocalizedTitle();
     }
     $templateMgr->assign('reviewForms', $reviewForms);
     $templateMgr->assign('emailVariables', array('reviewerName' => __('user.name'), 'responseDueDate' => __('reviewer.submission.responseDueDate'), 'reviewDueDate' => __('reviewer.submission.reviewDueDate'), 'submissionReviewUrl' => __('common.url'), 'reviewerUserName' => __('user.username'), 'contextName' => $context->getLocalizedName(), 'contextUrl' => __('common.url'), 'editorialContactSignature' => PKPString::stripUnsafeHtml($user->getContactSignature()), 'submissionTitle' => PKPString::stripUnsafeHtml($submission->getLocalizedTitle()), 'submissionAbstract' => PKPString::html2text($submission->getLocalizedAbstract())));
     // Allow the default template
     $templateKeys[] = $this->_getMailTemplateKey($request->getContext());
     // Determine if the current user can use any custom templates defined.
     $roleDao = DAORegistry::getDAO('RoleDAO');
     $userRoles = $roleDao->getByUserId($user->getId(), $submission->getContextId());
     foreach ($userRoles as $userRole) {
         if (in_array($userRole->getId(), array(ROLE_ID_MANAGER, ROLE_ID_SUB_EDITOR, ROLE_ID_ASSISTANT))) {
             $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO');
             $customTemplates = $emailTemplateDao->getCustomTemplateKeys(Application::getContextAssocType(), $submission->getContextId());
             $templateKeys = array_merge($templateKeys, $customTemplates);
             break;
         }
     }
     foreach ($templateKeys as $templateKey) {
         $template = new SubmissionMailTemplate($submission, $templateKey, null, null, null, false);
         $template->assignParams(array());
         $templates[$templateKey] = $template->getSubject();
     }
     $templateMgr->assign('templates', $templates);
     // Get the reviewer user groups for the create new reviewer/enroll existing user tabs
     $context = $request->getContext();
     $userGroupDao = DAORegistry::getDAO('UserGroupDAO');
     /* @var $userGroupDao UserGroupDAO */
     $reviewRound = $this->getReviewRound();
     $reviewerUserGroups = $userGroupDao->getUserGroupsByStage($context->getId(), $reviewRound->getStageId(), false, false, ROLE_ID_REVIEWER);
     $userGroups = array();
     while ($userGroup = $reviewerUserGroups->next()) {
         $userGroups[$userGroup->getId()] = $userGroup->getLocalizedName();
     }
     $this->setData('userGroups', $userGroups);
     return parent::fetch($request);
 }

//.........这里部分代码省略.........
         if (!empty($publisher)) {
             $recordNode->appendChild($node = $doc->createElement('publisher', htmlspecialchars($publisher, ENT_COMPAT, 'UTF-8')));
         }
         // Journal's title (M)
         $journalTitle = $context->getName($context->getPrimaryLocale());
         $recordNode->appendChild($node = $doc->createElement('journalTitle', htmlspecialchars($journalTitle, ENT_COMPAT, 'UTF-8')));
         // Identification Numbers
         $issn = $context->getSetting('printIssn');
         if (!empty($issn)) {
             $recordNode->appendChild($node = $doc->createElement('issn', $issn));
         }
         $eissn = $context->getSetting('onlineIssn');
         if (!empty($eissn)) {
             $recordNode->appendChild($node = $doc->createElement('eissn', $eissn));
         }
         // Article's publication date, volume, issue
         if ($pubObject->getDatePublished()) {
             $recordNode->appendChild($node = $doc->createElement('publicationDate', $this->formatDate($pubObject->getDatePublished())));
         } else {
             $recordNode->appendChild($node = $doc->createElement('publicationDate', $this->formatDate($issue->getDatePublished())));
         }
         $volume = $issue->getVolume();
         if (!empty($volume) && $issue->getShowVolume()) {
             $recordNode->appendChild($node = $doc->createElement('volume', htmlspecialchars($volume, ENT_COMPAT, 'UTF-8')));
         }
         $issueNumber = $issue->getNumber();
         if (!empty($issueNumber) && $issue->getShowNumber()) {
             $recordNode->appendChild($node = $doc->createElement('issue', htmlspecialchars($issueNumber, ENT_COMPAT, 'UTF-8')));
         }
         /** --- FirstPage / LastPage (from PubMed plugin)---
          * there is some ambiguity for online journals as to what
          * "page numbers" are; for example, some journals (eg. JMIR)
          * use the "e-location ID" as the "page numbers" in PubMed
          */
         $pages = $pubObject->getPages();
         if (preg_match("/([0-9]+)\\s*-\\s*([0-9]+)/i", $pages, $matches)) {
             // simple pagination (eg. "pp. 3-8")
             $recordNode->appendChild($node = $doc->createElement('startPage', htmlspecialchars($matches[1], ENT_COMPAT, 'UTF-8')));
             $recordNode->appendChild($node = $doc->createElement('endPage', htmlspecialchars($matches[2], ENT_COMPAT, 'UTF-8')));
         } elseif (preg_match("/(e[0-9]+)/i", $pages, $matches)) {
             // elocation-id (eg. "e12")
             $recordNode->appendChild($node = $doc->createElement('startPage', htmlspecialchars($matches[1], ENT_COMPAT, 'UTF-8')));
             $recordNode->appendChild($node = $doc->createElement('endPage', htmlspecialchars($matches[1], ENT_COMPAT, 'UTF-8')));
         }
         // DOI
         $doi = $pubObject->getStoredPubId('doi');
         if (!empty($doi)) {
             $recordNode->appendChild($node = $doc->createElement('doi', htmlspecialchars($doi, ENT_COMPAT, 'UTF-8')));
         }
         // publisherRecordId
         $recordNode->appendChild($node = $doc->createElement('publisherRecordId', htmlspecialchars($pubObject->getId(), ENT_COMPAT, 'UTF-8')));
         // documentType
         $type = $pubObject->getType($pubObject->getLocale());
         if (!empty($type)) {
             $recordNode->appendChild($node = $doc->createElement('documentType', htmlspecialchars($type, ENT_COMPAT, 'UTF-8')));
         }
         // Article title
         foreach ((array) $pubObject->getTitle(null) as $locale => $title) {
             if (!empty($title)) {
                 $recordNode->appendChild($node = $doc->createElement('title', htmlspecialchars($title, ENT_COMPAT, 'UTF-8')));
                 $node->setAttribute('language', AppLocale::get3LetterIsoFromLocale($locale));
             }
         }
         // Authors and affiliations
         $authorsNode = $doc->createElement('authors');
         $recordNode->appendChild($authorsNode);
         $affilList = $this->createAffiliationsList($pubObject->getAuthors(), $pubObject);
         foreach ($pubObject->getAuthors() as $author) {
             $authorsNode->appendChild($this->createAuthorNode($doc, $pubObject, $author, $affilList));
         }
         if (!empty($affilList[0])) {
             $affilsNode = $doc->createElement('affiliationsList');
             $recordNode->appendChild($affilsNode);
             for ($i = 0; $i < count($affilList); $i++) {
                 $affilsNode->appendChild($node = $doc->createElement('affiliationName', htmlspecialchars($affilList[$i], ENT_COMPAT, 'UTF-8')));
                 $node->setAttribute('affiliationId', $i);
             }
         }
         // Abstract
         foreach ((array) $pubObject->getAbstract(null) as $locale => $abstract) {
             if (!empty($abstract)) {
                 $recordNode->appendChild($node = $doc->createElement('abstract', htmlspecialchars(PKPString::html2text($abstract), ENT_COMPAT, 'UTF-8')));
                 $node->setAttribute('language', AppLocale::get3LetterIsoFromLocale($locale));
             }
         }
         // FullText URL
         $recordNode->appendChild($node = $doc->createElement('fullTextUrl', htmlspecialchars(Request::url(null, 'article', 'view', $pubObject->getId()), ENT_COMPAT, 'UTF-8')));
         $node->setAttribute('format', 'html');
         // Keywords
         $keywordsNode = $doc->createElement('keywords');
         $recordNode->appendChild($keywordsNode);
         $subjects = array_map('trim', explode(';', $pubObject->getSubject($pubObject->getLocale())));
         foreach ($subjects as $keyword) {
             if (!empty($keyword)) {
                 $keywordsNode->appendChild($node = $doc->createElement('keyword', htmlspecialchars($keyword, ENT_COMPAT, 'UTF-8')));
             }
         }
     }
     return $doc;
 }

 /**
  * @copydoc ReportPlugin::display() 
  */
 function display($args, $request)
 {
     $journal = $request->getJournal();
     $journalId = $journal->getId();
     $userDao = DAORegistry::getDAO('UserDAO');
     $countryDao = DAORegistry::getDAO('CountryDAO');
     $subscriptionTypeDao = DAORegistry::getDAO('SubscriptionTypeDAO');
     $individualSubscriptionDao = DAORegistry::getDAO('IndividualSubscriptionDAO');
     $institutionalSubscriptionDao = DAORegistry::getDAO('InstitutionalSubscriptionDAO');
     header('content-type: text/comma-separated-values');
     header('content-disposition: attachment; filename=subscriptions-' . date('Ymd') . '.csv');
     $fp = fopen('php://output', 'wt');
     // Columns for individual subscriptions
     $columns = array(__('subscriptionManager.individualSubscriptions'));
     fputcsv($fp, array_values($columns));
     $columnsCommon = array('subscription_id' => __('common.id'), 'status' => __('subscriptions.status'), 'type' => __('common.type'), 'format' => __('subscriptionTypes.format'), 'date_start' => __('manager.subscriptions.dateStart'), 'date_end' => __('manager.subscriptions.dateEnd'), 'membership' => __('manager.subscriptions.membership'), 'reference_number' => __('manager.subscriptions.referenceNumber'), 'notes' => __('common.notes'));
     $columnsIndividual = array('name' => __('user.name'), 'mailing_address' => __('common.mailingAddress'), 'country' => __('common.country'), 'email' => __('user.email'), 'phone' => __('user.phone'));
     $columns = array_merge($columnsCommon, $columnsIndividual);
     // Write out individual subscription column headings to file
     fputcsv($fp, array_values($columns));
     // Iterate over individual subscriptions and write out each to file
     $individualSubscriptions = $individualSubscriptionDao->getSubscriptionsByJournalId($journalId);
     while ($subscription = $individualSubscriptions->next()) {
         $user = $userDao->getById($subscription->getUserId());
         $subscriptionType = $subscriptionTypeDao->getSubscriptionType($subscription->getTypeId());
         foreach ($columns as $index => $junk) {
             switch ($index) {
                 case 'subscription_id':
                     $columns[$index] = $subscription->getId();
                     break;
                 case 'status':
                     $columns[$index] = $subscription->getStatusString();
                     break;
                 case 'type':
                     $columns[$index] = $subscription->getSubscriptionTypeSummaryString();
                     break;
                 case 'format':
                     $columns[$index] = __($subscriptionType->getFormatString());
                     break;
                 case 'date_start':
                     $columns[$index] = $subscription->getDateStart();
                     break;
                 case 'date_end':
                     $columns[$index] = $subscription->getDateEnd();
                     break;
                 case 'membership':
                     $columns[$index] = $subscription->getMembership();
                     break;
                 case 'reference_number':
                     $columns[$index] = $subscription->getReferenceNumber();
                     break;
                 case 'notes':
                     $columns[$index] = PKPString::html2text($subscription->getNotes());
                     break;
                 case 'name':
                     $columns[$index] = $user->getFullName();
                     break;
                 case 'mailing_address':
                     $columns[$index] = PKPString::html2text($user->getMailingAddress());
                     break;
                 case 'country':
                     $columns[$index] = $countryDao->getCountry($user->getCountry());
                     break;
                 case 'email':
                     $columns[$index] = $user->getEmail();
                     break;
                 case 'phone':
                     $columns[$index] = $user->getPhone();
                     break;
                 default:
                     $columns[$index] = '';
             }
         }
         fputcsv($fp, $columns);
     }
     // Columns for institutional subscriptions
     $columns = array('');
     fputcsv($fp, array_values($columns));
     $columns = array(__('subscriptionManager.institutionalSubscriptions'));
     fputcsv($fp, array_values($columns));
     $columnsInstitution = array('institution_name' => __('manager.subscriptions.institutionName'), 'institution_mailing_address' => __('plugins.reports.subscriptions.institutionMailingAddress'), 'domain' => __('manager.subscriptions.domain'), 'ip_ranges' => __('plugins.reports.subscriptions.ipRanges'), 'contact' => __('manager.subscriptions.contact'), 'mailing_address' => __('common.mailingAddress'), 'country' => __('common.country'), 'email' => __('user.email'), 'phone' => __('user.phone'));
     $columns = array_merge($columnsCommon, $columnsInstitution);
     // Write out institutional subscription column headings to file
     fputcsv($fp, array_values($columns));
     // Iterate over institutional subscriptions and write out each to file
     $institutionalSubscriptions =& $institutionalSubscriptionDao->getSubscriptionsByJournalId($journalId);
     while ($subscription = $institutionalSubscriptions->next()) {
         $user = $userDao->getById($subscription->getUserId());
         $subscriptionType = $subscriptionTypeDao->getSubscriptionType($subscription->getTypeId());
         foreach ($columns as $index => $junk) {
             switch ($index) {
                 case 'subscription_id':
                     $columns[$index] = $subscription->getId();
                     break;
                 case 'status':
                     $columns[$index] = $subscription->getStatusString();
                     break;
//.........这里部分代码省略.........

 /**
  * Auto-fill the DOAJ form.
  * @param $journal object
  */
 function contact($journal, $send = false)
 {
     $request = $this->getRequest();
     $user = $request->getUser();
     $issn = $journal->getSetting('printIssn');
     $paramArray = array('name' => $user->getFullName(), 'email' => $user->getEmail(), 'title' => $journal->getLocalizedName(), 'description' => PKPString::html2text($journal->getLocalizedSetting('focusScopeDesc')), 'url' => $request->url($journal->getPath()), 'charging' => $journal->getSetting('submissionFee') > 0 ? 'Y' : 'N', 'issn' => $issn, 'eissn' => $journal->getSetting('onlineIssn'), 'pub' => $journal->getSetting('publisherInstitution'), 'language' => AppLocale::getLocale(), 'keywords' => $journal->getLocalizedSetting('searchKeywords'), 'contact_person' => $journal->getSetting('contactName'), 'contact_email' => $journal->getSetting('contactEmail'));
     $url = 'http://www.doaj.org/doaj?func=suggest&owner=1';
     foreach ($paramArray as $name => $value) {
         $url .= '&' . urlencode($name) . '=' . urlencode($value);
     }
     $request->redirectUrl($url);
 }