/**
  * Internal function to return an ArticleGalley object from a row.
  * @param $row array
  * @return ArticleGalley
  */
 function &_returnGalleyFromRow(&$row)
 {
     if ($row['html_galley']) {
         $galley = new ArticleHTMLGalley();
         // HTML-specific settings
         $galley->setStyleFileId($row['style_file_id']);
         if ($row['style_file_id']) {
             $galley->setStyleFile($this->articleFileDao->getArticleFile($row['style_file_id']));
         }
         // Retrieve images
         $images =& $this->getGalleyImages($row['galley_id']);
         $galley->setImageFiles($images);
     } else {
         $galley = new ArticleGalley();
     }
     $galley->setId($row['galley_id']);
     $galley->setArticleId($row['article_id']);
     $galley->setLocale($row['locale']);
     $galley->setFileId($row['file_id']);
     $galley->setLabel($row['label']);
     $galley->setFileStage($row['file_stage']);
     $galley->setSequence($row['seq']);
     $galley->setRemoteURL($row['remote_url']);
     // ArticleFile set methods
     $galley->setFileName($row['file_name']);
     $galley->setOriginalFileName($row['original_file_name']);
     $galley->setFileType($row['file_type']);
     $galley->setFileSize($row['file_size']);
     $galley->setDateModified($this->datetimeFromDB($row['date_modified']));
     $galley->setDateUploaded($this->datetimeFromDB($row['date_uploaded']));
     $this->getDataObjectSettings('article_galley_settings', 'galley_id', $row['galley_id'], $galley);
     HookRegistry::call('ArticleGalleyDAO::_returnGalleyFromRow', array(&$galley, &$row));
     return $galley;
 }
    function importArticles()
    {
        assert($this->xml->name == 'articles');
        $articleDAO =& DAORegistry::getDAO('ArticleDAO');
        $articles = $articleDAO->getArticlesByJournalId($this->journal->getId());
        $journalFileManager = new JournalFileManager($this->journal);
        $publicFileManager =& new PublicFileManager();
        $this->nextElement();
        while ($this->xml->name == 'article') {
            $articleXML = $this->getCurrentElementAsDom();
            $article = new Article();
            $article->setJournalId($this->journal->getId());
            $article->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $articleXML->userId));
            $article->setSectionId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_SECTION, (int) $articleXML->sectionId));
            $article->setLocale((string) $articleXML->locale);
            $article->setLanguage((string) $articleXML->language);
            $article->setCommentsToEditor((string) $articleXML->commentsToEditor);
            $article->setCitations((string) $articleXML->citations);
            $article->setDateSubmitted((string) $articleXML->dateSubmitted);
            $article->setDateStatusModified((string) $articleXML->dateStatusModified);
            $article->setLastModified((string) $articleXML->lastModified);
            $article->setStatus((int) $articleXML->status);
            $article->setSubmissionProgress((int) $articleXML->submissionProgress);
            $article->setCurrentRound((int) $articleXML->currentRound);
            $article->setPages((string) $articleXML->pages);
            $article->setFastTracked((int) $articleXML->fastTracked);
            $article->setHideAuthor((int) $articleXML->hideAuthor);
            $article->setCommentsStatus((int) $articleXML->commentsStatus);
            $articleDAO->insertArticle($article);
            $oldArticleId = (int) $articleXML->oldId;
            $this->restoreDataObjectSettings($articleDAO, $articleXML->settings, 'article_settings', 'article_id', $article->getId());
            $article =& $articleDAO->getArticle($article->getId());
            // Reload article with restored settings
            $covers = $article->getFileName(null);
            if ($covers) {
                foreach ($covers as $locale => $oldCoverFileName) {
                    $sourceFile = $this->publicFolderPath . '/' . $oldCoverFileName;
                    $extension = $publicFileManager->getExtension($oldCoverFileName);
                    $destFile = 'cover_issue_' . $article->getId() . "_{$locale}.{$extension}";
                    $publicFileManager->copyJournalFile($this->journal->getId(), $sourceFile, $destFile);
                    unlink($sourceFile);
                    $article->setFileName($destFile, $locale);
                    $articleDAO->updateArticle($article);
                }
            }
            $articleFileManager = new ArticleFileManager($article->getId());
            $authorDAO =& DAORegistry::getDAO('AuthorDAO');
            foreach ($articleXML->author as $authorXML) {
                $author = new Author();
                $author->setArticleId($article->getId());
                $author->setFirstName((string) $authorXML->firstName);
                $author->setMiddleName((string) $authorXML->middleName);
                $author->setLastName((string) $authorXML->lastName);
                $author->setSuffix((string) $authorXML->suffix);
                $author->setCountry((string) $authorXML->country);
                $author->setEmail((string) $authorXML->email);
                $author->setUrl((string) $authorXML->url);
                $author->setUserGroupId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_GROUP, (int) $authorXML->userGroupId));
                $author->setPrimaryContact((int) $authorXML->primaryContact);
                $author->setSequence((int) $authorXML->sequence);
                $authorDAO->insertAuthor($author);
                $this->restoreDataObjectSettings($authorDAO, $authorXML->settings, 'author_settings', 'author_id', $author->getId());
                unset($author);
            }
            $articleEmailLogDAO =& DAORegistry::getDAO('ArticleEmailLogDAO');
            $emailLogsXML = array();
            foreach ($articleXML->emailLogs->emailLog as $emailLogXML) {
                array_unshift($emailLogsXML, $emailLogXML);
            }
            foreach ($emailLogsXML as $emailLogXML) {
                $emailLog = new ArticleEmailLogEntry();
                $emailLog->setAssocType(ASSOC_TYPE_ARTICLE);
                $emailLog->setAssocId($article->getId());
                $emailLog->setSenderId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $emailLogXML->senderId));
                $emailLog->setDateSent((string) $emailLogXML->dateSent);
                $emailLog->setIPAddress((string) $emailLogXML->IPAddress);
                $emailLog->setEventType((int) $emailLogXML->eventType);
                $emailLog->setFrom((string) $emailLogXML->from);
                $emailLog->setRecipients((string) $emailLogXML->recipients);
                $emailLog->setCcs((string) $emailLogXML->ccs);
                $emailLog->setBccs((string) $emailLogXML->bccs);
                $emailLog->setSubject((string) $emailLogXML->subject);
                $emailLog->setBody((string) $emailLogXML->body);
                $articleEmailLogDAO->insertObject($emailLog);
                $this->idTranslationTable->register(INTERNAL_TRANSFER_OBJECT_ARTICLE_EMAIL_LOG, (int) $emailLogXML->oldId, $emailLog->getId());
            }
            $articleFileDAO =& DAORegistry::getDAO('ArticleFileDAO');
            foreach ($articleXML->articleFile as $articleFileXML) {
                try {
                    $articleFile = new ArticleFile();
                    $articleFile->setArticleId($article->getId());
                    $articleFile->setSourceFileId((int) $articleFileXML->sourceFileId);
                    $articleFile->setSourceRevision((int) $articleFileXML->sourceRevision);
                    $articleFile->setRevision((int) $articleFileXML->revision);
                    $articleFile->setFileName((string) $articleFileXML->fileName);
                    $articleFile->setFileType((string) $articleFileXML->fileType);
                    $articleFile->setFileSize((string) $articleFileXML->fileSize);
                    $articleFile->setOriginalFileName((string) $articleFileXML->originalFileName);
                    $articleFile->setFileStage((int) $articleFileXML->fileStage);
                    $articleFile->setAssocId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_EMAIL_LOG, (int) $articleFileXML->assocId));
                    $articleFile->setDateUploaded((string) $articleFileXML->dateUploaded);
                    $articleFile->setDateModified((string) $articleFileXML->dateModified);
                    $articleFile->setRound((int) $articleFileXML->round);
                    $articleFile->setViewable((int) $articleFileXML->viewable);
                    $articleFileDAO->insertArticleFile($articleFile);
                    $oldArticleFileId = (int) $articleFileXML->oldId;
                    $oldFileName = $articleFile->getFileName();
                    $stagePath = $articleFileManager->fileStageToPath($articleFile->getFileStage());
                    $fileInTransferPackage = $this->journalFolderPath . "/articles/{$oldArticleId}/{$stagePath}/{$oldFileName}";
                    $newFileName = $articleFileManager->generateFilename($articleFile, $articleFile->getFileStage(), $articleFile->getOriginalFileName());
                    $newFilePath = "/articles/" . $article->getId() . "/{$stagePath}/{$newFileName}";
                    $journalFileManager->copyFile($fileInTransferPackage, $journalFileManager->filesDir . $newFilePath);
                    unlink($fileInTransferPackage);
                    $articleFileDAO->updateArticleFile($articleFile);
                    $this->idTranslationTable->register(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, $oldArticleFileId, $articleFile->getFileId());
                } catch (Exception $e) {
                }
            }
            $articleFiles = $articleFileDAO->getArticleFilesByArticle($article->getId());
            foreach ($articleFiles as $articleFile) {
                try {
                    $articleFile->setSourceFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, $articleFile->getSourceFileId()));
                    $articleFileDAO->updateArticleFile($articleFile);
                } catch (Exception $e) {
                }
            }
            $suppFileDAO =& DAORegistry::getDAO('SuppFileDAO');
            foreach ($articleXML->suppFile as $suppFileXML) {
                $suppFile =& new SuppFile();
                $suppFile->setArticleId($article->getId());
                $suppFile->setRemoteURL((string) $suppFileXML->remoteURL);
                $suppFile->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $suppFileXML->fileId));
                $suppFile->setType((string) $suppFileXML->type);
                $suppFile->setDateCreated((string) $suppFileXML->dateCreated);
                $suppFile->setLanguage((string) $suppFileXML->language);
                $suppFile->setShowReviewers((int) $suppFileXML->showReviewers);
                $suppFile->setDateSubmitted((string) $suppFileXML->dateSubmitted);
                $suppFile->setSequence((int) $suppFileXML->sequence);
                $suppFileDAO->insertSuppFile($suppFile);
                $this->restoreDataObjectSettings($suppFileDAO, $suppFileXML->settings, 'article_supp_file_settings', 'supp_id', $suppFile->getId());
            }
            $articleCommentDAO =& DAORegistry::getDAO('ArticleCommentDAO');
            foreach ($articleXML->articleComment as $articleCommentXML) {
                $articleComment = new ArticleComment();
                $articleComment->setArticleId($article->getId());
                $articleComment->setAssocId($article->getId());
                $articleComment->setCommentType((int) $articleCommentXML->commentType);
                $articleComment->setRoleId((int) $articleCommentXML->roleId);
                $articleComment->setAuthorId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $articleCommentXML->authorId));
                $articleComment->setCommentTitle((string) $articleCommentXML->commentTitle);
                $articleComment->setComments((string) $articleCommentXML->comments);
                $articleComment->setDatePosted((string) $articleCommentXML->datePosted);
                $articleComment->setDateModified((string) $articleCommentXML->dateModified);
                $articleComment->setViewable((int) $articleCommentXML->viewable);
                $articleCommentDAO->insertArticleComment($articleComment);
            }
            $articleGalleyDAO =& DAORegistry::getDAO('ArticleGalleyDAO');
            foreach ($articleXML->articleGalley as $articleGalleyXML) {
                $articleGalley = null;
                if ($articleGalleyXML->htmlGalley == "1") {
                    $articleGalley = new ArticleHTMLGalley();
                } else {
                    $articleGalley = new ArticleGalley();
                }
                $articleGalley->setArticleId($article->getId());
                $articleGalley->setLocale((string) $articleGalleyXML->locale);
                $articleGalley->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleGalleyXML->fileId));
                $articleGalley->setLabel((string) $articleGalleyXML->label);
                $articleGalley->setSequence((int) $articleGalleyXML->sequence);
                $articleGalley->setRemoteURL((string) $articleGalleyXML->remoteURL);
                if ($articleGalley instanceof ArticleHTMLGalley) {
                    $articleGalley->setStyleFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleGalleyXML->styleFileId));
                }
                $articleGalleyDAO->insertGalley($articleGalley);
                if ($articleGalley instanceof ArticleHTMLGalley) {
                    foreach ($articleGalleyXML->htmlGalleyImage as $articleGalleyImageXML) {
                        $imageId = $this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleGalleyImageXML);
                        $articleGalleyDAO->insertGalleyImage($articleGalley->getId(), $imageId);
                    }
                }
                $this->restoreDataObjectSettings($articleGalleyDAO, $articleGalleyXML->settings, 'article_galley_settings', 'galley_id', $articleGalley->getId());
            }
            $noteDAO =& DAORegistry::getDAO('NoteDAO');
            foreach ($articleXML->articleNote as $articleNoteXML) {
                $articleNote = new Note();
                $articleNote->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $articleNoteXML->userId));
                $articleNote->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleNoteXML->fileId));
                $articleNote->setAssocType(ASSOC_TYPE_ARTICLE);
                $articleNote->setAssocId($article->getId());
                $articleNote->setDateCreated((string) $articleNoteXML->dateCreated);
                $articleNote->setDateModified((string) $articleNoteXML->dateModified);
                $articleNote->setContents((string) $articleNoteXML->contents);
                $articleNote->setTitle((string) $articleNoteXML->title);
                $noteDAO->insertObject($articleNote);
            }
            $editAssignmentDAO =& DAORegistry::getDAO('EditAssignmentDAO');
            foreach ($articleXML->editAssignment as $editAssignmentXML) {
                $editAssignment = new EditAssignment();
                $editAssignment->setArticleId($article->getId());
                $editAssignment->setEditorId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $editAssignmentXML->editorId));
                $editAssignment->setCanReview((int) $editAssignmentXML->canReview);
                $editAssignment->setCanEdit((int) $editAssignmentXML->canEdit);
                $editAssignment->setDateUnderway((string) $editAssignmentXML->dateUnderway);
                $editAssignment->setDateNotified((string) $editAssignmentXML->dateNotified);
                $editAssignmentDAO->insertEditAssignment($editAssignment);
            }
            $reviewAssignmentDAO =& DAORegistry::getDAO('ReviewAssignmentDAO');
            $reviewFormResponseDAO =& DAORegistry::getDAO('ReviewFormResponseDAO');
            foreach ($articleXML->reviewAssignment as $reviewAssignmentXML) {
                $reviewAssignment = new ReviewAssignment();
                $reviewAssignment->setSubmissionId($article->getId());
                $reviewAssignment->setReviewerId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $reviewAssignmentXML->reviewerId));
                try {
                    $reviewAssignment->setReviewerFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $reviewAssignmentXML->reviewerFileId));
                } catch (Exception $e) {
                    $this->logger->log("Arquivo do artigo {$oldArticleId} não encontrado. ID: " . (int) $reviewAssignmentXML->reviewerFileId . "\n");
                }
                $reviewAssignment->setReviewFormId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_REVIEW_FORM, (int) $reviewAssignmentXML->reviewFormId));
                $reviewAssignment->setReviewRoundId((int) $reviewAssignmentXML->reviewRoundId);
                $reviewAssignment->setStageId((int) $reviewAssignmentXML->stageId);
                $reviewAssignment->setReviewerFullName((string) $reviewAssignmentXML->reviewerFullName);
                $reviewAssignment->setCompetingInterests((string) $reviewAssignmentXML->competingInterests);
                $reviewAssignment->setRegretMessage((string) $reviewAssignmentXML->regretMessage);
                $reviewAssignment->setRecommendation((string) $reviewAssignmentXML->recommendation);
                $reviewAssignment->setDateAssigned((string) $reviewAssignmentXML->dateAssigned);
                $reviewAssignment->setDateNotified((string) $reviewAssignmentXML->dateNotified);
                $reviewAssignment->setDateConfirmed((string) $reviewAssignmentXML->dateConfirmed);
                $reviewAssignment->setDateCompleted((string) $reviewAssignmentXML->dateCompleted);
                $reviewAssignment->setDateAcknowledged((string) $reviewAssignmentXML->dateAcknowledged);
                $reviewAssignment->setDateDue((string) $reviewAssignmentXML->dateDue);
                $reviewAssignment->setDateResponseDue((string) $reviewAssignmentXML->dateResponseDue);
                $reviewAssignment->setLastModified((string) $reviewAssignmentXML->lastModified);
                $reviewAssignment->setDeclined((int) $reviewAssignmentXML->declined);
                $reviewAssignment->setReplaced((int) $reviewAssignmentXML->replaced);
                $reviewAssignment->setCancelled((int) $reviewAssignmentXML->cancelled);
                $reviewAssignment->setQuality((int) $reviewAssignmentXML->quality);
                $reviewAssignment->setDateRated((string) $reviewAssignmentXML->dateRated);
                $reviewAssignment->setDateReminded((string) $reviewAssignmentXML->dateReminded);
                $reviewAssignment->setReminderWasAutomatic((int) $reviewAssignmentXML->reminderWasAutomatic);
                $reviewAssignment->setRound((int) $reviewAssignmentXML->round);
                $reviewAssignment->setReviewRevision((int) $reviewAssignmentXML->reviewRevision);
                $reviewAssignment->setReviewMethod((int) $reviewAssignmentXML->reviewMethod);
                $reviewAssignment->setUnconsidered((int) $reviewAssignmentXML->unconsidered);
                $reviewAssignmentDAO->insertObject($reviewAssignment);
                foreach ($reviewAssignmentXML->formResponses->formResponse as $formResponseXML) {
                    $reviewFormResponseDAO->update('INSERT INTO review_form_responses
							(review_form_element_id, review_id, response_type, response_value)
							VALUES
							(?, ?, ?, ?)', array($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_REVIEW_FORM_ELEMENT, (int) $formResponseXML->reviewFormElementId), $reviewAssignment->getId(), (string) $formResponseXML->responseType, (string) $formResponseXML->responseValue));
                }
            }
            $signoffDAO =& DAORegistry::getDAO('SignoffDAO');
            foreach ($articleXML->signoff as $signoffXML) {
                $signoff = new Signoff();
                $signoff->setAssocType(ASSOC_TYPE_ARTICLE);
                $signoff->setAssocId($article->getId());
                $signoff->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $signoffXML->userId));
                $signoff->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $signoffXML->fileId));
                $signoff->setUserGroupId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_GROUP, (int) $signoffXML->userGroupId));
                $signoff->setSymbolic((string) $signoffXML->symbolic);
                $signoff->setFileRevision((int) $signoffXML->fileRevision);
                $signoff->setDateUnderway((string) $signoffXML->dateUnderway);
                $signoff->setDateNotified((string) $signoffXML->dateNotified);
                $signoff->setDateCompleted((string) $signoffXML->dateCompleted);
                $signoff->setDateAcknowledged((string) $signoffXML->dateAcknowledged);
                $signoffDAO->insertObject($signoff);
            }
            $editorSubmissionDAO =& DAORegistry::getDAO('EditorSubmissionDAO');
            foreach ($articleXML->editDecisions as $editDecisionXML) {
                $editDecisions =& $editorSubmissionDAO->update('INSERT INTO edit_decisions (article_id, round, editor_id, decision, date_decided) values (?, ?, ?, ?, ?)', array($article->getId(), (string) $editDecisionXML->round, $this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $editDecisionXML->editorId), (string) $editDecisionXML->decision, (string) $editDecisionXML->dateDecided));
            }
            $publishedArticleDAO =& DAORegistry::getDAO('PublishedArticleDAO');
            if (isset($articleXML->publishedArticle)) {
                $publishedArticleXML = $articleXML->publishedArticle;
                $publishedArticle = new PublishedArticle();
                $publishedArticle->setId($article->getId());
                $publishedArticle->setIssueId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ISSUE, (int) $publishedArticleXML->issueId));
                $publishedArticle->setDatePublished((string) $publishedArticleXML->datePublished);
                $publishedArticle->setSeq((int) $publishedArticleXML->seq);
                $publishedArticle->setAccessStatus((int) $publishedArticleXML->accessStatus);
                $publishedArticleDAO->insertPublishedArticle($publishedArticle);
            }
            $articleEventLogDAO =& DAORegistry::getDAO('ArticleEventLogDAO');
            $eventLogsXML =& iterator_to_array($articleXML->eventLogs->eventLog);
            $eventLogsXML = array();
            foreach ($articleXML->eventLogs->eventLog as $eventLogXML) {
                array_unshift($eventLogsXML, $eventLogXML);
            }
            foreach ($eventLogsXML as $eventLogXML) {
                $eventLog = new ArticleEventLogEntry();
                $eventLog->setAssocType(ASSOC_TYPE_ARTICLE);
                $eventLog->setAssocId($article->getId());
                $eventLog->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $eventLogXML->userId));
                $eventLog->setDateLogged((string) $eventLogXML->dateLogged);
                $eventLog->setIPAddress((string) $eventLogXML->IPAddress);
                $eventLog->setEventType((int) $eventLogXML->eventType);
                $eventLog->setMessage((string) $eventLogXML->message);
                $eventLog->setIsTranslated((int) $eventLogXML->isTranslated);
                $articleEventLogDAO->insertObject($eventLog);
                $this->restoreDataObjectSettings($articleEventLogDAO, $eventLogXML->settings, 'event_log_settings', 'log_id', $eventLog->getId());
            }
            try {
                $article->setSubmissionFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->submissionFileId));
            } catch (Exception $e) {
            }
            try {
                $article->setRevisedFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->revisedFileId));
            } catch (Exception $e) {
            }
            try {
                $article->setReviewFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->reviewFileId));
            } catch (Exception $e) {
            }
            try {
                $article->setEditorFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->editorFileId));
            } catch (Exception $e) {
            }
            $articleDAO->updateArticle($article);
            $this->nextElement();
        }
    }
예제 #3
0
 /**
  * Save changes to the galley.
  * @return int the galley ID
  */
 function execute($fileName = null, $createRemote = false)
 {
     import('classes.file.ArticleFileManager');
     $articleFileManager = new ArticleFileManager($this->articleId);
     $galleyDao =& DAORegistry::getDAO('ArticleGalleyDAO');
     $fileName = isset($fileName) ? $fileName : 'galleyFile';
     $journal =& Request::getJournal();
     $fileId = null;
     $articleDao =& DAORegistry::getDAO('ArticleDAO');
     $article =& $articleDao->getArticle($this->articleId, $journal->getId());
     if (isset($this->galley)) {
         $galley =& $this->galley;
         // Upload galley file
         if ($articleFileManager->uploadedFileExists($fileName)) {
             if ($galley->getFileId()) {
                 $articleFileManager->uploadPublicFile($fileName, $galley->getFileId());
                 $fileId = $galley->getFileId();
             } else {
                 $fileId = $articleFileManager->uploadPublicFile($fileName);
                 $galley->setFileId($fileId);
             }
             // Update file search index
             import('classes.search.ArticleSearchIndex');
             $articleSearchIndex = new ArticleSearchIndex();
             $articleSearchIndex->articleFileChanged($this->articleId, ARTICLE_SEARCH_GALLEY_FILE, $galley->getFileId());
             $articleSearchIndex->articleChangesFinished();
         }
         if ($articleFileManager->uploadedFileExists('styleFile')) {
             // Upload stylesheet file
             $styleFileId = $articleFileManager->uploadPublicFile('styleFile', $galley->getStyleFileId());
             $galley->setStyleFileId($styleFileId);
         } else {
             if ($this->getData('deleteStyleFile')) {
                 // Delete stylesheet file
                 $styleFile =& $galley->getStyleFile();
                 if (isset($styleFile)) {
                     $articleFileManager->deleteFile($styleFile->getFileId());
                 }
             }
         }
         // Update existing galley
         $galley->setLabel($this->getData('label'));
         if ($journal->getSetting('enablePublicGalleyId')) {
             $galley->setStoredPubId('publisher-id', $this->getData('publicGalleyId'));
         }
         $galley->setLocale($this->getData('galleyLocale'));
         if ($this->getData('remoteURL')) {
             $galley->setRemoteURL($this->getData('remoteURL'));
         }
         // consider the additional field names from the public identifer plugins
         import('classes.plugins.PubIdPluginHelper');
         $pubIdPluginHelper = new PubIdPluginHelper();
         $pubIdPluginHelper->execute($this, $galley);
         parent::execute();
         $galleyDao->updateGalley($galley);
     } else {
         // Upload galley file
         if ($articleFileManager->uploadedFileExists($fileName)) {
             $fileType = $articleFileManager->getUploadedFileType($fileName);
             $fileId = $articleFileManager->uploadPublicFile($fileName);
         }
         if (isset($fileType) && strstr($fileType, 'html')) {
             // Assume HTML galley
             $galley = new ArticleHTMLGalley();
         } else {
             $galley = new ArticleGalley();
         }
         $galley->setArticleId($this->articleId);
         $galley->setFileId($fileId);
         if ($this->getData('label') == null) {
             // Generate initial label based on file type
             $enablePublicGalleyId = $journal->getSetting('enablePublicGalleyId');
             if ($galley->isHTMLGalley()) {
                 $galley->setLabel('HTML');
                 if ($enablePublicGalleyId) {
                     $galley->setStoredPubId('publisher-id', 'html');
                 }
             } else {
                 if ($createRemote) {
                     $galley->setLabel(__('common.remote'));
                     $galley->setRemoteURL(__('common.remoteURL'));
                     if ($enablePublicGalleyId) {
                         $galley->setStoredPubId('publisher-id', strtolower(__('common.remote')));
                     }
                 } else {
                     if (isset($fileType)) {
                         if (strstr($fileType, 'pdf')) {
                             $galley->setLabel('PDF');
                             if ($enablePublicGalleyId) {
                                 $galley->setStoredPubId('publisher-id', 'pdf');
                             }
                         } else {
                             if (strstr($fileType, 'postscript')) {
                                 $galley->setLabel('PostScript');
                                 if ($enablePublicGalleyId) {
                                     $galley->setStoredPubId('publisher-id', 'ps');
                                 }
                             } else {
                                 if (strstr($fileType, 'xml')) {
                                     $galley->setLabel('XML');
                                     if ($enablePublicGalleyId) {
                                         $galley->setStoredPubId('publisher-id', 'xml');
                                     }
                                 } else {
                                     if (strstr($fileType, 'epub')) {
                                         $galley->setLabel('EPUB');
                                         if ($enablePublicGalleyId) {
                                             $galley->setStoredPubId('publisher-id', 'epub');
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
             if ($galley->getLabel() == null) {
                 $galley->setLabel(__('common.untitled'));
             }
         } else {
             $galley->setLabel($this->getData('label'));
         }
         $galley->setLocale($article->getLocale());
         if ($enablePublicGalleyId) {
             // check to make sure the assigned public id doesn't already exist for another galley of this article
             $galleyDao =& DAORegistry::getDAO('ArticleGalleyDAO');
             /* @var $galleylDao ArticleGalleyDAO */
             $publicGalleyId = $galley->getPubId('publisher-id');
             $suffix = '';
             $i = 1;
             while ($galleyDao->getGalleyByPubId('publisher-id', $publicGalleyId . $suffix, $this->articleId)) {
                 $suffix = '_' . $i++;
             }
             $galley->setStoredPubId('publisher-id', $publicGalleyId . $suffix);
         }
         parent::execute();
         // Insert new galley
         $galleyDao->insertGalley($galley);
         $this->galleyId = $galley->getId();
     }
     if ($fileId) {
         // Update file search index
         import('classes.search.ArticleSearchIndex');
         $articleSearchIndex = new ArticleSearchIndex();
         $articleSearchIndex->articleFileChanged($this->articleId, ARTICLE_SEARCH_GALLEY_FILE, $fileId);
         $articleSearchIndex->articleChangesFinished();
     }
     // Stamp the article modification (for OAI)
     $articleDao->updateArticle($article);
     return $this->galleyId;
 }
예제 #4
0
 /**
  * Internal function to return an ArticleGalley object from a row.
  * @param $row array
  * @return ArticleGalley
  */
 function &_returnGalleyFromRow($row)
 {
     $galley = new ArticleGalley();
     $galley->setId($row['galley_id']);
     $galley->setSubmissionId($row['submission_id']);
     $galley->setLocale($row['locale']);
     $galley->setLabel($row['label']);
     $galley->setSequence($row['seq']);
     $galley->setRemoteURL($row['remote_url']);
     $galley->setIsAvailable($row['is_available']);
     $galley->setGalleyType($row['galley_type']);
     $this->getDataObjectSettings('submission_galley_settings', 'galley_id', $row['galley_id'], $galley);
     HookRegistry::call('ArticleGalleyDAO::_returnGalleyFromRow', array(&$galley, &$row));
     return $galley;
 }