Example #1
0
 /**
  * Prüft, ob eine Nummer für eine Schriftenreihe bereits vergeben ist.
  *
  * Wenn die Nummer bereits vergeben ist, wird geprüft, ob es sich um das aktuelle Dokument handelt. In diesem Fall
  * ist die Validierung ebenfalls erfolgreich.
  *
  * Wenn die Series nicht gefunden werden kann soll die Validierung einfach ignoriert werden, da nicht festgestellt
  * werden kann, ob es eine Kollision gibt. Eine fehlende Series-ID im Formular muss woanders geprüft und gemeldet
  * werden.
  */
 public function isValid($value, $context = null)
 {
     $value = (string) $value;
     $this->_setValue($value);
     if (array_key_exists(Admin_Form_Document_Series::ELEMENT_SERIES_ID, $context)) {
         $seriesId = $context[Admin_Form_Document_Series::ELEMENT_SERIES_ID];
     } else {
         $seriesId = null;
     }
     if (strlen(trim($seriesId)) == 0 && is_numeric($seriesId)) {
         Zend_Registry::get('Zend_Log')->err(__METHOD__ . ' Context without \'SeriesId\'.');
         return true;
         // should be captured somewhere else
     }
     try {
         $series = new Opus_Series($seriesId);
     } catch (Opus_Model_NotFoundException $omnfe) {
         Zend_Registry::get('Zend_Log')->err(__METHOD__ . $omnfe->getMessage());
         return true;
     }
     if (!$series->isNumberAvailable($value)) {
         if (array_key_exists(Admin_Form_Document_Series::ELEMENT_DOC_ID, $context)) {
             $currentDocId = $context[Admin_Form_Document_Series::ELEMENT_DOC_ID];
             $otherDocId = $series->getDocumentIdForNumber($value);
             if ($currentDocId == $otherDocId) {
                 return true;
             }
         }
         $this->_error(self::NOT_AVAILABLE);
         return false;
     }
     return true;
 }
Example #2
0
 public function testConstructWithNonEmptyVisibleSeries()
 {
     $series = new Solrsearch_Model_Series(1);
     $this->assertNotNull($series);
     $seriesFramework = new Opus_Series(1);
     $this->assertEquals($seriesFramework->getId(), $series->getId());
     $this->assertEquals($seriesFramework->getTitle(), $series->getTitle());
     $this->assertEquals($seriesFramework->getInfobox(), $series->getInfobox());
 }
Example #3
0
 /**
  * Returns the number of a document in a series.
  * @param Opus_Document $document
  * @param Opus_Series $series
  * @return string
  */
 public function seriesNumber($document, $series)
 {
     foreach ($document->getSeries() as $linkedSeries) {
         if ($linkedSeries->getModel()->getId() === $series->getId()) {
             return htmlspecialchars($linkedSeries->getNumber());
         }
     }
     return '';
 }
Example #4
0
 public function testSeriesVisibility()
 {
     $series = new Opus_Series(1);
     $this->assertEquals($series->getVisible(), '1');
     $series = new Opus_Series(2);
     $this->assertEquals($series->getVisible(), '1');
     $series = new Opus_Series(3);
     $this->assertEquals($series->getVisible(), '1');
     $series = new Opus_Series(4);
     $this->assertEquals($series->getVisible(), '1');
 }
 /**
  * Setzt Defaultwerte für das Formular.
  * @return Opus_Series
  */
 public function getNewModel()
 {
     $series = parent::getNewModel();
     $series->setVisible(1);
     $series->setSortOrder(Opus_Series::getMaxSortKey() + 1);
     return $series;
 }
 /**
  * Für jede Collection der Collection Role series wird eine neue Schriftenreihe
  * Opus_Series angelegt, wobei der Name, die Sichtbarkeit und die Sorierreihenfolge
  * übernommen wird.
  *
  * Die Wurzel-Collection der Collection Role series wird nicht betrachtet.
  *
  * 
  * @return int number of collections that were migrated
  */
 private function migrateCollectionToSeries()
 {
     $numOfCollectionsMigrated = 0;
     foreach (Opus_Collection::fetchCollectionsByRoleId($this->seriesRole->getId()) as $collection) {
         // ignore root collection (does not have valid data and associated documents)
         if ($collection->isRoot()) {
             continue;
         }
         $series = new Opus_Series(Opus_Series::createRowWithCustomId($collection->getId()));
         $series->setTitle($collection->getName());
         $series->setVisible($collection->getVisible());
         $series->setSortOrder($collection->getSortOrder());
         $series->store();
         $this->logger->info('created series with id #' . $collection->getId());
         $numOfCollectionsMigrated++;
     }
     return $numOfCollectionsMigrated;
 }
Example #7
0
 public function __construct($seriesId)
 {
     if (is_null($seriesId)) {
         throw new Solrsearch_Model_Exception('Could not browse series due to missing id parameter.');
     }
     $s = null;
     try {
         $s = new Opus_Series($seriesId);
     } catch (Opus_Model_NotFoundException $e) {
         throw new Solrsearch_Model_Exception("Series with id '" . $seriesId . "' does not exist.");
     }
     if ($s->getVisible() !== '1') {
         throw new Solrsearch_Model_Exception("Series with id '" . $seriesId . "' is not visible.");
     }
     if ($s->getNumOfAssociatedPublishedDocuments() === 0) {
         throw new Solrsearch_Model_Exception("Series with id '" . $seriesId . "' does not have any published documents.");
     }
     $this->_series = $s;
 }
Example #8
0
 /**
  * Return all non-empty visible Opus_Series objects in sorted order.
  *
  * @return array an array of Opus_Series objects
  */
 public function getVisibleNonEmptySeriesSortedBySortKey()
 {
     $visibleSeries = array();
     foreach (Opus_Series::getAllSortedBySortKey() as $series) {
         if ($series->getVisible() == '1' && $series->getNumOfAssociatedPublishedDocuments() > 0) {
             array_push($visibleSeries, $series);
         }
     }
     return $visibleSeries;
 }
Example #9
0
 public function testOptions()
 {
     $element = $this->getElement();
     $allSeries = Opus_Series::getAll();
     $this->assertEquals(count($allSeries), count($element->getMultiOptions()));
     $index = 0;
     foreach ($element->getMultiOptions() as $seriesId => $label) {
         $this->assertEquals($allSeries[$index]->getId(), $seriesId);
         $this->assertEquals($allSeries[$index]->getTitle(), $label);
         $index++;
     }
 }
Example #10
0
 public function init()
 {
     parent::init();
     $this->setRequired(true);
     $this->setDisableTranslator(true);
     // Schriftenreihen werden nicht übersetzt
     $validator = new Zend_Validate_Int();
     $validator->setMessage('validation_error_int');
     $this->addValidator($validator);
     $options = Opus_Series::getAll();
     foreach ($options as $option) {
         $this->addMultiOption($option->getId(), $option->getTitle());
     }
 }
Example #11
0
 public function testPopulateFromModel()
 {
     $form = new Admin_Form_Series();
     $series = new Opus_Series();
     $series->setTitle('TestTitle');
     $series->setInfobox('TestInfo');
     $series->setVisible(1);
     $series->setSortOrder(20);
     $form->populateFromModel($series);
     $this->assertEquals('TestTitle', $form->getElement('Title')->getValue());
     $this->assertEquals('TestInfo', $form->getElement('Infobox')->getValue());
     $this->assertEquals(1, $form->getElement('Visible')->getValue());
     $this->assertEquals(20, $form->getElement('SortOrder')->getValue());
 }
 private function setSortOrders($sortOrders)
 {
     foreach (Opus_Series::getAll() as $seriesItem) {
         $seriesItem->setSortOrder($sortOrders[$seriesItem->getId()]);
         $seriesItem->store();
     }
 }
 private function restoreVisiblitySettings()
 {
     foreach (Opus_Series::getAll() as $seriesItem) {
         $seriesItem->setVisible($this->visibilities[$seriesItem->getId()]);
         $seriesItem->store();
     }
 }
 * @version     $Id: reassign_doc_sort_order.php 12918 2014-01-21 10:06:02Z esimon $
 */
/**
 * 
 * Setzt die interne Sortierreihenfolge (doc_sort_order) für die einer
 * Schriftenreihe zugeordneten Dokumente auf Basis der vergebenenen Bandnummern
 * neu.
 *
 * Dazu werden für eine Schriftenreihe alle Bandnummern der zugeordneten
 * Dokumente ermittelt. Die Dokumente werden anschließend der Schriftenreihe
 * neu zugeordnet. Als Sortierkriterium wird dabei die existierende Bandnummer
 * betrachtet. Sind alle Bandnummern numerisch, so wird numerisch nach
 * Bandnummer sortiert; andernfalls lexikographisch nach Bandnummer.
 *
 */
foreach (Opus_Series::getAll() as $series) {
    echo "\nreassign doc_sort_order for documents in series #" . $series->getId() . ': ';
    $docIds = $series->getDocumentIds();
    if (empty($docIds)) {
        echo "no documents found -- nothing to do\n";
        continue;
    }
    echo count($docIds) . " documents found\n";
    $seriesNumbers = array();
    foreach ($docIds as $docId) {
        $doc = new Opus_Document($docId);
        foreach ($doc->getSeries() as $docSeries) {
            if ($docSeries->getModel()->getId() === $series->getId()) {
                $seriesNumbers[$docId] = $docSeries->getNumber();
            }
        }
Example #15
0
 /**
  * Imports Series from Opus3 to Opus4 in alphabetical order
  *
  * @param DOMDocument $data XML-Document to be imported
  * @return void
  */
 protected function importSeries($data)
 {
     $mf = $this->config->migration->mapping->series;
     $fp = null;
     $fp = @fopen($mf, 'w');
     if (!$fp) {
         $this->logger->log("Could not create '" . $mf . "' for Series", Zend_Log::ERR);
         return;
     }
     $series = $this->transferOpusSeries($data);
     $sort_order = 1;
     foreach ($series as $s) {
         if (array_key_exists('name', $s) === false) {
             continue;
         }
         if (array_key_exists('sr_id', $s) === false) {
             continue;
         }
         $sr = new Opus_Series();
         $sr->setTitle($s['name']);
         $sr->setVisible(1);
         $sr->setSortOrder($sort_order++);
         $sr->store();
         $this->logger->log("Series imported: " . $s['name'], Zend_Log::DEBUG);
         fputs($fp, $s['sr_id'] . ' ' . $sr->getId() . "\n");
     }
     fclose($fp);
 }
Example #16
0
 /**
  * return all visible series from database or cache
  * @return <Array> sets
  */
 private function getSeries()
 {
     $sets = array();
     if (empty($this->series)) {
         foreach ($dbSeries = Opus_Series::getAllSortedBySortKey() as $set) {
             if ($set->getVisible()) {
                 $title = $set->getTitle();
                 $id = $set->getId();
                 $sets[$id] = $title;
             }
         }
         $this->series = $sets;
         return $sets;
     } else {
         return $this->series;
     }
 }
 public function testSeriesIdIsShownInTable()
 {
     $this->dispatch('/admin/series');
     $allSeries = Opus_Series::getAll();
     foreach ($allSeries as $series) {
         $seriesId = $series->getId();
         $this->assertXPathContentContains('//td', "(ID = {$seriesId})");
     }
 }
Example #18
0
 private function _validateSeriesNumber()
 {
     $validSeries = true;
     $series = $this->fetchSeriesFields();
     // in $series befinden sich auch die nicht vom Benutzer ausgefüllten Felder
     $seriesWithoutDefaults = array();
     foreach ($series as $key => $value) {
         if ($value != '') {
             $seriesWithoutDefaults[$key] = $value;
         }
     }
     if (count($seriesWithoutDefaults) == 0) {
         return true;
         // es wurden keine Schriftenreihen / Bandnummern ausgewählt / eingegeben
     }
     // prüfe, ob zu jedem Series-Select eine zugehörige Bandnummer existiert und umgekehrt
     foreach ($seriesWithoutDefaults as $seriesElement => $value) {
         if (strpos($seriesElement, 'Series_') === 0) {
             // Schriftenreihe gefunden: zugehörige Bandnummer erwartet
             $key = str_replace('Series_', 'SeriesNumber_', $seriesElement);
             $errorMsgPrefix = 'seriesnumber';
         } else {
             if (strpos($seriesElement, 'SeriesNumber_') === 0) {
                 // Bandnummer gefunden: zugehörige Schriftenreihe erwartet
                 $key = str_replace('SeriesNumber_', 'Series_', $seriesElement);
                 $errorMsgPrefix = 'seriesselect';
             } else {
                 $this->log->warn(__METHOD__ . " unbekanntes Schriftenreihen-Formularfeld: " . $seriesElement);
                 continue;
             }
         }
         if (!array_key_exists($key, $seriesWithoutDefaults)) {
             // Mismatch gefunden: Validierungsfehlermeldung ausgeben
             $element = $this->form->getElement($key);
             if (!is_null($element)) {
                 $element->clearErrorMessages();
                 $element->addError($this->translate('publish_error_series_missing_' . $errorMsgPrefix));
             }
             $this->log->debug(__METHOD__ . " Feld {$seriesElement} ohne zugehöriges Feld {$key}");
             $validSeries = false;
         }
     }
     foreach ($series as $fieldname => $number) {
         if (strpos($fieldname, 'SeriesNumber_') === 0 && $number != '') {
             $selectFieldName = str_replace('SeriesNumber_', 'Series_', $fieldname);
             if (key_exists($selectFieldName, $this->data)) {
                 $selectFieldValue = $this->data[$selectFieldName];
                 $matches = array();
                 if (preg_match('/^(\\d+)$/', $selectFieldValue, $matches) == 0) {
                     continue;
                 }
                 $seriesId = $matches[1];
                 $currSeries = null;
                 try {
                     $currSeries = new Opus_Series($seriesId);
                 } catch (Opus_Model_Exception $e) {
                     $this->log->err(__METHOD__ . " could not instantiate Opus_Series with id {$seriesId}", $e);
                     $validSeries = false;
                 }
                 if ($currSeries != null && !$currSeries->isNumberAvailable($number)) {
                     $this->log->debug(__METHOD__ . " : error for element {$fieldname} : serial number {$number} not available");
                     $element = $this->form->getElement($fieldname);
                     if (!is_null($element)) {
                         $element->clearErrorMessages();
                         $element->addError($this->translate('publish_error_seriesnumber_not_available'));
                     }
                     $validSeries = false;
                 }
             }
         }
     }
     return $validSeries;
 }
 public function testSortOrderOfSeries()
 {
     $val = new Publish_Model_Validation('Series', $this->session);
     $values = $val->selectOptions();
     $series = Opus_Series::getAllSortedBySortKey();
     $visibleSeries = array();
     foreach ($series as $serie) {
         if ($serie->getVisible() == '1') {
             $visibleSeries[] = $serie->getTitle();
         }
     }
     $this->assertEquals(count($values), count($visibleSeries));
     $index = 0;
     foreach ($values as $name) {
         $this->assertEquals($name, $visibleSeries[$index]);
         $index++;
     }
 }
Example #20
0
 /**
  * return all visible series from database or cache
  * @return <Array> sets
  */
 private function getSeries()
 {
     $sets = array();
     if (empty($this->series)) {
         foreach ($dbSeries = Opus_Series::getAllSortedBySortKey() as $set) {
             if ($set->getVisible()) {
                 $title = $set->getTitle();
                 $id = $set->getId();
                 $sets[$id] = $title;
             }
         }
         $config = Zend_Registry::get('Zend_Config');
         if (isset($config->browsing->series->sortByTitle) && boolval($config->browsing->series->sortByTitle)) {
             uasort($sets, function ($value1, $value2) {
                 return strnatcmp($value1, $value2);
             });
         }
         $this->series = $sets;
         return $sets;
     } else {
         return $this->series;
     }
 }
Example #21
0
 /**
  * Display documents (all or filtered by state)
  *
  * @return void
  */
 public function indexAction()
 {
     $this->view->title = 'admin_documents_index';
     $this->prepareDocStateLinks();
     $url_call_id = array('module' => 'admin', 'controller' => 'document', 'action' => 'index');
     $this->view->url_call_id = $this->view->url($url_call_id, 'default', true);
     $this->prepareSortingLinks();
     $data = $this->_request->getParams();
     $filter = $this->_getParam("filter");
     $this->view->filter = $filter;
     $data = $this->_request->getParams();
     $page = 1;
     if (array_key_exists('page', $data)) {
         // set page if requested
         $page = $data['page'];
     }
     $collectionId = null;
     if (array_key_exists('collectionid', $data)) {
         $collectionId = $data['collectionid'];
     }
     $seriesId = null;
     if (array_key_exists('seriesid', $data)) {
         $seriesId = $data['seriesid'];
     }
     $sort_reverse = $this->getSortingDirection($data);
     $this->view->sort_reverse = $sort_reverse;
     $this->view->sortDirection = $sort_reverse ? 'descending' : 'ascending';
     $state = $this->getStateOption($data);
     $this->view->state = $state;
     $sort_order = $this->getSortingOption($data);
     $this->view->sort_order = $sort_order;
     if (!empty($collectionId)) {
         $collection = new Opus_Collection($collectionId);
         $result = $collection->getDocumentIds();
         $this->view->collection = $collection;
         if ($collection->isRoot()) {
             $collectionRoleName = 'default_collection_role_' . $collection->getRole()->getDisplayName();
             $this->view->collectionName = $this->view->translate($collectionRoleName);
             if ($this->view->collectionName == $collectionRoleName) {
                 $this->view->collectionName = $collection->getRole()->getDisplayName();
             }
         } else {
             $this->view->collectionName = $collection->getNumberAndName();
         }
     } else {
         if (!empty($seriesId)) {
             $series = new Opus_Series($seriesId);
             $this->view->series = $series;
             $result = $series->getDocumentIdsSortedBySortKey();
         } else {
             $result = $this->_helper->documents($sort_order, $sort_reverse, $state);
         }
     }
     $paginator = Zend_Paginator::factory($result);
     $page = 1;
     if (array_key_exists('page', $data)) {
         // paginator
         $page = $data['page'];
     }
     $this->view->maxHitsPerPage = $this->getItemCountPerPage($data);
     $paginator->setItemCountPerPage($this->view->maxHitsPerPage);
     $paginator->setCurrentPageNumber($page);
     $this->view->paginator = $paginator;
     $this->prepareItemCountLinks();
 }