functions.php

<?php
/**
 * @copyright Roy Rosenzweig Center for History and New Media, 2007-2012
 * @license http://www.gnu.org/licenses/gpl-3.0.txt
 * @package ExhibitBuilder
 */

/**
 * Add EB's translations directory for all requests.
 */
function exhibit_builder_initialize()
{
    add_translation_source(dirname(__FILE__) . '/languages');
    add_shortcode ('exhibits', 'exhibit_builder_exhibits_shortcode');
    add_shortcode ('featured_exhibits', 'exhibit_builder_featured_exhibits_shortcode');
}

/**
 * Install the plugin, creating the tables in the database.
 */
function exhibit_builder_install()
{
    $db = get_db();

    $db->query(<<<SQL
CREATE TABLE IF NOT EXISTS `{$db->prefix}exhibits` (
    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
    `title` VARCHAR(255) DEFAULT NULL,
    `description` TEXT,
    `credits` TEXT,
    `featured` TINYINT(1) DEFAULT 0,
    `public` TINYINT(1) DEFAULT 0,
    `theme` VARCHAR(30) DEFAULT NULL,
    `theme_options` TEXT,
    `slug` VARCHAR(30) NOT NULL,
    `added` TIMESTAMP NOT NULL DEFAULT '2000-01-01 00:00:00',
    `modified` TIMESTAMP NOT NULL DEFAULT '2000-01-01 00:00:00',
    `owner_id` INT UNSIGNED DEFAULT NULL,
    `use_summary_page` TINYINT(1) DEFAULT 1,
    `cover_image_file_id` INT UNSIGNED DEFAULT NULL,
    `summary_template` VARCHAR(255) DEFAULT NULL,
    PRIMARY KEY  (`id`),
    UNIQUE KEY `slug` (`slug`),
    KEY `public` (`public`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
SQL
    );

    $db->query(<<<SQL
CREATE TABLE IF NOT EXISTS `{$db->prefix}exhibit_pages` (
    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
    `exhibit_id` INT UNSIGNED NOT NULL,
    `parent_id` INT UNSIGNED DEFAULT NULL,
    `title` VARCHAR(255) DEFAULT NULL,
    `short_title` VARCHAR(255) DEFAULT NULL,
    `slug` VARCHAR(30) NOT NULL,
    `layout` VARCHAR(255) DEFAULT NULL,
    `layout_data` TEXT,
    `order` SMALLINT UNSIGNED DEFAULT NULL,
    `added` TIMESTAMP NOT NULL DEFAULT '2000-01-01 00:00:00',
    `modified` TIMESTAMP NOT NULL DEFAULT '2000-01-01 00:00:00',
    PRIMARY KEY  (`id`),
    KEY `exhibit_id_order` (`exhibit_id`, `order`),
    UNIQUE KEY `exhibit_id_parent_id_slug` (`exhibit_id`, `parent_id`, `slug`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
SQL
    );

    $db->query(<<<SQL
CREATE TABLE IF NOT EXISTS `{$db->prefix}exhibit_page_blocks` (
    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
    `page_id` INT UNSIGNED NOT NULL,
    `layout` VARCHAR(50) NOT NULL,
    `layout_data` TEXT,
    `options` TEXT,
    `text` MEDIUMTEXT,
    `order` SMALLINT UNSIGNED DEFAULT NULL,
    PRIMARY KEY (`id`),
    KEY `page_id_order` (`page_id`, `order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
SQL
    );

    $db->query(<<<SQL
CREATE TABLE IF NOT EXISTS `{$db->prefix}exhibit_block_attachments` (
    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
    `block_id` INT UNSIGNED NOT NULL,
    `item_id` INT UNSIGNED NOT NULL,
    `file_id` INT UNSIGNED DEFAULT NULL,
    `caption` TEXT,
    `order` SMALLINT UNSIGNED DEFAULT NULL,
    PRIMARY KEY (`id`),
    KEY `block_id_order` (`block_id`, `order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
SQL
    );
}

/**
 * Uninstall the plugin.
 */
function exhibit_builder_uninstall()
{
    // drop the tables
    $db = get_db();
    $sql = "DROP TABLE IF EXISTS `{$db->prefix}exhibits`";
    $db->query($sql);
    $sql = "DROP TABLE IF EXISTS `{$db->prefix}exhibit_pages`";
    $db->query($sql);
    $sql = "DROP TABLE IF EXISTS `{$db->prefix}exhibit_page_blocks`";
    $db->query($sql);
    $sql = "DROP TABLE IF EXISTS `{$db->prefix}exhibit_block_attachments`";
    $db->query($sql);

    // delete plugin options
    delete_option('exhibit_builder_sort_browse');
    delete_option('exhibit_builder_researcher_permissions');
}

/**
 * Upgrades ExhibitBuilder's tables to be compatible with a new version.
 *
 * @param array $args expected keys:
 *  'old_version' => Previous plugin version
 *  'new_version' => Current version; to be upgraded to
 */
function exhibit_builder_upgrade($args)
{
    $oldVersion = $args['old_version'];
    $newVersion = $args['new_version'];

    $db = get_db();

    // MySQL 5.7+ fix; must do first or else MySQL complains about any other ALTER
    if (version_compare($oldVersion, '3.3', '<')) {
        $sql = <<<SQL
ALTER TABLE `{$db->prefix}exhibits`
    ALTER `added` SET DEFAULT '2000-01-01 00:00:00',
    ALTER `modified` SET DEFAULT '2000-01-01 00:00:00'
SQL;
        $db->query($sql);
    }

    // Transition to upgrade model for EB
    if (version_compare($oldVersion, '0.6', '<') )
    {
        $sql = "ALTER TABLE `{$db->prefix}exhibits` ADD COLUMN `theme_options` text collate utf8_unicode_ci default NULL AFTER `theme`";
        $db->query($sql);
    }

    if (version_compare($oldVersion, '0.6', '<=') )
    {
        $sql = "ALTER TABLE `{$db->prefix}items_section_pages` ADD COLUMN `caption` text collate utf8_unicode_ci default NULL AFTER `text`";
        $db->query($sql);
    }

    if(version_compare($oldVersion, '2.0-dev', '<')) {
        // Automatically skip these steps if the final one is already done
        // (would happen on retry of an earlier failed upgrade)
        $renamesDone = (bool) $db->fetchOne("SHOW TABLES LIKE '{$db->prefix}exhibit_pages'");
        if (!$renamesDone) {
            $sql = "RENAME TABLE `{$db->prefix}items_section_pages` TO `{$db->prefix}exhibit_page_entries`";
            $db->query($sql);

            //alter the section_pages table into revised exhibit_pages table
            $sql = "ALTER TABLE `{$db->prefix}section_pages` ADD COLUMN `parent_id` INT UNSIGNED NULL AFTER `id`";
            $db->query($sql);

            $sql = "ALTER TABLE `{$db->prefix}section_pages` ADD COLUMN `exhibit_id` INT UNSIGNED NOT NULL AFTER `parent_id`";
            $db->query($sql);

            $sql = "RENAME TABLE `{$db->prefix}section_pages` TO `{$db->prefix}exhibit_pages`";
            $db->query($sql);
        }

        // Remove any broken pages or artifacts from a failed upgrade
        $sql = "DELETE FROM `{$db->prefix}exhibit_pages` WHERE section_id = 0";
        $db->query($sql);

        // Get all the data about sections to turn them into ExhibitPages
        $sql = "SELECT * FROM `{$db->prefix}sections` ";
        $result = $db->query($sql);
        $sectionData = $result->fetchAll();

        $sectionIdMap = array();
        foreach($sectionData as $section) {
            // Create a page for each section
            $newPageData = array(
                'title' => $section['title'],
                'parent_id' => null,
                'exhibit_id' => $section['exhibit_id'],
                'section_id' => 0,
                'layout' => 'text',
                'slug' => $section['slug'],
                'order' => $section['order']
            );
            $db->getAdapter()->insert($db->ExhibitPage, $newPageData);
            $pageId = (int) $db->lastInsertId();

            $sectionIdMap[$section['id']] = array('pageId' => $pageId, 'exhibitId' => $section['exhibit_id']);

            //slap the section's description into a text entry for the page
            $newEntryData = array(
                'page_id' => $pageId,
                'order' => 1,
                'text' => $section['description']
            );
            $db->getAdapter()->insert($db->ExhibitPageEntry, $newEntryData);
        }

        //map the old section ids to the new page ids, and slap in the correct exhibit id.
        foreach($sectionIdMap as $sectionId => $data) {
            $updateData = array(
                'parent_id' => $data['pageId'],
                'exhibit_id' => $data['exhibitId']
            );
            $db->update($db->ExhibitPage, $updateData,
                array('section_id = ?' => $sectionId));
        }

        $sql = "ALTER TABLE `{$db->prefix}exhibit_pages` DROP `section_id` ";
        $db->query($sql);

        //finally kill the sections for good.
        $sql = "DROP TABLE `{$db->prefix}sections`";
        $db->query($sql);
    }

    if(version_compare($oldVersion, '2.0-dev2', '<')) {
        $sql = "ALTER TABLE `{$db->prefix}exhibit_page_entries` ADD `file_id` INT UNSIGNED DEFAULT NULL AFTER `item_id`";
        $db->query($sql);

        $sql = "ALTER TABLE `{$db->prefix}exhibit_page_entries` ADD INDEX `page_id_order` (`page_id`, `order`)";
        $db->query($sql);

        $sql = "ALTER TABLE `{$db->prefix}exhibit_pages` ADD INDEX `exhibit_id_order` (`exhibit_id`, `order`)";
        $db->query($sql);

        delete_option('exhibit_builder_use_browse_exhibits_for_homepage');
    }

    if (version_compare($oldVersion, '2.0', '<=')) {
        $sql = "ALTER TABLE `{$db->prefix}exhibit_pages` ADD UNIQUE INDEX `exhibit_id_parent_id_slug` (`exhibit_id`, `parent_id`, `slug`)";
        $db->query($sql);
    }

    if (version_compare($oldVersion, '3.0-dev', '<')) {
        $db->query(<<<SQL
CREATE TABLE IF NOT EXISTS `{$db->prefix}exhibit_page_blocks` (
    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
    `page_id` INT UNSIGNED NOT NULL,
    `layout` VARCHAR(50) NOT NULL,
    `options` TEXT,
    `text` MEDIUMTEXT,
    `order` SMALLINT UNSIGNED DEFAULT NULL,
    PRIMARY KEY (`id`),
    KEY `page_id_order` (`page_id`, `order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
SQL
        );

        $db->query(<<<SQL
CREATE TABLE IF NOT EXISTS `{$db->prefix}exhibit_block_attachments` (
    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
    `block_id` INT UNSIGNED NOT NULL,
    `item_id` INT UNSIGNED NOT NULL,
    `file_id` INT UNSIGNED DEFAULT NULL,
    `caption` TEXT,
    `order` SMALLINT UNSIGNED DEFAULT NULL,
    PRIMARY KEY (`id`),
    KEY `block_id_order` (`block_id`, `order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
SQL
        );

        $sql = "SELECT id, layout FROM `{$db->prefix}exhibit_pages` ORDER BY id";
        $pages = $db->query($sql)->fetchAll();

        $upgrader = new ExhibitPageUpgrader($db);
        foreach ($pages as $page) {
            $upgrader->upgradePage($page['id'], $page['layout']);
        }

        $sql = "DROP TABLE `{$db->prefix}exhibit_page_entries`";
        $db->query($sql);

        $sql = "ALTER TABLE `{$db->prefix}exhibit_pages` DROP COLUMN `layout`";
        $db->query($sql);
    }

    if (version_compare($oldVersion, '3.1.4', '<')) {
        $sql = "ALTER TABLE `{$db->prefix}exhibits` ADD `use_summary_page` TINYINT(1) DEFAULT 1 AFTER `owner_id`";
        $db->query($sql);
    }

    if (version_compare($oldVersion, '3.3', '<')) {
        $sql = <<<SQL
ALTER TABLE `{$db->prefix}exhibits`
    ADD `cover_image_file_id` INT UNSIGNED DEFAULT NULL AFTER `use_summary_page`
SQL;
        $db->query($sql);
    }

    if (version_compare($oldVersion, '3.3.3', '<')) {
        $sql = <<<SQL
ALTER TABLE `{$db->prefix}exhibit_pages`
              ADD `added` TIMESTAMP NOT NULL DEFAULT '2000-01-01 00:00:00',
              ADD `modified` TIMESTAMP NOT NULL DEFAULT '2000-01-01 00:00:00'
SQL;
        $db->query($sql);
    }

    if (version_compare($oldVersion, '3.3.4', '<')) {
        $sql = "ALTER TABLE `{$db->prefix}exhibit_pages` ADD `short_title` VARCHAR(255) DEFAULT NULL";
        $db->query($sql);
    }

    if (version_compare($oldVersion, '3.11.0-alpha', '<')) {
        $sql = "ALTER TABLE `{$db->prefix}exhibit_pages` ADD `layout` VARCHAR(255) DEFAULT NULL, ADD `layout_data` TEXT";
        $db->query($sql);
        $sql = "ALTER TABLE `{$db->prefix}exhibit_page_blocks` ADD `layout_data` TEXT";
        $db->query($sql);
    }

    if (version_compare($oldVersion, '3.11.1', '<')) {
        $sql = "ALTER TABLE `{$db->prefix}exhibits` ADD `summary_template` VARCHAR(255) DEFAULT NULL";
        $db->query($sql);
    }
}

/**
 * Display the configuration form.
 */
function exhibit_builder_config_form()
{
    include 'config_form.php';
}

/**
 * Process the configuration form.
 */
function exhibit_builder_config()
{
    set_option('exhibit_builder_sort_browse', $_POST['exhibit_builder_sort_browse']);
    set_option('exhibit_builder_researcher_permissions', $_POST['exhibit_builder_researcher_permissions']);
}

/**
 * Modify the ACL to include an 'ExhibitBuilder_Exhibits' resource.
 *
 * Requires the module name as part of the ACL resource in order to avoid naming
 * conflicts with pre-existing controllers, e.g. an ExhibitBuilder_ItemsController
 * would not rely on the existing Items ACL resource.
 *
 * @param array $args Zend_Acl in the 'acl' key
 */
function exhibit_builder_define_acl($args)
{
    $acl = $args['acl'];

    /*
     * NOTE: unless explicitly denied, super users and admins have access to all
     * of the defined resources and privileges.  Other user levels will not by default.
     * That means that admin and super users can both manipulate exhibits completely,
     * but researcher/contributor cannot.
     */
    $acl->addResource('ExhibitBuilder_Exhibits');
    $acl->addResource('ExhibitBuilder_Files');

    $acl->allow(null, 'ExhibitBuilder_Exhibits',
        array('show', 'summary', 'show-item', 'browse', 'tags'));

    // Allow contributors everything but editAll and deleteAll.
    $acl->allow('contributor', 'ExhibitBuilder_Exhibits', array(
        'add', 'delete-confirm', 'edit-page',
        'attachment', 'attachment-item-options',
        'editSelf', 'deleteSelf', 'showSelfNotPublic', 'add-pageSelf', 'theme-configSelf', 'block-form'));

    $acl->allow('contributor', 'ExhibitBuilder_Files', 'cover-image');

    $acl->allow(null, 'ExhibitBuilder_Exhibits', array('edit', 'delete', 'add-page', 'theme-config'),
        new Omeka_Acl_Assert_Ownership);

    if (get_option('exhibit_builder_researcher_permissions')==1) {
        $acl->allow('researcher', 'ExhibitBuilder_Exhibits', 'showNotPublic');
    }
}

/**
 * Add the routes from routes.ini in this plugin folder.
 *
 * @param array $args Router object in 'router' key
 */
function exhibit_builder_define_routes($args)
{
    $router = $args['router'];
    $router->addConfig(new Zend_Config_Ini(EXHIBIT_PLUGIN_DIR .
        DIRECTORY_SEPARATOR . 'routes.ini', 'routes'));
}

/**
 * Display the CSS layout for the exhibit in the public head
 */
function exhibit_builder_public_head($args)
{
    $request = Zend_Controller_Front::getInstance()->getRequest();
    $module = $request->getModuleName();

    if ($module == 'exhibit-builder') {
        queue_css_file('exhibits');
        queue_css_file('jcarousel.responsive');
        queue_js_file('jcarousel.responsive');
        queue_js_file('jquery.jcarousel.min');
        queue_js_file('jquery.jcarousel-fade.min');
        $exhibitPage = get_current_record('exhibit_page', false);
        if ($exhibitPage) {
            $blocks = $exhibitPage->ExhibitPageBlocks;

            $layouts = array();
            foreach ($blocks as $block) {
                $layout = $block->getLayout();
                if (!array_key_exists($layout->id, $layouts)) {
                    $layouts[$layout->id] = true;
                    try {
                        queue_css_url($layout->getAssetUrl('layout.css'));
                    } catch (InvalidArgumentException $e) {
                        // no CSS for this layout
                    }
                }
            }
            fire_plugin_hook('exhibit_builder_page_head', array(
                'view' => $args['view'],
                'layouts' => $layouts)
            );
        }
    }
}

/**
 * Display the CSS style and javascript for the exhibit in the admin head
 */
function exhibit_builder_admin_head()
{
    $request = Zend_Controller_Front::getInstance()->getRequest();
    $module = $request->getModuleName();
    $controller = $request->getControllerName();

    // Check if using Exhibits controller, and add the stylesheet for general display of exhibits
    if ($module == 'exhibit-builder' && $controller == 'exhibits') {
        queue_css_file('exhibits', 'screen');
        queue_js_file(array('vendor/tinymce/tinymce.min', 'exhibits'));
    }
}

/**
 * Append an Exhibits section to admin dashboard
 *
 * @param array $stats Array of "statistics" displayed on dashboard
 * @return array
 */
function exhibit_builder_dashboard_stats($stats)
{
    if (is_allowed('ExhibitBuilder_Exhibits', 'browse')) {
        if (version_compare(OMEKA_VERSION, '3.1', 'ge')) {
            $stats['exhibits'] = array(total_records('Exhibits'), __('exhibits'));
        } else {
            $stats[] = array(link_to('exhibits', array(), total_records('Exhibits')), __('exhibits'));
        }
    }
    return $stats;
}

/**
 * Adds the Browse Exhibits link to the public main navigation
 *
 * @param array $navArray The array of navigation links
 * @return array
 */
function exhibit_builder_public_main_nav($navArray)
{
    $navArray[] = array(
        'label' => __('Browse Exhibits'),
        'uri' => url('exhibits'),
        'visible' => true
    );
    return $navArray;
}

/**
 * Adds the Exhibits link to the admin navigation
 *
 * @param array $navArray The array of admin navigation links
 * @return array
 */
function exhibit_builder_admin_nav($navArray)
{
    $navArray[] = array(
        'label' => __('Exhibits'),
        'uri' => url('exhibits'),
        'resource' => 'ExhibitBuilder_Exhibits',
        'privilege' => 'browse'
    );
    return $navArray;
}

/**
 * Intercept get_theme_option calls to allow theme settings on a per-Exhibit basis.
 *
 * @param string $themeOptions Serialized array of theme options
 * @param string $args Unused here
 */
function exhibit_builder_theme_options($themeOptions, $args)
{
    try {
        $exhibit = get_current_record('exhibit', false);
        if ($exhibit) {
            $exhibitThemeOptions = $exhibit->getThemeOptions();
            if (!empty($exhibitThemeOptions)) {
                return serialize($exhibitThemeOptions);
            }
        }
    } catch (Zend_Exception $e) {
        // no view available
    }
    return $themeOptions;
}

/**
 * Filter for changing the public theme between exhibits.
 *
 * @param string $themeName "Normal" current theme.
 * @return string Theme that will actually be used.
 */
function exhibit_builder_public_theme_name($themeName)
{
    static $exhibitTheme;

    if ($exhibitTheme) {
        return $exhibitTheme;
    }

    $request = Zend_Controller_Front::getInstance()->getRequest();

    if ($request && $request->getModuleName() == 'exhibit-builder') {
        $slug = $request->getParam('slug');
        $exhibit = get_db()->getTable('Exhibit')->findBySlug($slug);
        if ($exhibit && $exhibit->theme) {
            // Save result in static for future calls
            $exhibitTheme = $exhibit->theme;
            add_filter('theme_options', 'exhibit_builder_theme_options');
            return $exhibitTheme;
        }
    }

    // Short-circuit any future calls to the hook if we didn't change the theme
    $exhibitTheme = $themeName;
    return $exhibitTheme;
}

/**
 * Custom hook from the HtmlPurifier plugin that will only fire when that plugin is
 * enabled.
 *
 * @param $args: 'purifier' => HTMLPurifier The purifier object.
 */
function exhibit_builder_purify_html($args)
{
    $request = Zend_Controller_Front::getInstance()->getRequest();
    $purifier = $args['purifier'];
    // Make sure that we only bother with the Exhibits controller in the ExhibitBuilder module.
    if ($request->getControllerName() != 'exhibits' or $request->getModuleName() != 'exhibit-builder') {
        return;
    }

    $post = $request->getPost();

    switch ($request->getActionName()) {
        // exhibit-metadata-form
        case 'add':
        case 'edit':
            if (!empty($post['description'])) {
                $post['description'] = $purifier->purify($post['description']);
            }
            break;
        case 'add-page':
        case 'edit-page':
            // page-content-form
            if (!empty($post['blocks'])) {
                foreach ($post['blocks'] as &$blockData) {
                    if (!empty($blockData['text'])) {
                        $blockData['text'] = $purifier->purify($blockData['text']);
                    }
                    if (!empty($blockData['attachments'])) {
                        foreach ($blockData['attachments'] as &$attachmentData) {
                            if (!empty($attachmentData['caption'])) {
                                $attachmentData['caption'] = $purifier->purify($attachmentData['caption']);
                            }
                        }
                    }
                }
            }
            break;
        default:
            // Don't process anything by default.
            break;
    }

    $request->setPost($post);
}

/**
 * Hooks into item_browse_sql to return items in a particular exhibit. The
 * passed exhibit can either be an Exhibit object or a specific exhibit ID.
 *
 * @return Omeka_Db_Select
 */
function exhibit_builder_items_browse_sql($args)
{
    $select = $args['select'];
    $params = $args['params'];
    $db = get_db();

    $exhibit = isset($params['exhibit']) ? $params['exhibit'] : null;

    if ($exhibit) {
        $select
            ->joinInner(
                array('eba' => $db->ExhibitBlockAttachment),
                'eba.item_id = items.id',
                array()
            )
            ->joinInner(
                array('epb' => $db->ExhibitPageBlock),
                'epb.id = eba.block_id',
                array()
            )
            ->joinInner(
                array('ep' => $db->ExhibitPage),
                'ep.id = epb.page_id',
                array()
            )
            ->joinInner(
                array('e' => $db->Exhibit),
                'e.id = ep.exhibit_id',
                array()
            );

        if ($exhibit instanceof Exhibit) {
            $select->where('e.id = ?', $exhibit->id);
        } elseif (is_numeric($exhibit)) {
            $select->where('e.id = ?', $exhibit);
        }
    }

    return $select;
}

/**
 * Form element for advanced search.
 *
 * @internal Themed partial should go to "my_theme/exhibits".
 */
function exhibit_builder_items_search($args)
{
    $view = $args['view'];
    echo $view->partial('exhibits/exhibit-builder-advanced-search.php');
}

function exhibit_builder_search_record_types($recordTypes)
{
    $recordTypes['Exhibit'] = __('Exhibit');
    $recordTypes['ExhibitPage'] = __('Exhibit Page');
    return $recordTypes;
}

/**
 * Add exhibit title to item search filters.
 */
function exhibit_builder_item_search_filters($displayArray, $args)
{
    $request = $args['request_array'];

    if (isset($request['exhibit'])
        && ($exhibit = get_record_by_id('Exhibit', $request['exhibit']))
    ) {
        $displayArray['exhibit'] =
            metadata($exhibit, 'title', array('no_escape' => true));
    }
    return $displayArray;
}

function exhibit_builder_api_resources($apiResources)
{
    $apiResources['exhibits'] = array(
        'record_type' => 'Exhibit',
        'actions' => array('get', 'index'),
        'index_params' => array('tag', 'tags', 'sort', 'public', 'featured')
    );
    $apiResources['exhibit_pages'] = array(
        'record_type' => 'ExhibitPage',
        'actions' => array('get', 'index'),
        'index_params' => array('parent', 'exhibit', 'order', 'topOnly', 'item')
    );


    return $apiResources;
}

function exhibit_builder_api_extend_items($extend, $args)
{
    $item = $args['record'];
    $pages = get_db()->getTable('ExhibitPage')->findBy(array('item' => $item->id));

    if(count($pages) == 1) {
        $page = $pages[0];
        $extend['exhibit_pages'] = array(
            'id' => $page->id,
            'url' => Omeka_Record_Api_AbstractRecordAdapter::getResourceUrl("/exhibit_pages/{$page->id}"),
            'resource' => 'exhibit_pages'
        );
    } else {
        $extend['exhibit_pages'] = array(
            'count' => count($pages),
            'url' => Omeka_Record_Api_AbstractRecordAdapter::getResourceUrl("/exhibit_pages?item={$item->id}"),
            'resource' => 'exhibit_pages'
        );
    }
    return $extend;
}

function exhibit_builder_api_import_omeka_adapters($adapters, $args)
{
        $exhibitsAdapter = new ApiImport_ResponseAdapter_Omeka_GenericAdapter(null, $args['endpointUri'], 'Exhibit');
        $exhibitsAdapter->setService($args['omeka_service']);
        $exhibitsAdapter->setUserProperties(array('owner'));
        $exhibitsAdapter->addSkipProperty('added');
        $exhibitsAdapter->addSkipProperty('modified');
        $adapters['exhibits'] = $exhibitsAdapter;
        $adapters['exhibit_pages'] = 'ExhibitBuilder_ApiImport_ExhibitPageAdapter';
        return $adapters;
}

function exhibit_builder_display_records_types($recordTypes)
{
    $recordTypes['Exhibit'] = array('partial' => 'exhibit-builder/exhibits/single.php', 'alias' => 'exhibit');
    return $recordTypes;
}

function exhibit_builder_exports_records_csv_get_field_data($fieldData, $args)
{
    $k = $args['k'];
    $v = $args['v'];
    $export = $args['export'];
    $exportData = $export->getData();

    // Add page block texts to a page_blocks CSV.
    if ('exhibit_pages' === $exportData['record'] && 'page_blocks' === $k) {
        $pageBlockTexts = [];
        foreach ($v as $pageBlock) {
            if (isset($pageBlock['text'])) {
                $pageBlockTexts[] = $pageBlock['text'];
            }
        }
        $fieldData = [['Text', implode($exportData['multivalue_separator'], $pageBlockTexts)]];
        return $fieldData;
    }

    return $fieldData;
}

/**
 * StaticSiteExport plugin: Add "Browse exhibits" link to static site menu.
 */
function exhibit_builder_static_site_export_site_config($args)
{
    $args['site_config']['menus']['main'][] = [
        'name' => __('Browse exhibits'),
        'pageRef' => '/exhibits',
        'weight' => 40,
    ];
    // Register exhibit menus.
    $exhibits = get_db()->getTable('Exhibit')->findAll();
    foreach ($exhibits as $exhibit) {
        $menu = sprintf('exhibit_%s', $exhibit->id);
        $args['site_config']['menus'][$menu] = [];
    }
}

/**
 * StaticSiteExport plugin: Add vendor packages to static site.
 */
function exhibit_builder_static_site_export_vendor_packages($vendorPackages, $args)
{
    $vendorPackages['jcarousel'] = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/jcarousel', PLUGIN_DIR);
    return $vendorPackages;
}

/**
 * StaticSiteExport plugin: Add shortcodes to static site.
 */
function exhibit_builder_static_site_export_shortcodes($shortcodes, $args)
{
    $shortcodes['omeka-exhibit-builder-page-block-file-text'] = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/shortcodes/omeka-exhibit-builder-page-block-file-text.html', PLUGIN_DIR);
    $shortcodes['omeka-exhibit-builder-page-block-gallery'] = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/shortcodes/omeka-exhibit-builder-page-block-gallery.html', PLUGIN_DIR);
    $shortcodes['omeka-exhibit-builder-page-block-text'] = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/shortcodes/omeka-exhibit-builder-page-block-text.html', PLUGIN_DIR);
    $shortcodes['omeka-exhibit-builder-page-block-carousel'] = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/shortcodes/omeka-exhibit-builder-page-block-carousel.html', PLUGIN_DIR);
    $shortcodes['omeka-exhibit-builder-single-exhibit'] = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/shortcodes/omeka-exhibit-builder-single-exhibit.html', PLUGIN_DIR);
    return $shortcodes;
}

function exhibit_builder_static_site_export_omeka_shortcode_callbacks($callbacks)
{
    // @see exhibit_builder_exhibits_shortcode()
    $callbacks['exhibits'] = function ($args, $frontMatter, $job) {
        $params = [];
        if (isset($args['is_featured'])) {
            $params['featured'] = $args['is_featured'];
        }
        if (isset($args['sort'])) {
            $params['sort_field'] = $args['sort'];
        }
        if (isset($args['order'])) {
            $params['sort_dir'] = $args['order'];
        }
        if (isset($args['ids'])) {
            $params['range'] = $args['ids'];
        }
        if (isset($args['tags'])) {
            $params['tags'] = $args['tags'];
        }
        if (isset($args['num'])) {
            $limit = $args['num'];
        } else {
            $limit = 10;
        }
        $content = [];
        $exhibits = get_records('Exhibit', $params, $limit);
        foreach ($exhibits as $exhibit) {
            $content[] = sprintf('{{< omeka-exhibit-builder-single-exhibit exhibitPage="exhibits/%s" >}}', $exhibit->slug);
        }
        return implode("\n", $content);
    };

    // @see exhibit_builder_featured_exhibits_shortcode()
    $callbacks['featured_exhibits'] = function ($args, $frontMatter, $job) use ($callbacks) {
        $args['is_featured'] = 1;
        if (!isset($args['num'])) {
            $args['num'] = 1;
        }
        $args['sort'] = 'random';
        return $callbacks['exhibits']($args, $frontMatter, $job);
    };

    return $callbacks;
}

/**
 * StaticSiteExport plugin: Add markdown for exhibit builder block layouts.
 */
function exhibit_builder_static_site_export_exhibit_page_block($args)
{
    $job = $args['job'];
    $frontMatterExhibitPage = $args['frontMatterExhibitPage'];
    $frontMatterExhibitPageBlock = $args['frontMatterExhibitPageBlock'];
    $block = $args['block'];
    $markdown = $args['markdown'];
    $attachments = $block->getAttachments();

    // Set block attachments data to block front matter.
    $setAttachmentsToFrontMatter = function ($thumbnailType) use ($job, $block, $frontMatterExhibitPageBlock) {
        foreach ($block->getAttachments() as $attachment) {
            $item = $attachment->getItem();
            $file = $attachment->getFile();
            $frontMatterExhibitPageBlock['params']['attachments'][] = [
                'itemID' => $item ? $item->id : null,
                'itemTitle' => $item ? metadata($item, 'display_title') : null,
                'fileID' => $file ? $file->id : null,
                'fileMimeType' => $file ? explode('/', $file->mime_type)[0] : null,
                'fileName' => $file ? $file->original_filename : null,
                'thumbnailSpec' => $file ? $job->getThumbnailSpec($file, $thumbnailType) : null,
                'caption' => $attachment->caption,
            ];
        }
    };

    switch ($block->layout) {
        // Build the "file" and "file-text" block markdown.
        case 'file':
        case 'file-text':
            $options = $block->getOptions();
            $thumbnailType = isset($options['file-size']) ? $options['file-size'] : 'fullsize';
            $thumbnailTypeClassMap = [
                'fullsize' => 'full',
                'thumbnail' => 'thumb',
                'square_thumbnail' => 'thumb',
            ];
            $frontMatterExhibitPageBlock['params']['options'] = [
                'fileSize' => $thumbnailType,
                'filePosition' => isset($options['file-position']) ? $options['file-position'] : 'left',
                'captionsPosition' => isset($options['captions-position']) ? $options['captions-position'] : 'center',
                'imgClass' => $thumbnailTypeClassMap[$thumbnailType],
            ];
            $setAttachmentsToFrontMatter($thumbnailType);
            $markdown[] = sprintf('{{< omeka-exhibit-builder-page-block-file-text >}}');
            break;
        // Build the "gallery" block markdown.
        case 'gallery':
            $options = $block->getOptions();
            $showcasePosition = isset($options['showcase-position']) ? $options['showcase-position'] : 'none';
            $galleryFileSize = isset($options['gallery-file-size']) ? $options['gallery-file-size'] : 'square_thumbnail';
            $frontMatterExhibitPageBlock['params']['options'] = [
                'showcasePosition' => $showcasePosition,
                'showcaseFile' => ($showcasePosition !== 'none' && !empty($attachments)),
                'galleryPosition' => isset($options['gallery-position']) ? $options['gallery-position'] : 'left',
                'galleryFileSize' => $galleryFileSize,
                'captionsPosition' => isset($options['captions-position']) ? $options['captions-position'] : 'center',
            ];
            $setAttachmentsToFrontMatter($galleryFileSize);
            $markdown[] = sprintf('{{< omeka-exhibit-builder-page-block-gallery >}}');
            break;
        // Build the "text" block markdown.
        case 'text':
            $markdown[] = sprintf('{{< omeka-exhibit-builder-page-block-text >}}');
            break;
        // Build the "carousel" block markdown.
        case 'carousel':
            $frontMatterExhibitPage['css'][] = 'vendor/jcarousel/jcarousel.responsive.css';
            $frontMatterExhibitPage['js'][] = 'vendor/jquery/jquery.js';
            $frontMatterExhibitPage['js'][] = 'vendor/jquery/jquery-ui.js';
            $frontMatterExhibitPage['js'][] = 'vendor/jcarousel/jquery.jcarousel.min.js';
            $frontMatterExhibitPage['js'][] = 'vendor/jcarousel/jcarousel.responsive.js';
            $frontMatterExhibitPage['js'][] = 'vendor/jcarousel/jquery.jcarousel-fade.min.js';

            $options = $block->getOptions();
            $fileSize = isset($options['file-size']) ? $options['file-size'] : 'thumbnail';
            $fade = isset($options['fade']) ? $options['fade'] : 0;
            $scrollingSpeed = isset($options['speed']) ? $options['speed'] : 400;
            $autoSlide = isset($options['auto-slide']) ? (int) $options['auto-slide'] : 0;
            $autoscroll = [];
            if ($autoSlide > 0) {
                $autoscroll['interval'] = $autoSlide;
                if ($fade) {
                    $autoscroll['method'] = 'fade';
                }
            }
            $frontMatterExhibitPageBlock['params']['options'] = [
                'carousel' => [
                    'animation' => is_numeric($scrollingSpeed) ? (int) $scrollingSpeed : (($fade == true) ? 400 : $scrollingSpeed),
                    'wrap' => $loop ? 'circular' : null,
                    'transitions' => 1,
                ],
                'fileSize' => $fileSize,
                'showTitle' => isset($options['show-title']) ? $options['show-title'] : 0,
                'fade' => $fade,
                'overlay' => (isset($options['float-caption']) && ($options['float-caption'] == 1)) ? 'text-overlay' : 'text-float',
                'perSlide' => isset($options['per-slide']) ? $options['per-slide'] : 1,
                'stretchImage' => isset($options['stretch-image']) ? $options['stretch-image'] : 'none',
                'captionPosition' => isset($options['caption-position']) ? $options['caption-position'] : 'center',
                'scrollingSpeed' => $scrollingSpeed,
                'autoSlide' => $autoSlide,
                'loop' => isset($options['loop']) ? $options['loop'] : 0,
                'carouselTitle' => isset($options['carousel-title']) ? $options['carousel-title'] : '',
                'autoscroll' => $autoscroll,
            ];
            $setAttachmentsToFrontMatter($fileSize);
            $markdown[] = sprintf('{{< omeka-exhibit-builder-page-block-carousel >}}');
            break;
        default:
            break;
    }
}

/**
 * StaticSiteExport plugin: Add exhibit builder content to static site.
 */
function exhibit_builder_static_site_export_site_export_post($args)
{
    $job = $args['job'];

    // Add exhibit layouts.
    $job->makeDirectory('layouts/exhibits');
    $job->makeDirectory('layouts/exhibit-pages');
    $fromPath = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/exhibits.html', PLUGIN_DIR);
    $job->makeFile('layouts/exhibits/list.html', file_get_contents($fromPath));
    $fromPath = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/exhibit-pages.html', PLUGIN_DIR);
    $job->makeFile('layouts/exhibit-pages/list.html', file_get_contents($fromPath));
    $fromPath = sprintf('%s/ExhibitBuilder/libraries/ExhibitBuilder/StaticSiteExport/exhibit-page.html', PLUGIN_DIR);
    $job->makeFile('layouts/exhibit-pages/single.html', file_get_contents($fromPath));

    // Create the exhibits section.
    $frontMatter = [
        'title' => __('Browse exhibits'),
        'type' => 'exhibits',
        'params' => [
            'bodyClasses' => [
                'exhibits browse',
            ],
        ],
    ];
    $job->makeDirectory('content/exhibits');
    $job->makeFile('content/exhibits/_index.md', json_encode($frontMatter, JSON_PRETTY_PRINT | JSON_FORCE_OBJECT));

    $includePrivate = $job->getStaticSite()->getDataValue('include_private');

    $page = 1;
    do {
        $exhibits = get_db()->getTable('Exhibit')->findBy([], 100, $page++);
        foreach ($exhibits as $exhibit) {
            // Create the exhibit pages section.
            $frontMatterExhibit = new ArrayObject([
                'date' => (new DateTime(metadata($exhibit, 'added')))->format('c'),
                'title' => $exhibit->title,
                'draft' => $exhibit->public ? false : !$includePrivate,
                'type' => 'exhibit-pages',
                'params' => [
                    'exhibitID' => $exhibit->id,
                    'description' => $exhibit->description,
                    'credits' => $exhibit->credits,
                    'thumbnailSpec' => $job->getThumbnailSpec($exhibit, 'square_thumbnail'),
                    'bodyClasses' => [
                        'exhibits show summary',
                    ],
                ],
            ]);
            $job->makeDirectory(sprintf('content/exhibits/%s', $exhibit->slug));
            $job->makeFile(
                sprintf('content/exhibits/%s/_index.md', $exhibit->slug),
                json_encode($frontMatterExhibit, JSON_PRETTY_PRINT)
            );
            foreach ($exhibit->getPages() as $exhibitPage) {
                // Create the exhibit page bundle.
                $frontMatterExhibitPage = new ArrayObject([
                    'date' => (new DateTime(metadata($exhibitPage, 'added')))->format('c'),
                    'title' => $exhibitPage->title,
                    'draft' => $exhibit->public ? false : !$includePrivate,
                    'weight' => $exhibitPage->order + 10,
                    'type' => 'exhibit-pages',
                    'css' => [],
                    'js' => [],
                    'params' => [
                        'exhibitID' => $exhibit->id,
                        'exhibitPageID' => $exhibitPage->id,
                        'thumbnailSpec' => $job->getThumbnailSpec($exhibit, 'square_thumbnail'),
                        'bodyClasses' => [
                            'exhibits show',
                        ],
                    ],
                    // Set exhibit menu entry representing this page.
                    'menus' => [
                        sprintf('exhibit_%s', $exhibit->id) => [
                            'identifier' => sprintf('exhibit_page_%s', $exhibitPage->id),
                            'parent' => $exhibitPage->parent_id ? sprintf('exhibit_page_%s', $exhibitPage->parent_id) : null,
                        ],
                    ],
                ]);
                $job->makeDirectory(sprintf('content/exhibits/%s/%s', $exhibit->slug, $exhibitPage->slug));
                $job->makeDirectory(sprintf('content/exhibits/%s/%s/blocks', $exhibit->slug, $exhibitPage->slug));
                foreach ($exhibitPage->getPageBlocks() as $exhibitPageBlock) {
                    // Create the exhibit page blocks.
                    $frontMatterExhibitPageBlock = new ArrayObject([
                        'params' => [
                            'layout' => $exhibitPageBlock->layout,
                            'text' => $exhibitPageBlock->text,
                            'attachments' => [],
                        ],
                    ]);
                    $markdown = new ArrayObject;
                    $job->fireHook('exhibit_builder_static_site_export_exhibit_page_block', [
                        'frontMatterExhibitPage' => $frontMatterExhibitPage,
                        'frontMatterExhibitPageBlock' => $frontMatterExhibitPageBlock,
                        'block' => $exhibitPageBlock,
                        'markdown' => $markdown,
                    ]);
                    $blockNumber = str_pad($exhibitPageBlock->order++, 4, '0', STR_PAD_LEFT);
                    $job->makeFile(
                        sprintf('content/exhibits/%s/%s/blocks/%s-%s.md', $exhibit->slug, $exhibitPage->slug, $blockNumber, $exhibitPageBlock->layout),
                        sprintf("%s\n%s", json_encode($frontMatterExhibitPageBlock, JSON_PRETTY_PRINT), implode("\n", $markdown->getArrayCopy()))
                    );
                }
                $job->makeFile(
                    sprintf('content/exhibits/%s/%s/index.md', $exhibit->slug, $exhibitPage->slug),
                    json_encode($frontMatterExhibitPage, JSON_PRETTY_PRINT)
                );
            }
        }
    } while ($exhibits);
}

/**
 * Get all available page templates.
 *
 * Keys are template names, values are the labels shown in the admin. A
 * template name must match the name of the partial that provides it: the
 * template "foo" is rendered from common/page-template/foo.php.
 *
 * @param Exhibit $exhibit
 * @return array
 */
function exhibit_builder_get_page_templates(Exhibit $exhibit)
{
    $themeConfig = exhibit_builder_get_theme_config($exhibit);
    $themeTemplates = $themeConfig['exhibit_builder_templates']['page_templates'] ?? [];
    $pluginTemplates = apply_filters('exhibit_builder_page_templates', []);
    return array_merge($themeTemplates, $pluginTemplates);
}

/**
 * Get all available summary page templates.
 *
 * Keys are template names, values are the labels shown in the admin. A
 * template name must match the name of the partial that provides it: the
 * template "foo" is rendered from common/summary-template/foo.php.
 *
 * @param Exhibit $exhibit
 * @return array
 */
function exhibit_builder_get_summary_templates(Exhibit $exhibit)
{
    $themeConfig = exhibit_builder_get_theme_config($exhibit);
    $themeTemplates = $themeConfig['exhibit_builder_templates']['summary_templates'] ?? [];
    $pluginTemplates = apply_filters('exhibit_builder_summary_templates', []);
    return array_merge($themeTemplates, $pluginTemplates);
}

/**
 * Get all available block templates.
 *
 * Keys are template names, values are the labels shown in the admin. A
 * template name must match the name of the partial that provides it: the
 * template "foo" on the "bar" layout is rendered from
 * common/block-template/bar/foo.php.
 *
 * @param Exhibit $exhibit
 * @param string $layout
 * @return array
 */
function exhibit_builder_get_block_templates(Exhibit $exhibit, $layout)
{
    $themeConfig = exhibit_builder_get_theme_config($exhibit);
    $themeTemplates = $themeConfig['exhibit_builder_templates']['block_templates'][$layout] ?? [];
    $pluginTemplates = apply_filters('exhibit_builder_block_templates', [], ['layout' => $layout]);
    return array_merge($themeTemplates, $pluginTemplates);
}

/**
 * Get the theme configuration.
 *
 * @todo Is there a way to get theme configuration via the core?
 * @param Exhibit $exhibit
 * @return array
 */
function exhibit_builder_get_theme_config(Exhibit $exhibit)
{
    $themeName = $exhibit->theme ? $exhibit->theme : Theme::getCurrentThemeName('public');
    $configPath = sprintf('%s/%s/config.ini', PUBLIC_THEME_DIR, $themeName);
    if (file_exists($configPath) && is_readable($configPath)) {
        return (new Zend_Config_Ini($configPath))->toArray();
    }
    return [];
}