content.php

<?php

/*
 * Copyright (C) 2015 Maarch
 *
 * This file is part of bundle archivesPubliques
 *
 * Bundle archivesPubliques is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Bundle archivesPubliques is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with bundle archivesPubliques.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace ext\archivesPubliques\presentation\maarchRM\Presenter\archivesPubliques;

/**
 * Serializer html of contentDescription
 *
 * @author Alexis Ragot <alexis.ragot@maarch.org>
 */
class content
{
    use \presentation\maarchRM\Presenter\exceptions\exceptionTrait;

    public $view;
    protected $json;

    /**
     * Constuctor of invoice html serializer
     * @param \dependency\html\Document $view The view
     * @param \dependency\html\Document $json The json object
     */
    public function __construct(\dependency\html\Document $view, \dependency\json\JsonObject $json)
    {
        $this->view = $view;

        $this->json = $json;
        $this->json->status = true;
    }

    /**
     * Formulaire de recherche d'un contenu d'archive
     *
     * @return string
     */
    public function search()
    {
        $currentService = \laabs::getToken("ORGANIZATION");
        if (!$currentService) {
            $this->view->addContentFile("recordsManagement/welcome/noWorkingOrg.html");
            $this->view->translate();


            return $this->view->saveHtml();
        }

        $archivalProfiles = \laabs::callService('recordsManagement/archivalProfile/readIndex');
        $archivalAgreements = \laabs::callService('medona/archivalAgreement/readIndex');

        $this->view->addContentFile("archivesPubliques/contentDescription/search.html");

        // $ownerOriginatorOrgs = $this->getOwnerOrgs($currentService, 'originator');
        $orgController = \laabs::newController('organization/organization');

        $ownerOriginatorOrgs = [];

        $originators = $orgController->getOriginator();
        foreach ($originators as $originator) {
            if (!isset($ownerOriginatorOrgs[(string) $originator->ownerOrgId])) {
                $ownerOriginatorOrgs[(string) $originator->ownerOrgId] = new \stdClass();
                $ownerOriginatorOrgs[(string) $originator->ownerOrgId]->displayName = $originator->ownerOrgName;
                $ownerOriginatorOrgs[(string) $originator->ownerOrgId]->originators = [];
            }
            if (!in_array($originator, $ownerOriginatorOrgs[(string) $originator->ownerOrgId]->originators)) {
                $ownerOriginatorOrgs[(string)$originator->ownerOrgId]->originators[] = $originator;
            }
        }

        $ownerDepositorOrgs = $this->getOwnerOrgs($currentService, 'depositor');

        /*foreach ($ownerOriginatorOrgs as $ownerOriginatorOrgs) {
            if (!isset($ownerOriginatorOrgs[(string) $ownerOriginatorOrgs->ownerOrgId])) {
                $orgObject = \laabs::callService('organization/organization/read_orgId_', (string) $ownerOriginatorOrgs->ownerOrgId);

                $ownerOriginatorOrgs[(string) $orgObject->orgId] = new \stdClass();
                $ownerOriginatorOrgs[(string) $orgObject->orgId]->displayName = $orgObject->displayName;
                $ownerOriginatorOrgs[(string) $orgObject->orgId]->originators = [];
            }
            $ownerOriginatorOrgs[(string) $orgObject->orgId]->originators[] = $originator;
        }*/

        /*foreach ($depositors as $depositor) {
            if (!isset($ownerDepositorOrgs[(string) $depositor->ownerOrgId])) {
                $orgObject = \laabs::callService('organization/organization/read_orgId_', (string) $depositor->ownerOrgId);

                $ownerDepositorOrgs[(string) $orgObject->orgId] = new \stdClass();
                $ownerDepositorOrgs[(string) $orgObject->orgId]->displayName = $orgObject->displayName;
                $ownerDepositorOrgs[(string) $orgObject->orgId]->depositors = [];
            }

            $ownerDepositorOrgs[(string) $orgObject->orgId]->depositors[] = $depositor ;
        }*/

        $thesaurusNames = [
            "corpname",
            "famname",
            "geogname",
            "name",
            "occupation",
            "persname",
            "subject",
            "genreform",
            "function"
            ];

        $thesaurusList = new \stdClass();
        // Set default thesaurus
        $thesaurusList->subject = "T1";
        $thesaurusList->genreform = "T3";
        $thesaurusList->function = "T2";

        $conf = \laabs::Configuration()['recordsManagement'];
        
        if (isset($conf['refDirectory']) || is_dir($conf['refDirectory'])) {
            $refDirectory = $conf['refDirectory'];
            foreach ($thesaurusNames as $thesaurusName) {
                if (is_file($conf['refDirectory'].'/'.$thesaurusName.'.csv')) {
                    $thesaurusList->{$thesaurusName} = $thesaurusName;
                }
            }
        }

        $maxResults = null;
        if (isset(\laabs::configuration('presentation.maarchRM')['maxResults'])) {
            $maxResults = \laabs::configuration('presentation.maarchRM')['maxResults'];
        }

        $retentionRules = \laabs::callService('recordsManagement/retentionRule/readIndex');
        // sort retention rules alphabetically and add Capitalized letter on first character
        usort($retentionRules, function ($a, $b) {
            $a->label = ucfirst($a->label);
            $b->label = ucfirst($b->label);
            return $a->label <=> $b->label;
        });
        for ($i = 0, $count = count($retentionRules); $i < $count; $i++) {
            $retentionRules[$i]->durationText = (string) $retentionRules[$i]->duration;
        }

        $this->view->translate();
        $this->view->setSource('maxResults', $maxResults);
        $this->view->setSource('retentionRules', $retentionRules);
        $this->view->setSource('profiles', $archivalProfiles);
        $this->view->setSource('thesaurus', $thesaurusList);
        $this->view->setSource('archivalAgreements', $archivalAgreements);
        $this->view->setSource('ownerOriginatorOrgs', $ownerOriginatorOrgs);
        $this->view->setSource("organizationsOriginator", $ownerOriginatorOrgs);
        $this->view->setSource('ownerDepositorOrgs', $ownerDepositorOrgs);
        $this->view->setSource('isPublicArchive', true);
        $this->view->merge();

        return $this->view->saveHtml();
    }

    /**
     * Get the list of user accessible oranizations
     * @param object $currentService The user's current service
     * @param string $role           The org unit role to select
     *
     * @return The list of user accessible  orgs
     */
    protected function getOwnerOrgs($currentService, $role)
    {
        $orgUnits = \laabs::callService('organization/organization/readByrole_role_', $role);

        $userPositionController = \laabs::newController('organization/userPosition');
        $orgController = \laabs::newController('organization/organization');

        $owner = false;
        $archiver = false;
        $userOrgUnits = [];
        $userOrgs = [];

        $userOrgUnitOrgRegNumbers = array_merge(array($currentService->registrationNumber), $userPositionController->readDescandantService((string) $currentService->orgId));
        foreach ($userOrgUnitOrgRegNumbers as $userOrgUnitOrgRegNumber) {
            $userOrgUnit = $orgController->getOrgByRegNumber($userOrgUnitOrgRegNumber);
            $userOrgUnits[] = $userOrgUnit;
            if (isset($userOrgUnit->orgRoleCodes)) {
                foreach ($userOrgUnit->orgRoleCodes as $orgRoleCode) {
                    if ($orgRoleCode == 'owner') {
                        $owner = true;
                    }
                    if ($orgRoleCode == 'archiver') {
                        $archiver = true;
                    }
                }
            }
        }

        foreach ($userOrgUnits as $userOrgUnit) {
            foreach ($orgUnits as $orgUnit) {
                if (
                    // Owner = all originators
                    $owner
                    // Archiver = all originators fo the same org
                    || ($archiver && $orgUnit->ownerOrgId == $userOrgUnit->ownerOrgId)
                    // Originator = all originators at position and sub-services
                    || ($role == 'originator' && $orgUnit->registrationNumber == $userOrgUnit->registrationNumber)
                    // Depositor = all
                    || $role == 'depositor'
                    ) {
                    if (!isset($userOrgs[(string) $orgUnit->ownerOrgId])) {
                        $orgObject = \laabs::callService('organization/organization/read_orgId_', (string) $orgUnit->ownerOrgId);

                        $userOrgs[(string) $orgObject->orgId] = new \stdClass();
                        $userOrgs[(string) $orgObject->orgId]->displayName = $orgObject->displayName;
                        $userOrgs[(string) $orgObject->orgId]->originators = [];
                    }
                    if (!in_array($orgUnit, $userOrgs[(string) $orgObject->orgId]->originators)) {
                        $userOrgs[(string)$orgObject->orgId]->originators[] = $orgUnit;
                    }
                }
            }
        }

        return $userOrgs;
    }

    /**
     * Resultat de recherche d'un contenu d'archive
     * @param array   $archives Array of archive object
     * @param integer $count    Max count of archives from search without limit
     *
     * @return string
     */
    public function find(array $archives, $count)
    {
        $this->view->addContentFile("archivesPubliques/contentDescription/list.html");
        $this->view->translate();

        $transaction = isset(\laabs::configuration("medona")["transaction"]);

        $originators = array();
        $this->organizationController = \laabs::newController('organization/organization');
        foreach ((array) $this->organizationController->getOrgsByRole('originator') as $originator) {
            $originators[(string) $originator->registrationNumber] = $originator;
        }

        //access code selector
        $accessRuleController = \laabs::newController('recordsManagement/accessRule');
        $accessRules = $accessRuleController->index();
        foreach ($accessRules as $accessRule) {
            $accessRule->json = json_encode($accessRule);
            if ($accessRule->duration != null) {
                $accessRule->accessRuleDurationUnit = substr($accessRule->duration, -1);
                $accessRule->accessRuleDuration = substr($accessRule->duration, 1, -1);
            }
        }

        //retention code selector
        $retentionRuleController = \laabs::newController('recordsManagement/retentionRule');
        $retentionRules = $retentionRuleController->index();
        foreach ($retentionRules as $retentionRule) {
            $retentionRule->json = json_encode($retentionRule);
            if ($retentionRule->duration != null) {
                $retentionRule->retentionRuleDurationUnit = substr($retentionRule->duration, -1);
                $retentionRule->retentionRuleDuration = substr($retentionRule->duration, 1, -1);
            }
        }

        $positionController = \laabs::newController("organization/userPosition");
        $descendantServices = $positionController->listMyCurrentDescendantServices(\laabs::getToken("ORGANIZATION")->orgId);

        $currentDate = \laabs::newDate();
        $archiveController = \laabs::newController('recordsManagement/archive');

        $collection = \laabs::callService('Collection/Collection/readByUser');

        foreach ($archives as $archive) {
            $archive->finalDispositionDesc = $this->view->translator->getText($archive->finalDisposition, false, "recordsManagement/messages");
            $archive->statusDesc = $this->view->translator->getText($archive->status, false, "recordsManagement/messages");

            if ($archive->status == 'disposed' || $archive->status == 'error' || $archive->status == 'restituted' || $archive->status == 'transfered') {
                $archive->statusModif = true;
            }
            if (!empty($archive->disposalDate) && $archive->disposalDate <= $currentDate) {
                $archive->disposable = true;
            }
            if (isset($originators[$archive->originatorOrgRegNumber])) {
                $archive->originator = $originators[$archive->originatorOrgRegNumber];
            } else {
                $archive->originator = $archive->originatorOrgRegNumber;
            }

            $archive->restituable = false;
            if ($archive->status == 'preserved' && in_array($archive->originatorOrgRegNumber, $descendantServices)) {
                $archive->restituable = true;
            }

            if (isset($archive->description) && is_object($archive->description)) {
                if (isset($archive->description->startDate)) {
                    $archive->startDate = \laabs::newDate($archive->description->startDate);
                }

                if (isset($archive->description->endDate)) {
                    $archive->endDate = \laabs::newDate($archive->description->endDate);
                }
            }

            $archive->isInUserCollection = false;
            if (!is_null($collection->archiveIds) && !empty($collection->archiveIds)) {
                foreach ($collection->archiveIds as $collectedArchiveId) {
                    if ($collectedArchiveId == $archive->archiveId) {
                        $archive->isInUserCollection = true;
                    }
                }
            }

            $archive->isCommunicable = '2';
            if ($archive->accessRuleComDate) {
                $communicationDelay = $archive->accessRuleComDate->diff(\laabs::newTimestamp());
                if ($communicationDelay->invert != 0) {
                    $archive->isCommunicable = '1';
                }
            } elseif (
                isset(\laabs::configuration("recordsManagement")['actionWithoutCommunicationRule'])
                && \laabs::configuration("recordsManagement")['actionWithoutCommunicationRule'] == 'deny'
            ) {
                $archive->isCommunicable = '1';
            }
            $archive->actions = array();

            try {
                if (
                    $archive->status == 'disposed'
                    || $archive->status == 'error'
                    || $archive->status == 'restituted'
                    || $archive->status == 'transfered'
                ) {
                    $archive->hasRights = false;
                } elseif ($archive->isCommunicable == '2') {
                    $archive->hasRights = true;
                } else {
                    $archive->hasRights = $archiveController->checkRights($archive);
                }
            } catch (\Exception $e) {
                $archive->hasRights = false;
            }
        }

        $hasReachMaxResults = false;
        if (
            isset(\laabs::configuration('presentation.maarchRM')['maxResults'])
            && count($archives) >= \laabs::configuration('presentation.maarchRM')['maxResults']
        ) {
            $hasReachMaxResults = true;
        }

        $this->readPrivilegesOnArchives();

        $this->view->setSource('hasReachMaxResults', $hasReachMaxResults);
        $this->view->setSource('totalResultsWithoutLimit', $count);
        $this->view->setSource('maxResults', \laabs::configuration('presentation.maarchRM')['maxResults']);
        $this->view->setSource('content', $archives);
        $this->view->setSource("accessRules", $accessRules);
        $this->view->setSource("retentionRules", $retentionRules);
        $this->view->setSource('transaction', $transaction);
        $packageSchemas = \laabs::configuration("medona")["packageSchemas"];
        $this->view->setSource('packageSchemas', $packageSchemas);
        $this->view->setSource('collection', $collection);

        $this->view->merge();

        $dataTable = $this->view->getElementsByClass("dataTable")->item(0)->plugin['dataTable'];

        $dataTable->setPaginationType("full_numbers");
        $dataTable->setUnsortableColumns(0, 6);
        $dataTable->setSorting(array(array(3, 'desc')));

        $dataTable->setColumnsToExport([1, 2, 3, 4, 5]);
        $titleExport = $this->view->translator->getText(
            "Export to ",
            false,
            "recordsManagement/messages"
        );

        $dataTable->setExport(
            [
                [
                    "exportType" => "csv",
                    "text" => "<i class='fa fa-download'></i> CSV",
                    "titleAttr" => $titleExport . "CSV"
                ],
                [
                    "exportType" => "pdf",
                    "text" => "<i class='fa fa-download'></i> PDF",
                    "titleAttr" => $titleExport . "PDF"
                ]
            ],
            false
        );

        return $this->view->saveHtml();
    }

    /**
     * Read users privileges on archives
     */
    protected function readPrivilegesOnArchives()
    {
        $hasModificationPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "archiveManagement/modify");
        $hasIntegrityCheckPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "archiveManagement/checkIntegrity");
        $hasDestructionPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "destruction/destructionRequest");
        $hasDestructionCancelPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "destruction/destructionCancel");
        $hasRestitutionPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "restitution/restitutionRequest");
        $hasDeliveryPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "delivery/deliveryRequest");
        $hasTransferPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "definitiveTransfer/outgoingTransferSend");
        $hasModificationRequestPrivilege = \laabs::callService('auth/userAccount/readHasprivilege', "archiveManagement/modificationRequestSend");
        
        $this->view->setSource('hasModificationPrivilege', $hasModificationPrivilege);
        $this->view->setSource('hasIntegrityCheckPrivilege', $hasIntegrityCheckPrivilege);
        $this->view->setSource('hasDestructionPrivilege', $hasDestructionPrivilege);
        $this->view->setSource('hasDestructionCancelPrivilege', $hasDestructionCancelPrivilege);
        $this->view->setSource('hasRestitutionPrivilege', $hasRestitutionPrivilege);
        $this->view->setSource('hasDeliveryPrivilege', $hasDeliveryPrivilege);
        $this->view->setSource('hasTransferPrivilege', $hasTransferPrivilege);
        $this->view->setSource('hasModificationRequestPrivilege', $hasModificationRequestPrivilege);
    }

    /**
     * Visualisation d'une archive publique
     * @param archivesPubliques/content[] $contents The archive description
     *
     * @return string
     */
    public function read($contents)
    {
        $languageCodes = \laabs::callService("seda/archiveTransferComposition/readLanguageCodes");
        $this->view->addContentFile("archivesPubliques/contentDescription/contentDescription.table.html");
        $this->view->translate();

        /*$keywordTypesDoc = \laabs::newService('dependency/xml/Document');
        $keywordTypesDoc->load('bundle/seda/Resources/xsd/seda/v10/codes/seda_v1-0_keywordtype_code.xsd');
        $keywordTypesXpath = \laabs::newService('dependency/xml/XPath', $keywordTypesDoc);
        $keywordTypesXpath->registerNamespace('xsd', "http://www.w3.org/2001/XMLSchema");
        $keywordTypesXpath->registerNamespace('ccts', "urn:un:unece:uncefact:documentation:standard:CoreComponentsTechnicalSpecification:2");
        */

        $keywordTypes = array(
            'corpname' => 'Collectivité',
            'famname' => 'Nom de famille',
            'geogname' => 'Nom géographique',
            'name' => 'Nom',
            'occupation' => 'Fonction',
            'persname' => 'Nom de personne',
            'subject' => 'Mot-matière',
            'genreform' => 'Type de document',
            'function' => 'Activité',
        );

        $descriptionLevels = array(
            'class',
            'collection',
            'file',
            'fonds',
            'item',
            'recordgrp',
            'series',
            'subfonds',
            'subgrp',
            'subseries'
        );
        if (empty($contents)) {
            $this->view->merge();

            return $this->view->saveHtml();
        }



        if (is_array($contents)) {
            $hasContent = false;
            foreach ($contents as $content) {
                if (empty($content->resId)) {
                    $hasContent = true;
                    break;
                }
            }
            if (!$hasContent) {
                $this->view->merge();

                return $this->view->saveHtml();
            }
        } else {
            $content = $contents;
        }

        if (!empty($content->startDate) || !empty($content->endDate)) {
            $content->hasDateRange = true;
        }

        // Backward compat with bug #13540
        $content->descriptionLevel = strtolower($content->descriptionLevel);

        if (isset($content->language) && is_string($content->language)) {
            $content->language=[$content->language];
        }

        if (!empty($content->language) && count($content->language)) {
            $languageList = [];
            foreach ($content->language as $language) {
                foreach ($languageCodes as $languageCode) {
                    if ($language === $languageCode->alpha3b || $language === $languageCode->alpha3t) {
                        $languageList[] = ucfirst($languageCode->French);
                        break;
                    }
                }
            }

            $content->language = $languageList;
        }

        if (!empty($content->keyword) && count($content->keyword)) {
            foreach ($content->keyword as $keyword) {
                if (isset($keywordTypes[$keyword->type])) {
                    $keyword->type = $keywordTypes[$keyword->type];
                }
            }
        }

        $this->view->setSource("content", $content);
        $this->view->merge();

        return $this->view->saveHtml();
    }

    //JSON
    /**
     * Exception
     * @param archivesPubliques/Exception/contentDescriptionException $contentDescriptionException
     *
     * @return string
     */
    public function contentDescriptionException($contentDescriptionException)
    {
        $this->json->load($contentDescriptionException);
        $this->json->status = false;

        return $this->json->save();
    }

    /**
     * Get the list of owner originators oranizations
     * @param object $currentService The user's current service
     *
     * @return The list of owner originators orgs
     */
    protected function getOwnerOriginatorsOrgs($currentService)
    {
        $originators = \laabs::callService('organization/organization/readIndex', 'isOrgUnit=true');

        $userPositionController = \laabs::newController('organization/userPosition');
        $orgController = \laabs::newController('organization/organization');

        $owner = false;
        $userServices = [];
        $ownerOriginatorOrgs = [];

        // Get all user services,  and check OWNER role on one of them
        $userServiceOrgRegNumbers = array_merge(array($currentService->registrationNumber), $userPositionController->readDescandantService((string) $currentService->orgId));
        foreach ($userServiceOrgRegNumbers as $userServiceOrgRegNumber) {
            $userService = $orgController->getOrgByRegNumber($userServiceOrgRegNumber);
            $userServices[] = $userService;
            if (isset($userService->orgRoleCodes)) {
                foreach ($userService->orgRoleCodes as $orgRoleCode) {
                    if ($orgRoleCode == 'owner') {
                        $owner = true;

                        break;
                    }
                }
            }
        }
        foreach ($userServices as $userService) {
            foreach ($originators as $originator) {
                if ($owner || $originator->registrationNumber == $userService->registrationNumber) {
                    if (!isset($ownerOriginatorOrgs[(string) $originator->ownerOrgId])) {
                        $orgObject = \laabs::callService('organization/organization/read_orgId_', (string) $originator->ownerOrgId);
                        $ownerOriginatorOrgs[(string) $orgObject->orgId] = new \stdClass();
                        $ownerOriginatorOrgs[(string) $orgObject->orgId]->displayName = $orgObject->displayName;
                        $ownerOriginatorOrgs[(string) $orgObject->orgId]->orgId = $orgObject->orgId;
                        $ownerOriginatorOrgs[(string) $orgObject->orgId]->originators = [];
                    }
                    $ownerOriginatorOrgs[$originator->ownerOrgId]->originators[] = $originator;
                }
            }
        }

        return $ownerOriginatorOrgs;
    }

    /**
     * Get metadata to edit
     * @param archive           $archive
     * @param language code     $languageCodes
     *
     * @return string
     */
    public function edit($archive)
    {
        $this->view->addContentFile("archivesPubliques/contentDescription/metadata.html");

        $languageCodes = \laabs::callService("seda/archiveTransferComposition/readLanguageCodes");

        foreach ($languageCodes as $languageCode) {
            $languageCode->title =  ucfirst($languageCode->French);

            if ($languageCode->alpha3t) {
                $languageCode->value = $languageCode->alpha3t;
            } else {
                $languageCode->value = $languageCode->alpha3b;
            }
        }

        foreach ($archive->descriptionObject as $descriptionObject) {
            $descriptionObject->json = json_encode($descriptionObject);
        }

        if (isset($archive->descriptionObject[0]->language)) {
            $archive->descriptionObject[0]->lang = [];
            for ($i = 0; $i < count($archive->descriptionObject[0]->language); $i++) {
                $language = new \stdClass();
                $language->value = $archive->descriptionObject[0]->language[$i];

                foreach ($languageCodes as $languageCode) {
                    if ($languageCode->value === $archive->descriptionObject[0]->language[$i]) {
                        $language->name = $languageCode->title;
                    }
                }
                $archive->descriptionObject[0]->lang[] = $language;
            }
        }

        if (isset($archive->descriptionObject[0]->custodialHistory)) {
            foreach ($archive->descriptionObject[0]->custodialHistory as $custodialHistory) {
                $custodialHistory->json = json_encode($custodialHistory);
            }
        }

        if (isset($archive->descriptionObject[0]->keyword)) {
            foreach ($archive->descriptionObject[0]->keyword as $keyword) {
                $keyword->typeText = $this->view->translator->getText($keyword->type, false, "archivesPubliques/messages");
                $keyword->json = json_encode($keyword);
            }
        }

        if ($archive->descriptionObject) {
            $archive->descriptionObject = $archive->descriptionObject[0];
        }

        $thesaurusNames = [
            "corpname",
            "famname",
            "geogname",
            "name",
            "occupation",
            "persname",
            "subject",
            "genreform",
            "function"
            ];

        $thesaurusList = new \stdClass();
        // Set default thesaurus
        $thesaurusList->subject = "T1";
        $thesaurusList->genreform = "T3";
        $thesaurusList->function = "T2";

        $conf = \laabs::Configuration()['recordsManagement'];

        if (isset($conf['refDirectory']) || is_dir($conf['refDirectory'])) {
            $refDirectory = $conf['refDirectory'];
            foreach ($thesaurusNames as $thesaurusName) {
                if (glob($conf['refDirectory'].'/'.$thesaurusName.'.*')) {
                    $thesaurusList->$thesaurusName = $thesaurusName;
                }
            }
        }

        $this->view->setSource('thesaurus', $thesaurusList);
        $this->view->setSource('languageCodes', $languageCodes);
        $this->view->setSource("archive", $archive);

        $this->view->merge();
        $this->view->translate();

        return $this->view->saveHtml();
    }
}