grima-lib.php

Go to the documentation of this file.

<?php

require_once "grima-util.php";

require_once "grima-xmlbag.php";

require_once "grima-splats.php";

require_once "MARC21.php";

 

if (!defined('sodium_crypto_secretbox')) {

        @include_once "vendor/paragonie/sodium_compat/autoload.php";

}

 

 

// {{{ class Grima


class Grima


{

    public $server;

    public $apikey;

 

    // {{{ session management


 

    function sessionInit($force = false)

    {

        // Session Module


        $session_module_name = getenvWithFileFallbackAndDefault(

            'SESSION_MODULE',

            'encrypted_cookie'


        );

        if ($session_module_name=="none") {

            return;

        } else if ($session_module_name=="encrypted_cookie") {

            $session_key = base64_decode(

                getenvWithFileFallbackAndDefault(

                    'SESSION_KEY', "base64EncodedGrimaKeyOf32BytesTotallyRandom="


                )

            );

            session_set_save_handler(new EncryptedCookieSession($session_key));

            ini_set("session.use_cookies", false);

        } else if ($session_module_name) {

            $new_name = session_module_name($session_module_name);

            if ($new_name != $session_module_name) {

                session_name("grima_failsafe");

                session_start();

                return;

            }

        }

        // Session Name


        $session_name = getenvWithFileFallbackAndDefault('SESSION_NAME', 'grima');

        session_name($session_name);

        // Session Path


        $session_path = getenvWithFileFallbackAndDefault(

            'SESSION_PATH', join_paths(sys_get_temp_dir(), 'grima')

        );

        if (session_module_name()==='files') {

            @mkdir($session_path, 0700, true);

        }

        session_save_path($session_path);

        // Session lifetime


        session_set_cookie_params(365*24*60*60);        // one year


        ini_set('session.gc_maxlifetime', 525600*60);   // of love


        // Start session


        session_start();

    }

 

    function sessionSave($result)

    {

        $session_module_name = getenvWithFileFallbackAndDefault(

            'SESSION_MODULE', 'encrypted_cookie'


        );

        if ($session_module_name === "none") {

            return;

        }

        $this->sessionInit(true);

        foreach ($result as $key => $value) {

            $_SESSION[$key] = $value;

        }

        session_write_close();

    }

 

    function sessionDestroy()

    {

        $session_module_name = getenvWithFileFallbackAndDefault(

            'SESSION_MODULE', 'encrypted_cookie'


        );

        if ($session_module_name === "none") {

            return;

        }

        $_SESSION = [];

        if (ini_get("session.use_cookies")) {

            $params = session_get_cookie_params();

            $params['expires'] = time() - 42000;

            unset($params['lifetime']);

            setcookie(session_name(), '', $params);

        }

        $this->sessionInit(true);

        $_SESSION = [];

        session_destroy();

    }

 

    // }}}


 

    // {{{ config


    function __construct()

    {

 

        $this->sessionInit();

 

        $this->apikey =

            isset($_REQUEST['apikey']) && $_REQUEST['apikey'] ? $_REQUEST['apikey'] : (

            isset($_SESSION['apikey']) && $_SESSION['apikey'] ? $_SESSION['apikey'] : (

            getenvWithFileFallbackAndDefault('apikey', '') ) );

 

        $this->server =

            isset($_REQUEST['server']) && $_REQUEST['server'] ? $_REQUEST['server'] : (

            isset($_SESSION['server']) && $_SESSION['server'] ? $_SESSION['server'] : (

            getenvWithFileFallbackAndDefault('server', '') ) );

 

        if (strlen($this->server)==2) {

            $this->server = "https://api-" . $this->server . ".hosted.exlibrisgroup.com";

        }

 

        if (!preg_match('!https://api-[a-z]*\.hosted\.exlibrisgroup\.com!', $this->server)) {

            $this->server = "";

        }

 

        if ($this->apikey=='EDITME') {

            $this->apikey = "";

        }

 

        if ($this->apikey && $this->server) {

            $_SESSION['apikey'] = $this->apikey;

            $_SESSION['server'] = $this->server;

        }

 

        session_write_close();

 

        return false;

    }

 

    // }}}


 

    // {{{ REST - get/post/put/delete


 

    // {{{ request - general function for API calls


    function request($method, $url, $URLparams, $QSparams, $body = null)

    {

        $headers = array(

            'Authorization: apikey ' . urlencode($this->apikey),

            "Accept: application/xml",

        );

 

        // Change "/almaws/v1/users/{user_id}" to "/almaws/v1/users/${URLparams['user_id']}"


        foreach ($URLparams as $k => $v) {

            if (!$v) {

                throw new Exception("URL parameter $k is empty in $method $url");

            }

            $url = str_replace('{'.$k.'}', urlencode($v), $url);

        }

 

        // Include APIKey in url


        $url = $this->server . $url . '?apikey=' . urlencode($this->apikey) . '&format=xml';

 

        // Include query string parameters too


        foreach ($QSparams as $k => $v) {

            $url .= "&$k=" . urlencode($v);

        }

 

        // Include XML based body as well


        // XXX: detect if JSON is more appropriate?


        if ($body) {

            $bodyxml = $body->saveXML();

            $headers[] = 'Content-Type: application/xml';

        }

 

        $ch = curl_init();

        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);

        curl_setopt($ch, CURLOPT_URL, $url);

        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);

 

        $headerCapture = new HeaderCapture();

        curl_setopt($ch, CURLOPT_HEADERFUNCTION, [&$headerCapture,"capture"]);

 

        // ExLibris / Debian interoperability problem


        // https://github.com/openssl/openssl/issues/7126


        // error_log("OPENSSL_VERSION_NUMBER=" .dechex(OPENSSL_VERSION_NUMBER));


        //                            0x01000214f on reclaim


        if (OPENSSL_VERSION_NUMBER >= 0x010101000) {

            // debian 10 workaround until Ex Libris patches their servers


            curl_setopt($ch, CURLOPT_SSL_CIPHER_LIST, "DEFAULT@SECLEVEL=1");

        }

 

 

        if (isset($bodyxml)) {

            curl_setopt($ch, CURLOPT_POSTFIELDS, $bodyxml);

        }

        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

 

        /* XXX: DEBUG */


        $today = date("Y-m-d-H_i_s");

        $debug = fopen("/tmp/grima/debug/curl-$today.log", 'a+');

        fwrite(

            $debug, serialize(

                [

                "REQUEST_URI"=>isset($_SERVER["REQUEST_METHOD"])?($_SERVER["REQUEST_METHOD"]." ".$_SERVER["SERVER_NAME"].$_SERVER["REQUEST_URI"]):"cli",

                "_REQUEST"=>$_REQUEST,

                "request_body"=>$body,

                ]

            )

            ."\n"


        );

 

        curl_setopt($ch, CURLOPT_VERBOSE, true);

        curl_setopt($ch, CURLOPT_STDERR, $debug);

        /* */


 

        $response = curl_exec($ch);

        // error_log( print_r($headerCapture,true) );


        /* */


        fwrite($debug, serialize(["response"=>$response])."\n\n");

        fclose($debug);

        /* */


 

        $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (curl_errno($ch)) {

            throw new Exception("Network error: " . curl_error($ch));

        }

        curl_close($ch);

        if ($code == 204) {

            return; // no body


        }

 

        $xml = new DOMDocument();

        $xml->formatOutput = true;

        try {

            if (preg_match(',^application/json,', $headerCapture->headers['content-type'])) {

                $array = json_decode($response, true);

                $xml->loadXML('<?xml version="1.0"?' . '><json/>');

                arrayToXml($array, $xml->documentElement);

            } else if (!preg_match('/^</', $response)) {

                $xml->loadXML(

                    '<?xml version="1.0"?' . '><html><body><h1>Not xml</h1><pre>'


                    . htmlspecialchars($response).

                    '</pre></body></html>'


                );

            } else {

                $xml->loadXML($response);

            }

        } catch (Exception $e) {

            throw new Exception("Malformed XML from Alma:\n$method $url -> $code\n$e");

        }

 

        $xml->rawText = $response;

        $xml->httpCode = $code;

        $xml->headers = $headerCapture->headers;

        $xml->rawHeaders = $headerCapture->rawHeaders;

 

        return $xml;

    }

    // }}}


 

    // {{{ get - general function for GET (retrieve) API calls


    function get($url, $URLparams, $QSparams)

    {

        return $this->request("GET", $url, $URLparams, $QSparams, null);

    }

    // }}}


 

    // {{{ post - general function for POST (create) API calls


    function post($url, $URLparams, $QSparams, $body)

    {

        return $this->request("POST", $url, $URLparams, $QSparams, $body);

    }

    // }}}


 

    // {{{ put - general function for PUT (update) API calls


    function put($url, $URLparams, $QSparams, $body)

    {

        return $this->request("PUT", $url, $URLparams, $QSparams, $body);

    }

    // }}}


 

    // {{{ delete - general function for DELETE API calls


    function delete($url, $URLparams, $QSparams)

    {

        return $this->request("DELETE", $url, $URLparams, $QSparams, null);

    }

    // }}}


 

    // {{{ checkForErrorMessage - checks for errorMessage tag, throws exceptions


    function checkForErrorMessage($xml)

    {

        if ($xml instanceOf DomDocument) {

            $xpath = new DomXpath($xml);

            $xpath->registerNamespace("err", "http://com/exlibris/urm/general/xmlbeans");

            $error = $xpath->query('//err:errorMessage');

            if ($error->length > 0) {

                throw new Exception("Alma says: " . $error[0]->nodeValue);

            }

        }

    }

    // }}}


 

    // }}}


 

    //{{{Bib APIs


    // {{{ getBib (Retrieve Bib)


    function getBib($mms_id, $view = 'full', $expand = 'None')

    {

        $ret = $this->get(

            '/almaws/v1/bibs/{mms_id}',

            array('mms_id' => $mms_id),

            array('view' => $view, 'expand' => $expand)

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ postBib (Create Record)


    function postBib($bib)

    {

        $ret = $this->post(

            '/almaws/v1/bibs',

            array(),

            array(),

            $bib

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ putBib (Update Bib Record)


    function putBib($mms_id, $bib)

    {

        $ret = $this->put(

            '/almaws/v1/bibs/{mms_id}',

            array('mms_id' => $mms_id),

            array(),

            $bib

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ deleteBib (Delete Bib Record)


    function deleteBib($mms_id, $override = 'false')

    {

        $ret = $this->delete(

            '/almaws/v1/bibs/{mms_id}',

            array('mms_id' => $mms_id),

            array('override' => $override)

        );

        $this->checkForErrorMessage($ret);

    }

    // }}}


 

    //}}}


 

    //{{{Holdings List APIs


    // {{{ grima -> getHoldingsList (Retrieve Holdings list)


    function getHoldingsList($mms_id)

    {

        $ret = $this->get(

            '/almaws/v1/bibs/{mms_id}/holdings',

            array('mms_id' => $mms_id),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    //}}}


 

    //{{{Holding APIs


    // {{{ getHolding (Retrieve Holdings Record)


    function getHolding($mms_id, $holding_id)

    {

        $ret = $this->get(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}',

            array(

            'mms_id' => $mms_id,

            'holding_id' => $holding_id

            ),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ grima -> postHolding (Create holding record)


    function postHolding($mms_id, $holding)

    {

        $ret = $this->post(

            '/almaws/v1/bibs/{mms_id}/holdings',

            array('mms_id' => $mms_id),

            array(),

            $holding

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ putHolding (Update Holdings Record)


    function putHolding($mms_id, $holding_id, $holding)

    {

        $ret = $this->put(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}',

            array('mms_id' => $mms_id, 'holding_id' => $holding_id),

            array(),

            $holding

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ grima -> deleteHolding (Delete Holdings Record)


    function deleteHolding($mms_id, $holding_id, $override = 'false')

    {

        $ret = $this->delete(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}',

            array(

                'mms_id' => $mms_id,

                'holding_id' => $holding_id

            ),

            array('override' => $override)

        );

        $this->checkForErrorMessage($ret);

    }

    // }}}


 

    //}}}


 

    //{{{Item List APIs


    // {{{ getItemList (Retrieve Items list)


    function getItemList($mms_id, $holding_id, $limit, $offset)

    {

        $ret = $this->get(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}/items', array('mms_id' => $mms_id, 'holding_id' => $holding_id),

            array('limit' => $limit, 'offset' => $offset)

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    //}}}


 

    //{{{Item APIs


    // {{{ getItem (Retrieve Item and print label information)


    function getItem($mms_id, $holding_id, $item_pid)

    {

        $ret = $this->get(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}/items/{item_pid}', array(

            'mms_id' => $mms_id,

            'holding_id' => $holding_id,

            'item_pid' => $item_pid

            ),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ getItemBC (Retrieve Item and print label information (by barcode))


    function getItemBC($barcode)

    {

        $ret = $this->get(

            '/almaws/v1/items',

            array(),

            array(

                'item_barcode' => $barcode,

            )

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ postItem (Create Item)


    function postItem($mms_id, $holding_id, $item)

    {

        $ret = $this->post(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}/items',

            array('mms_id' => $mms_id, 'holding_id' => $holding_id),

            array(),

            $item

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ putItem (Update Item information)


    function putItem($mms_id, $holding_id, $item_pid, $item)

    {

        $ret = $this->put(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}/items/{item_pid}',

            array('mms_id' => $mms_id, 'holding_id' => $holding_id, 'item_pid' => $item_pid),

            array(),

            $item

        );

        return $ret;

    }

    // }}}


 

    // {{{ deleteItem (Withdraw Item)


    function deleteItem($mms_id, $holding_id, $item_pid, $override = "false",

        $holdings = "retain"


    ) {

        $ret = $this->delete(

            '/almaws/v1/bibs/{mms_id}/holdings/{holding_id}/items/{item_pid}', array(

                'mms_id' => $mms_id,

                'holding_id' => $holding_id,

                'item_pid' => $item_pid

            ), array(

                'override' => $override,

                'holdings' => $holdings

            )

        );

        $this->checkForErrorMessage($ret);

    }

    // }}}


 

    //}}}


 

    //{{{Electronic APIs


    // {{{ getElectronicPortfolio (Retrieve Portfolio)


    function getElectronicPortfolio($collection_id, $service_id, $portfolio_id)

    {

        $ret = $this->get(

            '/almaws/v1/electronic/e-collections/{collection_id}/e-services/{service_id}/portfolios/{portfolio_id}',

            array('collection_id' => $collection_id, 'service_id' => $service_id, 'portfolio_id' => $portfolio_id),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ getElectronicPortfolioFromBib (Retrieve Portfolio)


    function getElectronicPortfolioFromBib($mms_id, $portfolio_id)

    {

        $ret = $this->get(

            '/almaws/v1/bibs/{mms_id}/portfolios/{portfolio_id}',

            array('mms_id' => $mms_id, 'portfolio_id' => $portfolio_id),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ postElectronicPortfolio (Create Electronic Portfolio) #XXX


    function postElectronicPortfolio($collection_id, $service_id, $portfolio)

    {

        $ret = $this->post(

            '/almaws/v1/electronic/e-collections/{collection_id}/e-services/{service_id}/portfolios',

            array('collection_id' => $collection_id, 'service_id' => $service_id),

            array(),

            $portfolio

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ postElectronicPortfolioOnBib (Create Electronic Portfolio on Bib)


    function postElectronicPortfolioOnBib($mms_id, $portfolio, $update = true)

    {

        $ret = $this->post(

            '/almaws/v1/bibs/{mms_id}/portfolios/',

            array('mms_id' => $mms_id),

            array(),

            $portfolio

        );

        $this->checkForErrorMessage($ret);

        if ($update) {

            $portfolio->loadXML($ret->saveXML());

        }

        return $ret;

    }

    // }}}


 

    // {{{ putElectronicPortfolioOnBib (Update Portfolio for a Bib)


    function putElectronicPortfolioOnBib($mms_id, $portfolio_id, $portfolio)

    {

        $ret = $this->put(

            '/almaws/v1/bibs/{mms_id}/portfolios/{portfolio_id}',

            array('mms_id' => $mms_id, 'portfolio_id' => $portfolio_id),

            array(),

            $portfolio

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ deleteElectronicPortfolio (Delete Electronic Portfolio)


    function deleteElectronicPortfolio($collection_id, $service_id, $portfolio_id)

    {

        $ret = $this->delete(

            '/almaws/v1/electronic/e-collections/{collection_id}/e-services/{service_id}/portfolios/{portfolio_id}',

            array('collection_id' => $collection_id, 'service_id' => $service_id, 'portfolio_id' => $portfolio_id),

            array()

        );

        $this->checkForErrorMessage($ret);

    }

    // }}}


 

    // {{{ getElectronicPortfoliosForService (Retrieve Portfolios)


    function getElectronicPortfoliosForService($collection_id, $service_id, $limit, $offset)

    {

        $ret = $this->get(

            '/almaws/v1/electronic/e-collections/{collection_id}/e-services/{service_id}/portfolios',

            array('collection_id' => $collection_id, 'service_id' => $service_id),

            array('limit' => $limit, $offset = $offset)

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ grima -> getElectronicPortfoliosForBib (Retrieve Portfolios)


    function getElectronicPortfoliosForBib($mms_id, $limit, $offset)

    {

        $ret = $this->get(

            '/almaws/v1/bibs/{mms_id}/portfolios',

            array('mms_id' => $mms_id),

            array('limit' => $limit, $offset = $offset)

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ getElectronicCollection (Retrieve Electronic Collection)


    function getElectronicCollection($collection_id)

    {

        $ret = $this->get(

            '/almaws/v1/electronic/e-collections/{collection_id}',

            array('collection_id' => $collection_id),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ putElectronicCollection (Update Electronic Collection)


    function putElectronicCollection($collection_id, $collection)

    {

        $ret = $this->put(

            '/almaws/v1/electronic/e-collections/{collection_id}',

            array('collection_id' => $collection_id),

            array(),

            $collection

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ getElectronicServices (Retrieve Electronic Services)


    function getElectronicServices($collection_id)

    {

        $ret = $this->get(

            '/almaws/v1/electronic/e-collections/{collection_id}/e-services',

            array('collection_id' => $collection_id),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    //}}}


 

    //{{{Library APIs


    // {{{ grima -> getLibrary (Retrieve a Library)


    function getLibrary($libraryCode)

    {

        $ret = $this->get(

            '/almaws/v1/conf/libraries/{libraryCode}',

            array('libraryCode' => $libraryCode),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ grima -> getAllLibraries (Retrieve Libraries)


    function getAllLibraries()

    {

        $ret = $this->get(

            '/almaws/v1/conf/libraries',

            array(),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ getAllLocations (Retrieve Locations)


    function getAllLocations($libraryCode)

    {

        $ret = $this->get(

            '/almaws/v1/conf/libraries/{libraryCode}/locations',

            array('libraryCode' => $libraryCode),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    //}}}


 

    //{{{Location APIs


    // {{{ getLocation (Retrieve Location)


    function getLocation($libraryCode, $locationCode)

    {

        $ret = $this->get(

            '/almaws/v1/conf/libraries/{libraryCode}/locations/{locationCode}',

            array(

                'libraryCode' => $libraryCode,

                'locationCode' => $locationCode,

            ),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    //}}}


 

    //{{{Set APIs


    // {{{ grima -> getSet (Retrieve a Set)


    function getSet($set_id)

    {

        $ret = $this->get(

            '/almaws/v1/conf/sets/{set_id}',

            array('set_id' => $set_id),

            array()

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ grima -> postSet (Create a Set)


    function postSet($set)

    {

        $ret = $this->post(

            '/almaws/v1/conf/sets/',

            array(),

            array(),

            $set

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    // {{{ grima -> postSetManageMembers (Manage Members)


    function postSetManageMembers($set_id, $id_type, $op, $set)

    {

        $ret = $this->post(

            '/almaws/v1/conf/sets/{set_id}',

            array('set_id' => $set_id),

            array('id_type' => $id_type, 'op' => $op),

            $set

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

 

    // {{{ Set -> createSetFromImport (Create a Set)


    function createSetFromImport($job_instance_id, $population)

    {

        // create blank set


 

        $body = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?' . '>


<set>


  <name>Grima set from ' . $job_instance_id . '</name>


  <description>members of ' . $job_instance_id . '</description>


  <type desc="Itemized">ITEMIZED</type>


  <content desc="All Titles">BIB_MMS</content>


  <private desc="No">false</private>


</set>';

 

        /*


        Content:


        BIB_MMS -- all titles


        ITEM


        PORTFOLIO


        IEPA


        FILE


        AUTHORITY_MMS


        IEP


        IEE


        IED


        IEC


        */


 

        /*


        Population:


        */


 

        $bodyxml = new DomDocument();

        $bodyxml->loadXML($body);

 

        $ret = $this->post('/almaws/v1/conf/sets', array(), array('job_instance_id' => $job_instance_id, 'population' => $population), $bodyxml);

        $this->checkForErrorMessage($ret);

        return $ret;

 

    }

    // }}}


 

    // {{{ grima -> deleteSet (Delete a Set)


    function deleteSet($set_id)

    {

        $ret = $this->delete(

            '/almaws/v1/conf/sets/{set_id}',

            array(

                'set_id' => $set_id,

            ),

            array()

        );

        $this->checkForErrorMessage($ret);

    }

    // }}}


 

    // {{{ grima -> getSetMembers (Does it work????)


    function getSetMembers($set_id, $limit = 10, $offset = 0)

    {

        $ret = $this->get(

            '/almaws/v1/conf/sets/{set_id}/members',

            array('set_id' => $set_id),

            array('limit' => $limit, 'offset' => $offset)

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    //}}}


 

    //{{{Analytics APIs


    // XXX check if blank filter is ok


    function getAnalytics($path, $filter, $limit = 25, $token = null)

    {

        return $this->get(

            '/almaws/v1/analytics/reports',

            array(),

            array('path' => urlencode($path), 'filter' => urlencode($filter),

                'limit' => $limit, 'token' => $token)

        );

    }

 

    //}}}


 

    //{{{Job APIs


    // {{{ postJob (Submit a manual or scheduled job)


    function postJob($job_id, $op, $job)

    {

        $ret = $this->post(

            '/almaws/v1/conf/jobs/{job_id}',

            array('job_id' => $job_id),

            array('op' => $op),

            $job

        );

        $this->checkForErrorMessage($ret);

        return $ret;

    }

    // }}}


 

    //}}}


 

 

}

 

// }}}


 

// {{{ class GrimaTask


abstract class GrimaTask implements ArrayAccess

{

 

    public $error = false;

    public $args = array();

    public $el_override = array();

 

    public $auto_args = array();

 

    public $messages = array();

 

    function offsetExists($offset)

    {

        return isset($this->args[$offset]);

    }

 

    function offsetGet($offset)

    {

        return $this->args[$offset];

    }

 

    function offsetSet($offset, $value)

    {

        $this->args[$offset] = $value;

    }

 

    function offsetUnset($offset)

    {

        unset($this->args[$offset]);

    }

 

    function __construct()

    {

        $webroot = __DIR__;

        $base = get_class($this); //basename($_SERVER['PHP_SELF'],'.php');


        if (file_exists(join_paths($webroot, $base, "$base.xml")) and (!isset($this->formxml))) {

            $this->formxml = file_get_contents(join_paths($webroot, $base, "$base.xml"));

        }

        if (isset($this->formxml)) {

            $this->form = new GrimaForm();

            $this->form->fromXML($this->formxml);

        }

    }

 

    function setup_splat()

    {

        $webroot = __DIR__;

        $basename = get_class($this); //basename($_SERVER['PHP_SELF'],'.php');


 

        $this->splat = new zemowsplat\Splat();

 

        $this->splat->addBases(

            array(

            "$webroot/$basename/splats",    // per-task overrides


            "$webroot/splats",              // default


            )

        );

 

        $this->splatVars = array(

            'title'             => $this->form->title,

            'basename'          => $basename,

            'webroot'           => $webroot,

            'local_stylesheets' => array('Grima.css'),

            'form'              => &$this->form,

            'messages'          => &$this->messages,

            'width'             => 9,

        );

        if (isset($this['redirect_url'])) {

            $this->splatVars['redirect_url'] = $this['redirect_url'];

        }

    }

 

    function print_form()

    {

        $this->form->loadValues($this);

        $this->splat->splat('print_form', $this->splatVars);

    }

 

    function print_success()

    {

        $this->form->loadPersistentValues($this);

        $this->splat->splat('print_success', $this->splatVars);

    }

 

    function print_failure()

    {

        $this->form->loadValues($this);

        $this->splat->splat('print_failure', $this->splatVars);

    }

 

    function check_login()

    {

        global $grima;

        if (isset($grima->apikey) and isset($grima->server)

            and ($grima->apikey) and ($grima->server)

        ) {

            return true;

        } else {

            GrimaTask::call('Login', array("redirect_url"=>$_SERVER['PHP_SELF']));

            exit;

            return false;

        }

    }

 

    public function addMessage($type, $message)

    {

        $this->messages[] = new GrimaTaskMessage($type, $message);

    }

 

    public function run()

    {

        $this->check_login(); // if not logged in, print login form


        $this->error = false;

        $this->get_input();

        $this->setup_splat(); // should happen after form xml read in get_input


        if ($this->check_input()) {

            try {

                $this->do_task();

            } catch (Exception $e) {

                $this->addMessage('error', $e->getMessage());

                $this->error = true;

            }

        } else {

            $this->print_form();

            exit;

        }

        if ($this->error) {

            $this->print_failure();

        } else {

            $this->print_success();

        }

    }

 

    public static function RunIt()

    {

        $task = new static();

        $task->run();

    }

 

    function get_input()

    {

        if (isset($this->form)) {

            if (php_sapi_name() == "cli") { // command line


 

                $param = "";

                foreach ($this->form->fields as $field) {

                    $short = $field->shortname;

                    if ($field->required) {

                        $param .= "$short:";

                    } else {

                        $param .= "$short::";

                    }

                }

 

                if ($option = getopt($param)) {

                    foreach ($this->form->fields as $field) {

                        if (isset($option[$field->shortname])) {

                            $this[$field->name] = $option[$field->shortname];

                        }

                    }

                /*


                } else {


                    $this->usage(); exit;


                */


                }

 

                if (!$this->check_input()) {

                    $this->usage(); exit;

                }

 

            } else { // web


                foreach ($this->form->fields as $field) {

                    if (isset($_REQUEST[$field->name])) {

                        $this[$field->name] = $_REQUEST[$field->name];

                        /* sanitize */


                    }

                }

            }

 

        } else {

            // ??


            $this->get_input_param($this->auto_args);

        }

    }

 

    function check_input()

    {

        if (isset($this->form)) {

            $input_good = true;

            foreach ($this->form->fields as $field) {

                if ($field->required) {

                    if (!isset($this[$field->name])

                        or !($this[$field->name])

                    ) {

                        $field->error_condition = "error";

                        $field->error_message = "Field is required\n";

                        $input_good = false;

                    }

                }

            }

            return $input_good;

        } else {

 

            foreach ($this->auto_args as $k => $v) {

                if (preg_match('/[^:]:$/', $k)) {

                    if (!isset($this->args[$v]) or !($this->args[$v])) {

                        return false;

                    }

                }

            }

            return true;

        }

    }

 

    function get_input_param($param)

    {

        if (php_sapi_name() == "cli") { // command line


            if ($options = getopt(implode(array_keys($param)))) {

                foreach ($param as $k => $v) {

                    $this->args[$v] = $options[$k[0]];

                }

                if (!$this->check_input()) {

                    $this->usage(); exit;

                }

            } else {

                $this->usage(); exit;

            }

        } else { // web


            foreach ($param as $k => $v) {

                if (isset($_REQUEST[$v])) {

                    $this->args[$v] = $_REQUEST[$v];

                }

            }

            if (!$this->check_input()) {

                $this->print_form(); exit;

            }

        }

    }

 

    abstract function do_task();

 

    function usage()

    {

        // XXX rewrite for grima form


        global $argv;

        print "Usage: php ${argv[0]} ";

 

        foreach ($this->form->fields as $field) {

            $k = $field->shortname;

            $n = $field->name;

            if ($field->required) {

                print "-$k <$n> ";

            } else {

                print "[-$k <$n>] ";

            }

        }

        print "\n"; exit;

 

 

        // old format


        /*


        foreach ($this->auto_args as $k => $v) {


            if (preg_match('/^(.):$/', $k, $m)) {


                print "-${m[1]} <$v> ";


            } else {


                if (preg_match('/^(.)::$/', $k, $m)) {


                    print "[ -${m[1]} <$v> ] ";


                } else {


                    if (preg_match('/^.$/', $k)) {


                        print "[ -$k ] ";


                    }


                }


            }


        }


        print "\n";


        exit;


        */


    }

 

    public static function call($grimaname, $args = array())

    {

        $url = rtrim("../$grimaname/$grimaname.php?" . http_build_query($args), "?");

        do_redirect($url);

    }

 

}

 

// }}}


 

// {{{ class GrimaTaskMessage


class GrimaTaskMessage


{

    public $type;

        /* bootstrap type: debug, info, success, warning, error */


    public $message;

 

    function __construct($type, $message)

    {

        $this->type = $type;

        $this->message = $message;

    }

}

 

// }}}


 

//{{{ class GrimaForm


class GrimaForm


{

    public $fields = array();

    public $title;

    protected $action;

 

    // {{{ loadValues


    function loadValues($obj)

    {

        foreach ($this->fields as $field) {

            if (isset($obj[$field->name])) {

                $field->value = $obj[$field->name];

            }

        }

    }

    // }}}


 

    // {{{ loadPersistentValues


    function loadPersistentValues($obj)

    {

        foreach ($this->fields as $field) {

            if (($field->persistent) and isset($obj[$field->name])) {

                $field->value = $obj[$field->name];

            }

        }

    }

    // }}}


 

    // {{{ fromXML


    function fromXML($xml)

    {

        $doc = new DomDocument();

        $doc->loadXML($xml);

        $xpath = new DomXpath($doc);

        $this->title = $xpath->query('//Title')[0]->nodeValue;

        $this->action = basename($_SERVER['PHP_SELF']); // allow set?


 

        $nodes = $xpath->query('//Field');

        foreach ($nodes as $node) {

            $this->fields[$node->getAttribute('name')] = new GrimaFormField($node);

        }

    }

    // }}}


 

}

 

// }}}


 

//{{{ class GrimaDataStore


 

$ds_barcode = 'GRIMABYZEMKAT';

 

class GrimaDataStore implements ArrayAccess

{

 

    public $marc;

    public $bib;

    public $holding;

    public $item;

 

    // {{{ __construction


    function __construct()

    {

        global $ds_barcode;

        $this->item = new Item();

        try {

            $this->item->loadFromAlmaBarcode($ds_barcode);

        } catch (Exception $e) {

            $this->setup();

        }

        $this->bib = new Bib();

        $this->bib->loadFromAlma($this->item['mms_id']);

        $this->bib->useNormac();

    }

    // }}}


 

    // {{{ array access functions


    function offsetExists($offset)

    {

        $fields = $this->bib->marc->getFields('ZEM');

        foreach ($fields as $field) {

            $keys = $field->getSubfields('k');

            if ($keys[0]->data == $offset) {

                return true;

            }

        }

        return false;

    }

 

    function offsetGet($offset)

    {

        $fields = $this->bib->marc->getFields('ZEM');

        foreach ($fields as $field) {

            $keys = $field->getSubfields('k');

            if ($keys[0]->data == $offset) {

                $values = $field->getSubfields('v');

                return $values[0]->data;

            }

        }

        return false;

    }

 

    function offsetSet($offset, $value)

    {

        $fields = $this->bib->marc->getFields('ZEM');

        foreach ($fields as $field) {

            $keys = $field->getSubfields('k');

            if ($keys[0]->data == $offset) {

                $values = $field->getSubfields('v');

                $values[0]->data = $value;

                $this->bib->updateAlma();

                return true;

            }

        }

        $subarray = array(

            new ISO2709Subfield('k', $offset),

            new ISO2709Subfield('v', $value),

        );

        $field = new ISO2709Field('ZEM', null, "    ", $subarray);

        $this->bib->marc->appendField($field);

        $this->bib->updateAlma();

        return false;

    }

 

    function offsetUnset($offset)

    {

        $fields = $this->bib->marc->getFields('ZEM');

        foreach ($fields as $field) {

            $keys = $field->getSubfields('k');

            if ($keys[0]->data == $offset) {

                $field->delete();

                $this->bib->updateAlma();

                return true;

            }

        }

        return false;

    }

    // }}}


 

    // {{{ setup


    function setup()

    {

        global $ds_barcode;

        $bib = new Bib();

        $bib['title'] = "GRIMA'S DATA STORE"; // XXX indicators 00?


        $bib['suppress_from_publishing'] = "true";

        $bib->addToAlma();

        $this->bib = $bib;

        $this->bib->useNormac();

 

        $library = Library::getOneLibrary();

        $location = $library->getOneLocation();

 

        $holding = new Holding();

        $holding['library_code'] = $library['code'];

        $holding['location_code'] = $location['code'];

        $holding->addToAlmaBib($bib['mms_id']);

        $this->holding = $holding;

 

        $item = new Item();

        $item['barcode'] = $ds_barcode;

        $item->addToAlmaHolding($bib['mms_id'], $holding['holding_id']);

        $this->item = $item;

 

        preg_match('/\d{5}$/', $bib['mms_id'], $m);

        $this['alma institution code'] = $m[0];

    }

    // }}}


 

    // {{{ exists


    public static function exists()

    {

        global $ds_barcode;

        $item = new Item();

        try {

            $item->loadFromAlmaBarcode($ds_barcode);

            return true;

        } catch (Exception $e) {

            return false;

        }

    }

 

    // }}}


 

    // {{{ destroy


    public function destroy()

    {

        global $ds_barcode;

        $item = new Item();

        $item->loadFromAlmaBarcode($ds_barcode);

        $bib = new Bib();

        $bib->loadFromAlma($item['mms_id']);

        $bib->deleteTreeFromAlma();

    }

 

    // }}}


 

}

 

// }}}


 

//{{{ class GrimaFormField


 

class GrimaFormField


{

 

    public $value;

 

    public $name;

    public $shortname;

    public $label;

    public $placeholder;

    public $required;

    public $persistent;

    public $autofocus;

    public $visible;

    public $rows;

    public $dataset;

    protected $autocomplete;

    protected $highlight;

    public $error_condition = ""; /* can be warning or error */


    public $error_message = "";

 

    // {{{ booly - is it true or false


    function booly($str, $default = 'undefined')

    {

        switch(strtolower($str)) {

        case 'true':

        case 't':

        case 'on':

        case 'yes':

        case '1':

            return true;

        case 'false':

        case 'f':

        case 'off':

        case 'no':

        case '0':

            return false;

        default:

            return $default;

        }

    }

    // }}}


 

    // {{{ __construct


    function __construct($field)

    {

        $this->name = $field->getAttribute('name');

        $this->shortname = $field->getAttribute('shortname');

        $this->label = $field->getAttribute('label');

        $this->placeholder = $field->getAttribute('placeholder');

        $this->rows = $field->getAttribute('rows');

        $this->type = $field->getAttribute('type');

        if (!$this->type) {

            $this->type = 'input';

        }

        $this->required = $this->booly($field->getAttribute('required'), true);

        $this->persistent = $this->booly($field->getAttribute('persistent'), false);

        $this->autofocus = $this->booly($field->getAttribute('autofocus'), false);

        $this->autocomplete = $this->booly($field->getAttribute('autocomplete'), false);

        $this->visible = $this->booly($field->getAttribute('visible'), true);

        $this->dataset = $field->getAttribute('dataset');

        $this->options = array();

        if ($this->dataset) {

            if ($this->dataset == "institutions") {

                $institutions = GrimaDB::getInstitutions();

                $currentUser = GrimaUser::GetCurrentUser();

                foreach ($institutions as $institution) {

                    $i = htmlspecialchars($institution);

                    $s = ($institution === $currentUser['institution']) ? ' selected="selected"' : '';

                    $this->options[] = "<option value=\"$i\"$s>$i</option>";

                }

            }

        } else {

            foreach ($field->getElementsByTagName("option") as $option) {

                $this->options[] = $option->ownerDocument->saveXML($option);

            }

        }

    }

    // }}}


 

}

 

// }}}


 

//{{{ class AlmaObject


class AlmaObject implements ArrayAccess

{

    public $el_access = array();

    public $xml;

    public $templateDir = __DIR__ . "/templates";

 

    // {{{ __construct


    function __construct()

    {

        $this->xml = new DomDocument();

        $blankRecord = get_class($this);

        $this->xml->loadXML(file_get_contents("{$this->templateDir}/{$blankRecord}.xml"));

    }

    // }}}


 

    function offsetExists($offset)

    {

        if (isset($this->el_override)) {

            return array_key_exists($offset, $this->el_override);

        }

        return array_key_exists($offset, $this->el_access);

    }

 

    function offsetGet($offset)

    {

        if ((isset($this->el_override))

            and (isset($this->el_override[$offset]))

        ) {

            return $this->el_override[$offset];

        }

        $xpath = new DomXpath($this->xml);

        $node = $xpath->query($this->el_address[$offset]);

        if (sizeof($node) >= 1) {

            return $node[0]->nodeValue;

        }

        return null;

    }

 

    // XXX el_override ? 


    function offsetSet($offset, $value)

    {

        $xpath = new DomXpath($this->xml);

        $node = $xpath->query($this->el_address[$offset]);

        $node[0]->nodeValue = 

            preg_replace('/&(?!#?[a-z0-9]+;)/', '&amp;', $value); # XXX

    }

 

    function offsetUnset($offset)

    {

        $xpath = new DomXpath($this->xml);

        $node = $xpath->query($this->el_address[$offset]);

        $node[0]->nodeValue = null;

    }

 

}

 

// }}}


 

// {{{ class AlmaObjectWithMARC


class AlmaObjectWithMARC extends AlmaObject


{

 

    public $marc; // Normac MARC21Record


 

    function useNormac()

    {

        if (isset($this->marc)) { 

            return;

        }

        $this->marc = new MARC21Record();

        $this->marc->loadFromString($this->xml->saveXML());

    }

 

    // {{{ AlmaObjectWithMARC -> addControlField


    function addControlField($tag, $data)

    {

        $this->useNormac(); // this function uses normac


        $subarray = array();

        $field = new ISO2709Field($tag, $data);

        $this->marc->AppendField($field, true);

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> addDataField


    function addDataField($tag, $indicators, $subfields)

    {

        $this->useNormac(); // this function uses normac


        $subarray = array();

        foreach ($subfields as $k => $v) {

            $subarray[] = new ISO2709Subfield($k, $v);

        }

        $field = new ISO2709Field($tag, null, $indicators, $subarray);

        $fieldstr = $field->AsMnemonicString();

 

        $fields = $this->marc->getFields($tag);

        $found = false;

        foreach($fields as $f) {

            $fstr = $f->AsMnemonicString();

            if ($fstr == $fieldstr) {

                $found = true;

            } else {

                #error_log($fstr . " vs " . $fieldstr);

            }

        }

        if (! $found) {

            $this->marc->AppendField($field, true);

        }

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> normacToXML


    function normacToXML()

    {

        if (isset($this->marc)) {

            $newRecord = new DOMDocument;

            $marc = preg_replace('/&(?!#?[a-z0-9]+;)/', '&amp;', 

                $this->marc->asXMLString());

            $newRecord->loadXML($marc);

 

            $xpath = new DOMXpath($this->xml);

            $record = $xpath->query('//record');

            $node = $record[0];

            $node->parentNode->removeChild($node);

 

            $node = $this->xml->importNode($newRecord->documentElement, true);

            $this->xml->documentElement->appendChild($node);

        }

    }

 

    // }}}


 

    // {{{ AlmaObjectWithMARC -> appendField


    function appendField($tag, $ind1, $ind2, $subfields)

    ## XXX: replace with normac


    {

        $this->useNormac(); // this function uses normac


 

        $subs = array();

        foreach ($subfields as $k => $v) {

            $subfa = new ISO2709Subfield($k, $v);

            $subs[] = $subfa;

        }

        $field = new ISO2709Field($tag, null, $ind1.$ind2, $subs);

        $this->marc->AppendField($field,true);

 

        /* XXX: sheesh


        $frag = "<datafield ind1=\"$ind1\" ind2=\"$ind2\" tag=\"$tag\">";


        foreach ($subfields as $k => $v) {


            $frag .= "<subfield code=\"$k\">$v</subfield>";


        }


        $frag .= "</datafield>";


        $xpath = new DomXpath($this->xml);


        $record = $xpath->query("//record");


        appendInnerXML($record[0], $frag);


        */


    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> getFields


    function getFields($tag)

    {

        $this->useNormac(); // this function uses normac


        return $this->marc->getFields($tag);

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> getMarcFields # XXX IN PROGRESS


    function getMarcFields($tag)

    {

        $xpath = new DomXpath($this->xml);

        $tag = preg_replace('/X*$/', '', $tag);

        $tag = preg_replace('/\.*$/', '', $tag);

        $fields = $xpath->query("//record/datafield[starts-with(@tag,'$tag')]");

        $fieldarr = array();

        foreach ($fields as $field) {

            $marcfield = new MARCField();

            // indicators?


            $subfieldarr = array();

            foreach ($field->childNodes as $child) {

                $subfieldarr[] = array(

                    $child->attributes[0]->value,

                    $child->nodeValue

                );

            }

            $fieldarr[] = $subfieldarr;

        }

        return $fieldarr;

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> getSubfieldValues


    function getSubfieldValues($tag, $code)

    {

        $xpath = new DomXpath($this->xml);

        $subfields = $xpath->query("//record/datafield[@tag='$tag']/subfield[@code='$code']");

        $arr = array();

        foreach ($subfields as $subfield) {

            $arr[] = $subfield->nodeValue;

        }

        return $arr;

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> deleteField


    function deleteField($tag)

    {

        $xpath = new DomXpath($this->xml);

        $fields = $xpath->query("//record/datafield[@tag='$tag']");

        foreach ($fields as $field) {

            $field->parentNode->removeChild($field);

        }

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> deleteSubfieldMatching


    function deleteSubfieldMatching($tag, $code, $regex)

    {

        $xpath = new DomXPath($this->xml);

        $subfs = $xpath->query("//datafield[@tag='$tag']/subfield[@code='$code']");

        foreach ($subfs as $subf) {

            if (preg_match($regex, $subf->nodeValue)) {

                $subf->parentNode->removeChild($subf);

            }

        }

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> deleteFieldMatching # XXX TEST


    function deleteFieldMatching($tag,$code,$regex)

    {

        $this->useNormac();

        foreach ($this->getFields($tag) as $field) {

            foreach ($field->getSubfields($code) as $subfield) {

                if (preg_match($regex,$subfield->data)) {

                    $field->delete();

                    break;

                }

            }

        }

    }

    // }}}


 

    // {{{ AlmaObjectWithMARC -> replaceOrAddSubfield


    function replaceOrAddSubfield($tag, $code, $value)

    ## XXX: replace with normac


    {

        // very shady but sometimes needed


        $xpath = new DomXpath($this->xml);

        $fields = $xpath->query("//record/datafield[@tag='$tag']");

        if (sizeof($fields) == 0) {

            $this->appendField($tag, ' ', ' ', array($code => $value));

        } else {

            $done = false;

            foreach ($fields[0]->childNodes as $subfield) {

                if ($subfield->nodeType !== 1) {

                    continue;

                }

                if ($subfield->getAttribute("code") == $code) {

                    $subfield->nodeValue = $value;

                    $done = true;

                    break;

                }

            }

            if (!$done) {

                $subfield = $this->xml->createElement("subfield");

                $subfield->setAttribute("code", $code);

                $subfield->appendChild($this->xml->createTextNode($value));

                $fields[0]->appendChild($subfield);

            }

        }

    }

    // }}}


 

}

// }}}


 

// {{{ class Bib


class Bib extends AlmaObjectWithMARC


{

    public $holdingsList; // HoldingsList object


    public $holdings = array();

 

    public $itemList;

    public $items = array();

 

    public $portfolioList = array(); // just an array for now


 

    /* public $networknums = array(); */


 

    protected $el_address = array(

        'mms_id' => '//mms_id',

        'leader' => '//leader',

        'record_format' => '//record_format',

        'title' => '//title',

        'author' => '//author',

        'place_of_publication' => '//place_of_publication',

        'publisher_const' => '//publisher_const',

        'publisher' => '//publisher_const',

        'suppress_from_publishing' => '//suppress_from_publishing',

    );

 

    function offsetGet($offset)

    {

        if ($offset == 'Type') {

            $leader = $this['leader'];

            return $leader[6];

        }

        if ($offset == 'BLvl') {

            $leader = $this['leader'];

            return $leader[7];

        }

        if ($offset == 'ELvl') {

            $leader = $this['leader'];

            return $leader[17];

        }

        if ($offset == 'Desc') {

            $leader = $this['leader'];

            return $leader[18];

        }

        if ($offset == 'Lang') {

            $my008s = $this->getFields('008');

            $my008 = $my008s[0];

            $data = $my008->data;

            return substr($data,35,3);

        }

        return parent::offsetGet($offset);

    }

 

    // override because these go multiple places


    function offsetSet($offset, $value)

    {

        parent::offsetSet($offset, $value);

        if ($offset == 'author') {

            $this->replaceOrAddSubfield('100', 'a', $value);

        }

        if ($offset == 'title') {

            $this->replaceOrAddSubfield('245', 'a', $value);

        }

        if (($offset == 'publisher_const') or ($offset == 'publisher')) {

            $this->replaceOrAddSubfield('264', 'b', $value);

        }

        if ($offset == 'place_of_publication') {

            $this->replaceOrAddSubfield('264', 'a', $value);

        }

    }

 

    // {{{ Bib -> loadFromAlma (get) - gets Bib from Alma


    function loadFromAlma($mms_id)

    {

        global $grima;

        $this->xml = $grima->getBib($mms_id);

        $this->useNormac(); # XXX okay?

    }

    // }}}


 

    // {{{ Bib -> addToAlma (post) - adds the Bib to Alma


    function addToAlma()

    {

        global $grima;

        $this->normacToXML();

        $this->xml = $grima->postBib($this->xml);

    }

    // }}}


 

    // {{{ Bib -> updateAlma (put) - replaces the Bib in Alma


    function updateAlma()

    {

        global $grima;

        // XXX parent here?


        $this->normacToXML();

        $this->xml = $grima->putBib($this['mms_id'], $this->xml);

    }

    // }}}


 

    // {{{ Bib -> deleteFromAlma (delete) - deletes the Bib from Alma


    function deleteFromAlma()

    {

        global $grima;

        $grima->deleteBib($this['mms_id']);

    }

    // }}}


 

    // {{{ getMmsFromOCLC (get) - gets the MMS for an OCLC number


    public static function getMmsFromOCLC($oclc) # XXX


    {

        global $grima;

 

        $report = new AnalyticsReport();

        $report->path = "/shared/Community/Reports/Institutions/University of Kentucky/Kathryn/OclcToMMS";

        $report->filter = '


<sawx:expr xsi:type="sawx:comparison" op="equal" xmlns:saw="com.siebel.analytics.web/report/v1.1"


xmlns:sawx="com.siebel.analytics.web/expression/v1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"


xmlns:xsd="http://www.w3.org/2001/XMLSchema">


  <sawx:expr xsi:type="sawx:sqlExpression">"Holding Details"."Holding Id"</sawx:expr><sawx:expr xsi:type="xsd:string">{holding_id}</sawx:expr>


</sawx:expr>';

 

        $report->filter = '


<sawx:expr xsi:type="sawx:comparison" op="equal" xmlns:saw="com.siebel.analytics.web/report/v1.1"


xmlns:sawx="com.siebel.analytics.web/expression/v1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"


xmlns:xsd="http://www.w3.org/2001/XMLSchema">


  <sawx:expr xsi:type="sawx:sqlExpression">"Bibliographic Details"."OCLC Control Number (035a)"</sawx:expr></sawx:expr>


';

 

        $report->runReport(array('oclc' => $oclc), 1);

        if (count($report->rows) == 1) {

            return $report->rows[0][1];

        } else {

            throw new Exception("No MMS for OCLC #$oclc");

        }

    }

    // }}}


 

    // {{{ Bib -> deleteTreeFromAlma (delete) - deletes Bib and inventory from Alma


    function deleteTreeFromAlma()

    {

        global $grima;

        $this->getHoldings();

        foreach ($this->holdings as $holding) {

            $holding->deleteTreeFromAlma(); // XXX


        }

        $this->deleteAllPortfolios($this['mms_id']); // XXX


        $grima->deleteBib($this['mms_id']);

    }

    // }}}


 

    // {{{ Bib -> hasInventory - does the bib have holdings or portfolios in Alma?


    function hasInventory()

    {

        $this->getHoldingsList();

        if (count($this->holdingsList->entries) > 0) {

            return true;

        }

        $this->getPortfolioList();

        if (count($this->portfolioList) > 0) {

            print_r($this->portfolioList);

            return true;

        } else {

            return false;

        }

    }

    // }}}


 

    // {{{ Bib -> linkedToCZ - is the bib linked to community zone?


    function linkedToCZ()

    {

        $xpath = new DomXPath($this->xml);

        $nodes = $xpath->query("//linked_record_id[@type='CZ']");

        return (count($nodes) > 0);

    }

    // }}}


 

    // {{{ Bib -> unlinkFromCZ - does this work


    function unlinkFromCZ()

    {

        $xpath = new DomXPath($this->xml);

        $nodes = $xpath->query("//linked_record_id[@type='CZ']");

        foreach ($nodes as $node) {

            $node->parentNode->removeChild($node);

        }

        $this->updateAlma();

    }

    // }}}


 

    // {{{ Bib -> getHoldings - get holdings objects


    function getHoldings()

    {

        $this->getHoldingsList();

        foreach ($this->holdingsList->entries as $entry) {

            $holding = new Holding();

            $holding->loadFromAlma($this['mms_id'], $entry['holding_id']);

            $holding['mms_id'] = $this['mms_id'];

            $this->holdings[] = $holding;

        }

        return $this->holdings;

    }

    // }}}


 

    // {{{ Bib -> deleteAllPortfolios - delete all portfolios from the bib


    function deleteAllPortfolios()

    {

        global $grima;

        while ($this->getPortfolioList()) {

            foreach ($this->portfolioList as $portfolio) {

                error_log("deleting " . $portfolio['pid'] . "\n");

                $portfolio->deleteFromAlma();

            }

            $this->portfolioList = array();

            sleep(3);

        }

    }

    // }}}


 

    // {{{ Bib -> getHoldingsList


    function getHoldingsList()

    {

        $this->holdingsList = new HoldingsList($this['mms_id']);

    }

    // }}}


 

    // {{{ Bib -> getPortfolioList


    function getPortfolioList()

    {

        // maybe rename


        global $grima;

        $limit = 10; $offset = 0; // where to allow passing


        $ret = $grima->getElectronicPortfoliosForBib($this['mms_id'], $limit, $offset);

        $xpath = new DOMXpath($ret);

        $ports = $xpath->query('//portfolio');

        foreach ($ports as $portnode) {

            $newport = new ElectronicPortfolio();

            $newport->loadFromPortfolioListNode($portnode);

            $this->portfolioList[] = $newport;

        }

        return count($ports); // XXX is this the right thing to return?


    }

    // }}}


 

    // {{{ Bib -> getPortfolios


    function getPortfolios()

    {

        $this->getPortfolioList();

        foreach ($this->portfolioList as $port) {

            $port->loadFromAlma($port['portfolio_id']);

        }

        return $this->portfolioList;

    }

    // }}}


 

    // {{{ getItems - get items objects


    function getItems()

    {

        $this->getItemList();

        $this->items =& $this->itemList->items;

        return $this->items;

    }

    // }}}


 

    // {{{ getItemList - populates itemList property from Alma


    function getItemList()

    {

        // XXX


        global $grima;

        $this->itemList = new ItemList($this['mms_id'], 'ALL');

    }

    // }}}


 

    // {{{ Bib -> get_title_proper


    function get_title_proper()

    {

        $xpath = new DomXpath($this->xml);

        $title = $xpath->query("//record/datafield[@tag='245']/subfield[@code='a']");

        return preg_replace("/[ \/=:,;\.]*$/", "", $title[0]->nodeValue);

    }

    // }}}


 

    /*


    function get_networkNumbers() {


        $xpath = new DomXpath($this->xml);


        $netNums = $xpath->query("//bib/network_numbers/network_number");


        $ret = array();


        for ($j=0;$j<$netNums->length;$j++) {


            $ret[] = $netNums[$j]->nodeValue;


        }


        return $ret;


    }


    */


 

    // {{{ Bib -> getLCCallNumber #XXX


    function getLCCallNumber()

    {

        $xpath = new DomXPath($this->xml);

        $calls = array();

        foreach (array('050','090') as $tag) {

            foreach ($xpath->query("//datafield[@tag='$tag']") as $call) {

                $calls[] = $call;

            }

        }

        $ret = array();

 

        foreach ($calls as $node) {

            $classs = $xpath->query("subfield[@code='a']", $node);

            $items = $xpath->query("subfield[@code='b']", $node);

            if ((count($classs) > 0) and (count($items) > 0)) {

                $ret = array($classs[0]->nodeValue,$items[0]->nodeValue);

            }

        }

        return $ret;

    }

    // }}}


 

}

 

// }}}


 

// {{{ class HoldingsList


class HoldingsList extends AlmaObject


{

    public $el_address = array(

        'mms_id' => '//mms_id',

        'title' => '//title',

        'author' => '//author',

    );

    public $xml;

    // public $holdings = array(); # should this go in BIB?


    public $entries = array(); // array of HoldingsListEntry


 

    function __construct($mms_id = null)

    {

        if (!is_null($mms_id)) {

            $this->loadFromAlma($mms_id);

        }

    }

 

    function loadFromAlma($mms_id)

    {

        global $grima;

        $this->xml = $grima->getHoldingsList($mms_id);

        $xpath = new DomXpath($this->xml);

        $hs = $xpath->query('//holding');

        $this->entries = array(); // clear


        // $this->holdings = array(); # clear


        foreach ($hs as $h) {

            // $this->holdings[] = new HoldingsListEntry($h,$mms_id);


            $this->entries[] = new HoldingsListEntry($h, $mms_id);

        }

    }

}

 

// }}}


 

// {{{ class HoldingsListEntry


class HoldingsListEntry extends AlmaObject


{

    protected $el_address = array(

        'holding_id' => '//holding_id',

        'call_number' => '//holding/call_number',

        'library_code' => '//holding/library',

        'library' => '//holding/library/@desc',

        'location_code' => '//holding/location',

        'location' => '//holding/location/@desc'


    );

    public $xml;

 

    function __construct($node, $mms_id)

    {

        $this->xml = new DomDocument();

        $this->xml->appendChild($this->xml->importNode($node, true));

        $this->el_override['mms_id'] = $mms_id;

    }

 

    function getItemList($limit = -1)

    {

        global $grima;

        $this->getMmsIfNeeded();

        $this->itemList = new ItemList($this['mms_id'], $this['holding_id'], $limit);

    }

}

 

// }}}


 

// {{{ class ItemList


class ItemList extends AlmaObject


{

    public $items = array();    // maybe ok as is


 

    function __construct($mms_id, $holding_id, $limit = -1)

    {

 

        global $grima;

        $curr_offset = 0;

        $req_limit = ($limit == -1)?100:$limit;

 

        do {

            if ($curr_offset > 0) {

                if (($curr_offset+1)*100 > $limit) {

                    $req_limit = $limit - $curr_offset*100;

                } else {

                    $req_limit = 100;

                }

            }

            $xml = $grima->getItemList($mms_id, $holding_id, $req_limit, $curr_offset*100);

            $xpath = new DomXpath($xml);

            $is = $xpath->query('//item');

            foreach ($is as $i) {

                $new_item = new Item();

                $new_item->loadFromItemListNode($i);

                $this->items[] = $new_item;

            }

            $xpath = new DomXPath($xml);

            if (!$curr_offset) {

                $length = $xpath->query('//items/@total_record_count')[0]->nodeValue;

                if ($limit == -1) { $limit = $length;

                }

            }

            $curr_offset++;

 

        } while (($curr_offset*100 < $length) and ($curr_offset*100 < $limit));

 

    }

 

}

 

// }}}


 

// {{{ class Holding


class Holding extends AlmaObjectWithMARC


{

    public $itemList; // object


    public $items = array();

    public $xml;

 

    function offsetSet($offset, $value)

    {

        if ($offset == "mms_id") {

            $this->el_override['mms_id'] = $value;

            return;

        } 

        if ($offset == "location_code") {

            $this->setLocationCode($value);

            return;

        }

        parent::offsetSet($offset, $value);

    }

 

    function offsetGet($offset)

    {

        // XXX TEST


        if ($offset == "library") {

            $lib = new Library();

            $lib->loadFromAlma($this['library_code']);

            return $lib['name'];

        }

        if ($offset == "location") {

            $loc = new Location();

            $loc->loadFromAlma($this['library_code'], $this['location_code']);

            return $loc['name'];

        }

        if ($offset == "inst_code") {

            return $this->getInstitutionCode();

        }

        if ($offset == "library_code") {

            return $this->getLibraryCode();

        }

        if ($offset == "location_code") {

            return $this->getLocationCode();

        }

        if ($offset == "call_number") {

            $Hs = $this->getSubfieldValues("852", "h");

            $Is = $this->getSubfieldValues("852", "i");

            $acc = "";

            foreach ($Hs as $h) {

                $acc .= "$h ";

            }

            foreach ($Is as $i) {

                $acc .= "$i ";

            }

            return rtrim($acc);

        }

        return parent::offsetGet($offset);

    }

 

    // {{{ $el_address


    public $el_address = array(

        'holding_id' => '//holding_id',

        'shelving_scheme' => "/holding/record/datafield[@tag='852']/@ind1",

 

        /* should no longer be needed */


        'inst_code' => "/holding/record/datafield[@tag='852']/subfield[@code='a']",

        'library_code' => "/holding/record/datafield[@tag='852']/subfield[@code='b']",

        'location_code' => "/holding/record/datafield[@tag='852']/subfield[@code='c']",

 

        'classification_part' => "/holding/record/datafield[@tag='852']/subfield[@code='h']",

        '852h' => "/holding/record/datafield[@tag='852']/subfield[@code='h']",

 

        'item_part' => "/holding/record/datafield[@tag='852']/subfield[@code='i']",

        '852i' => "/holding/record/datafield[@tag='852']/subfield[@code='i']",

        /* should no longer be needed */


 

    );

    // }}}


 

    // {{{ loadFromAlma (get) - populates record from Alma


    function loadFromAlma($mms_id, $holding_id)

    {

        global $grima;

        $this->xml = $grima->getHolding($mms_id, $holding_id);

        $this['mms_id'] = $mms_id;

    }

    // }}}


 

    // {{{ getMmsFromHoldingID (get) - gets the MMS for a holding ID


    public static function getMmsFromHoldingID($holding_id)

    {

        global $grima;

 

        $report = new AnalyticsReport();

        // $report->path = "/shared/UK Libraries- University of Kentucky (UKY)/Reports/Kathryn/HoldingToMMS";


        $report->path = "/shared/Community/Reports/Institutions/University of Kentucky/Kathryn/HoldingToMMS";

        $report->filter = '


<sawx:expr xsi:type="sawx:comparison" op="equal" xmlns:saw="com.siebel.analytics.web/report/v1.1"


xmlns:sawx="com.siebel.analytics.web/expression/v1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"


xmlns:xsd="http://www.w3.org/2001/XMLSchema">


  <sawx:expr xsi:type="sawx:sqlExpression">"Holding Details"."Holding Id"</sawx:expr><sawx:expr xsi:type="xsd:string">{holding_id}</sawx:expr>


</sawx:expr>';

 

        $report->runReport(array('holding_id' => $holding_id), 1);

        if (count($report->rows) == 1) {

            return $report->rows[0][1];

        } else {

            throw new Exception("No MMS for Holding ID $holding_id");

        }

    }

    // }}}


 

    // {{{ getMmsIfNeeded (get) - populates MMS if needed


    function getMmsIfNeeded()

    {

        global $grima;

 

        if (!isset($this['mms_id']) or (!$this['mms_id'])) {

            $this['mms_id'] = Holding::getMmsFromHoldingID($this['holding_id']);

        }

    }

    // }}}


 

    // {{{ loadFromAlmaX (get) - populates record from Alma using holding_id


    function loadFromAlmaX($holding_id)

    {

        global $grima;

 

        $mms_id = Holding::getMmsFromHoldingID($holding_id);

        $this->xml = $grima->getHolding($mms_id, $holding_id);

        $this['mms_id'] = $mms_id;

    }

    // }}}


 

    // {{{ addToAlmaBib (post) - adds new holding record to specified bib


    function addToAlmaBib($mms_id)

    {

        global $grima;

        $this->normacToXML();

        $this->xml = $grima->postHolding($mms_id, $this->xml);

        $this['mms_id'] = $mms_id;

    }

    // }}}


 

    // {{{ hasItems - checks whether a holding record has any items


    function hasItems()

    {

        $this->getItemList();

        return (sizeof($this->itemList->items) > 0); // XXX test


    }

    // }}}


 

    // {{{ updateAlma (put) - update record in Alma


    function updateAlma()

    {

        global $grima;

        $this->normacToXML(); # XXX

        #error_log($this->xml->saveXML());


        $grima->putHolding($this['mms_id'], $this['holding_id'], $this->xml);

    }

    // }}}


 

    // {{{ deleteFromAlma (delete) - delete record in Alma


    function deleteFromAlma()

    {

        global $grima;

        $grima->deleteHolding($this['mms_id'], $this['holding_id']);

    }

    // }}}


 

    // {{{ getMethodOfAcquisition - get method of acq (fixed field)


    function getMethodOfAcquisition()

    {

        $this->useNormac(); 

        $fixed_fields = $this->getFields("008")[0];

        return substr($fixed_fields->data, 7, 1);

    }

    // }}}


 

    // {{{ setMethodOfAcquisition - get method of acq (fixed field)


    function setMethodOfAcquisition($code)

    {

        $this->useNormac(); 

        $fixed_fields = $this->getFields("008")[0];

        $newstr = substr_replace($fixed_fields->data,$code,7,1);

        $fixed_fields->data = $newstr;

    }

    // }}}


 

    // {{{ getInstitutionCode - get institution code, 852a


    function getInstitutionCode()

    {

        $this->useNormac();

        return $this->getFields("852")[0]->getSubFields("a")[0]->data;

    }

    // }}}


 

    // {{{ setInstitutionCode - set institution code, 852a


    function setInstitutionCode($code)

    {

        $this->useNormac();

        $instsf = $this->getFields("852")[0]->getSubFields("a")[0];

        $instsf->data = $code;

    }

    // }}}


 

    // {{{ getLibraryCode - get library code, 852b


    function getLibraryCode()

    {

        $this->useNormac();

        return $this->getFields("852")[0]->getSubFields("b")[0]->data;

    }

    // }}}


 

    // {{{ setLibraryCode - set institution code, 852b


    function setLibraryCode($code)

    {

        $this->useNormac();

        $libsf = $this->getFields("852")[0]->getSubFields("b")[0];

        $libsf->data = $code;

    }

    // }}}


 

    // {{{ getLocationCode - get location code, 852c


    function getLocationCode()

    {

        $this->useNormac();

        return $this->getFields("852")[0]->getSubFields("c")[0]->data;

    }

    // }}}


 

    // {{{ setLocationCode - set institution code, 852c


    function setLocationCode($code)

    {

        $this->useNormac();

        $locsf = $this->getFields("852")[0]->getSubFields("c")[0];

        $locsf->data = $code;

    }

    // }}}


 

    function setCallNumberType($ind1) # upgrade to normac


    {

        # XXX check argument


        $this->useNormac();

        $the852 = $this->getFields("852")[0];

        $the852->indicators[0] = $ind1;

 

        /*


        $this->normacToXML();


        $xpath = new DomXpath($this->xml);


        $xpath->query("//record/datafield[@tag='852']")->item(0)->setAttribute("ind1", $ind1);


 

        $field852 = $xpath->query("//record/datafield[@tag='852']")->item(0);


        $subfieldHs = $xpath->query("subfield[@code='h']", $field852);


        foreach ($subfieldHs as $subfieldH) {


            $subfieldH->parentNode->removeChild($subfieldH);


        }


        $subfieldIs = $xpath->query("subfield[@code='i']", $field852);


        foreach ($subfieldIs as $subfieldI) {


            $subfieldI->parentNode->removeChild($subfieldI);


        }


 

        appendInnerXML($field852, "<subfield code=\"h\">$h</subfield>");


        if ($i) {


            appendInnerXML($field852, "<subfield code=\"i\">$i</subfield>");


        }


        */


    }

 

    function setCallNumber($h, $i, $ind1) # upgrade to normac


    {

        $this->normacToXML();

        $xpath = new DomXpath($this->xml);

        $xpath->query("//record/datafield[@tag='852']")->item(0)->setAttribute("ind1", $ind1);

 

        $field852 = $xpath->query("//record/datafield[@tag='852']")->item(0);

        $subfieldHs = $xpath->query("subfield[@code='h']", $field852);

        foreach ($subfieldHs as $subfieldH) {

            $subfieldH->parentNode->removeChild($subfieldH);

        }

        $subfieldIs = $xpath->query("subfield[@code='i']", $field852);

        foreach ($subfieldIs as $subfieldI) {

            $subfieldI->parentNode->removeChild($subfieldI);

        }

 

        appendInnerXML($field852, "<subfield code=\"h\">$h</subfield>");

        if ($i) {

            appendInnerXML($field852, "<subfield code=\"i\">$i</subfield>");

        }

    }

 

    // {{{ moveToBib - moves a holding from one bib to another


    function moveToBib($mms_id)

    {

        $this->deleteFromAlma();

        $this->addToAlmaBib($mms_id);

    }

    // }}}


 

    // {{{ getItems - get items objects


    function getItems()

    {

        $this->getItemList();

        $this->items =& $this->itemList->items;

        return $this->items;

    }

    // }}}


 

    // {{{ getItemList - populates itemList property from Alma


    function getItemList()

    {

        global $grima;

        $this->getMmsIfNeeded();

        $this->itemList = new ItemList($this['mms_id'], $this['holding_id']);

    }

    // }}}


 

    // {{{ Holding -> deleteTreeFromAlma - delete the holding and all items


    function deleteTreeFromAlma()

    {

        global $grima;

        $this->getItemList();

        foreach ($this->itemList->items as $item) {

            $item->deleteFromAlma("true");

        }

        $this->deleteFromAlma();

    }

    // }}}


 

    // {{{ Holding -> deleteSubfieldMatching # XXX TEST


    function deleteSubfieldMatching($tag,$code,$regex)

    {

        $this->useNormac();

        foreach ($this->getFields($tag) as $field) {

            foreach ($field->getSubfields($code) as $subfield) {

                if (preg_match($regex,$subfield->data)) {

                    $subfield->delete();

                }

            }

        }

    }

    // }}}


 

    // {{{ Holding -> deleteFieldMatching # XXX TEST


    function deleteFieldMatching($tag,$code,$regex)

    {

        $this->useNormac();

        foreach ($this->getFields($tag) as $field) {

            foreach ($field->getSubfields($code) as $subfield) {

                if (preg_match($regex,$subfield->data)) {

                    $field->delete();

                    break;

                }

            }

        }

    }

    // }}}


 

 

}

 

// }}}


 

// {{{ class Item


class Item extends AlmaObject


{

 

    public $el_address = array(

        'item_pid' => '//pid',

        'barcode' => '//barcode',

        'creation_date' => '//creation_date',

        'modification_date' => '//modification_date',

        'base_status' => '//base_status',

        'physical_material_type_code' => '//physical_material_type',

        'physical_material_type' => '//physical_material_type/@desc',

        'location' => '//location/@desc',

        'location_code' => '//location',

        'library' => '//location/@desc',

        'library_code' => '//library',

        'policy' => '//policy',

        'item_policy' => '//policy',

        'provenance' => '//provenance',

        'po_line' => '//po_line',

        'is_magnetic' => '//is_magnetic',

        'arrival_date' => '//arrival_date',

        'year_of_issue' => '//year_of_issue',

        'enumeration_a' => '//enumeration_a',

        'enumeration_b' => '//enumeration_b',

        'enumeration_c' => '//enumeration_c',

        'enumeration_d' => '//enumeration_d',

        'enumeration_e' => '//enumeration_e',

        'enumeration_f' => '//enumeration_f',

        'enumeration_g' => '//enumeration_g',

        'enumeration_h' => '//enumeration_h',

        'chronology_i' => '//chronology_i',

        'chronology_j' => '//chronology_j',

        'chronology_k' => '//chronology_k',

        'chronology_l' => '//chronology_l',

        'chronology_m' => '//chronology_m',

        'description' => '//description',

        'alternative_call_number' => '//alternative_call_number',

        'alternative_call_number_type' => '//alternative_call_number_type',

        'storage_location_id' => '//storage_location_id',

        'receiving_operator' => '//receiving_operator',

        'process_type' => '//process_type',

        'in_temp_location' => '//in_temp_location',

        'mms_id' => '//mms_id',

        'holding_id' => '//holding_id',

        'title' => '//title',

        'author' => '//author',

        'call_number' => '//call_number',

        'pages' => '//pages',

        'pieces' => '//pieces',

        'public_note' => '//public_note',

        'fulfillment_note' => '//fulfillment_note',

        'internal_note_1' => '//internal_note_1',

        'internal_note_2' => '//internal_note_2',

        'internal_note_3' => '//internal_note_3',

        'statistics_note_1' => '//statistics_note_1',

        'statistics_note_2' => '//statistics_note_2',

        'statistics_note_3' => '//statistics_note_3',

        'requested' => '//requested',

        'physical_condition' => '//physical_condition',

        'temp_library' => '//temp_library',

        'temp_location' => '//temp_location',

        'temp_policy' => '//temp_policy',

        'copy_id' => '//copy_id',

        'inventory_date' => '//inventory_date',

        'inventory_number' => '//inventory_number',

        'inventory_price' => '//inventory_price',

    );

 

    // {{{ fluff


    function fluff()

    {

        $fields = array( # XXX: fill with the rest

            "pieces",

            "copy_id",

            "inventory_date",

            "inventory_number",

        );

        $xpath = new DomXpath($this->xml);

        $stem = $xpath->query("//item_data")[0];

        foreach($fields as $field) {

            $try = $xpath->query("//$field");

            if (sizeof($try) == 0) {

                # XXX add empty node with that name


                $node = $this->xml->createElement($field);

                $stem->appendChild($node);

            }

        }

    }

    // }}}


 

    // {{{ loadFromAlma (get)


    function loadFromAlma($mms_id, $holding_id, $item_pid)

    {

        global $grima;

        $this->xml = $grima->getItem($mms_id, $holding_id, $item_pid);

    }

    // }}}


 

    // {{{ loadFromAlmaX (get)


    function loadFromAlmaX($item_pid)

    {

        global $grima;

        $this->xml = $grima->getItem('X', 'X', $item_pid);

    }

    // }}}


 

    // {{{ loadFromAlmaBarcode (get)


    function loadFromAlmaBarcode($barcode)

    {

        global $grima;

        $this->xml = $grima->getItemBC($barcode);

    }

    // }}}


 

    // {{{ loadFromAlmaBCorX (get)


    function loadFromAlmaBCorX($id)

    {

        global $grima;

        if (preg_match("/^23.*/", $id)) { // item_pid


            // probably should know about suffix too


            $this->loadFromAlmaX($id);

        } else {

            $this->loadFromAlmaBarcode($id);

        }

    }

    // }}}


 

    // {{{ loadFromItemListNode


    function loadFromItemListNode($node)

    {

        $this->xml = new DomDocument();

        $this->xml->appendChild($this->xml->importNode($node, true));

    }

    // }}}


 

    // {{{ addToAlmaHolding (post)


    function addToAlmaHolding($mms_id, $holding_id)

    {

        global $grima;

        $this->mms_id = $mms_id;

        $this->holding_id = $holding_id;

        $this->xml = $grima->postItem($mms_id, $holding_id, $this->xml);

        return $this->xml;

    }

    // }}}


 

    // {{{ addToAlmaHoldingX (post)


    // XXX check this


    function addToAlmaHoldingX($holding_id)

    {

        $this->addToAlmaHolding('X', $holding_id);

        return $this->xml;

    }

    // }}}


 

    // {{{ updateAlma (put)


    function updateAlma()

    {

        global $grima;

        return $grima->putItem(

            $this['mms_id'],

            $this['holding_id'],

            $this['item_pid'],

            $this->xml

        );

    }

    // }}}


 

    // {{{ deleteFromAlma (delete)


    function deleteFromAlma($override = "false", $holdings = "retain")

    {

        global $grima;

        $grima->deleteItem($this['mms_id'], $this['holding_id'], $this['item_pid'], $override, $holdings);

    }

    // }}}


 

}

 

// }}}


 

// {{{ class ElectronicCollection


class ElectronicCollection extends AlmaObject


{

 

    public $xml;

    public $services = array();

 

 

    // {{{ ElectronicCollection -> el_address


    public $el_address = array( // XXX many more fields here


        'collection_id' => '//id',

        'id' => '//id',

        'public_name' => '//public_name',

    );

    // }}}


 

    // {{{ ElectronicCollection -> loadFromAlma (get)


    function loadFromAlma($collection_id)

    {

        global $grima;

        $this->xml = $grima->getElectronicCollection($collection_id);

        // $this['collection_id'] = $collection_id;


    }

    // }}}


 

    // {{{ ElectronicCollection -> updateAlma (put)


    function updateAlma()

    {

        global $grima;

        $this->xml = $grima->putElectronicCollection($this['collection_id'], $this->xml);

    }

    // }}}


 

    // {{{ ElectronicCollection -> getServices (get) XXX


    function getServices()

    {

        global $grima;

        $ret = $grima->getElectronicServices($this['collection_id']);

        $xpath = new DomXpath($ret);

        $eservices = $xpath->query('//electronic_services/electronic_service');

        foreach ($eservices as $service) {

            $service_id = $service->firstChild->nodeValue; // XXX really?


            $ser = new ElectronicService();

            $ser->loadFromServiceListNode($service);

            $this->services[] = $ser;

        }

    }

    // }}}


 

}

 

// }}}


 

// {{{ class ElectronicService


class ElectronicService extends AlmaObject


{

    public $number_of_portfolios;

 

    public $portfolios = array();

 

    public $el_address = array(

        'id' => '//id',

        'service_id' => '//id',

    );

 

    public $el_override = array();

 

    function __construct()

    {

        // load from template


    }

 

    function offsetSet($offset, $value)

    {

        if ($offset == "collection_id") {

            $this->el_override['collection_id'] = $value;

        } else {

            parent::offsetSet($offset, $value);

        }

    }

 

    // {{{ ElectronicService -> loadFromAlma (get)


    function loadFromAlma($collection_id, $service_id)

    {

        global $grima;

        $this->xml = $grima->getElectronicService($collection_id, $service_id);

        $this['collection_id'] = $collection_id;

    }

    // }}}


 

    // {{{ ElectronicService -> loadFromServiceListNode


    function loadFromServiceListNode($node)

    {

        $this->xml = new DomDocument();

        $this->xml->appendChild($this->xml->importNode($node, true));

        $xpath = new DomXPath($this->xml);

        $service_link = $xpath->query('//electronic_service')->item(0)->attributes['link']->nodeValue;

        preg_match('!/e-collections/(.*)/e-services/!', $service_link, $m);

        $this['collection_id'] = $m[1];

    }

 

    function retrieveAllPortfolios()

    {

        $curr_offset = 0;

        do {

            $retrieved = $this->getPortfolios(100, $curr_offset);

            $curr_offset += 100;

        } while ($retrieved == 100);

    }

 

    // {{{ ElectronicService -> getPortfolios


    /* mark full or brief? */


    // function retrievePortfolios($limit = 10, $offset = 0) { # RENAME


    function getPortfolios($limit = 10, $offset = 0)

    {

        global $grima;

        $ret = $grima->getElectronicPortfoliosForService($this['collection_id'], $this['service_id'], $limit, $offset);

        $xpath = new DOMXpath($ret);

        $ports = $xpath->query('//portfolio');

        foreach ($ports as $portnode) {

            $newport = new ElectronicPortfolio();

            $newport->loadFromPortfolioListNode($portnode);

            $this->portfolios[] = $newport;

        }

        return count($ports);

    }

 

    // }}}


 

    // {{{ ElectronicService -> deleteAllPortfolios - delete all portfolios from the bib


    function deleteAllPortfolios($bib_treat)

    {

        global $grima;

        while ($this->getPortfolios(100, 0)) {

            foreach ($this->portfolios as $portfolio) {

                $portfolio->deleteFromAlma($bib_treat);

            }

            $this->portfolios = array();

            sleep(2);

        }

    }

    // }}}


 

    /*


    function deleteAllPortfolios() { #XXX


        global $grima;


        # get portfolio list? or just ten at a time?


        $this->retrievePortfolios();


        while (sizeof($this->portfolios) > 0) {


            foreach ($this->portfolios as $portfolio) {


            print $portfolio['mms_id']->nodeValue; exit;


                #$portfolio->delete();


            }


        }


    }


    */


 

}

 

//}}}


//}}}


 

//{{{ class ElectronicPortfolio


class ElectronicPortfolio extends AlmaObject


{

    public $xml;

 

    // {{{ ElectronicPortfolio -> el_address


    public $el_address = array(

        'portfolio_id' => '//portfolio/id',

        'is_local' => '//is_local',

        'is_standalone' => '//is_standalone',

        'mms_id' => '//mms_id',

        'title' => '//title',

        'service' => '//service',

        'url' => '//url',

        'static_url' => '//static_url',

        'availability' => '//availability',

        'collection_id' => '//electronic_collection/id',

        'service_id' => '//electronic_collection/service',

        'material_type' => '//material_type',

        'url_type' => '//url_type',

        'public_note' => '//public_note',

        'proxy_enabled' => '//proxy_enabled',

        'proxy' => '//proxy',

        'library' => '//library',

        'po_line' => '//po_line'


    );

    // }}}


 

    // {{{ ElectronicPortfolio -> addToAlmaService


    function addToAlmaService($collection_id, $service_id)

    {

        global $grima;

        $ret = $grima->postElectronicPortfolio($collection_id, $service_id, $this->xml);

        return $ret;

    }

    // }}}


 

    // {{{ ElectronicPortfolio -> addToAlmaBib


    function addToAlmaBib($mms_id)

    {

        global $grima;

        $ret = $grima->postElectronicPortfolioOnBib($mms_id, $this->xml);

        return $ret;

    }

    // }}}


 

    // {{{ ElectronicPortfolio -> loadFromAlma


    function loadFromAlma($portfolio_id)

    {

        global $grima;

        $this->xml = $grima->getElectronicPortfolio('X', 'X', $portfolio_id);

    }

 

    function loadFromAlmaX($portfolio_id)

    {

        global $grima;

        $this->xml = $grima->getElectronicPortfolio('X', 'X', $portfolio_id);

    }

    // }}}


 

    // {{{ ElectronicPortfolio -> loadFromPortfolioListNode


    function loadFromPortfolioListNode($node)

    {

        $this->xml = new DomDocument();

        $this->xml->appendChild($this->xml->importNode($node, true));

    }

    // }}}


 

    // {{{ ElectronicPortfolio -> updateAlma


    function updateAlma()

    {

        global $grima;

        $this->xml = $grima->putElectronicPortfolioOnBib($this['mms_id'], $this['portfolio_id'], $this->xml);

    }

    // }}}


 

    // {{{ ElectronicPortfolio -> deleteFromAlma


    function deleteFromAlma($bib_treat = "retain")

    {

        // accept a variable?


        global $grima;

        $mms_id = $this['mms_id'];

        $grima->deleteElectronicPortfolio(

            'X', 'X',

            $this['portfolio_id']

        );

        if ($bib_treat == "delete") {

            $bib = new Bib();

            $bib->loadFromAlma($mms_id);

            sleep(2);

            if (! $bib->hasInventory()) {

                if ($bib->linkedToCZ()) {

                    print "LINKED TO CZ";

                    $bib->unlinkFromCZ();

                    exit;

                } else {

                    $bib->deleteFromAlma();

                }

            }

        }

    }

    // }}}


 

    // {{{ ElectronicPortfolio -> activate


    function activate()

    {

        $this['availability'] = 11;

    }

    // }}}


 

    // {{{ ElectronicPortfolio -> deactivate


    function deactivate()

    {

        $this['availability'] = 10;

    }

    // }}}


 

}

 

// }}}


 

// {{{ class Set


class Set extends AlmaObject


{

    public $xml;

    public $members = array();

 

    /*


    public $id;


    public $type; # itemized or logical


    public $name;


    public $private;


    public $active;


    public $size; # number of members


    */


 

    // {{{ Set -> el_address


    public $el_address = array(

        'set_id' => '//set/id',

        'id' => '//set/id',

        'name' => '//set/name',

        'description' => '//set/description',

        'type' => '//set/type',

        'content' => '//content',

        'private' => '//private',

        'status' => '//status',

        'status_date' => '//status_date',

        'note' => '//note',

        'created_by' => '//created_by',

        'created_date' => '//created_date',

        'query' => '//query',

        'number_of_members' => '//number_of_members',

        'additional_info' => '//additional_info',

    );

    // }}}


 

    // {{{ Set -> addToAlma (post) - adds the Set to Alma


    function addToAlma()

    {

        global $grima;

        $this->xml = $grima->postSet($this->xml);

    }

    // }}}


 

    // {{{ Set -> loadFromAlma


    function loadFromAlma($set_id)

    {

        global $grima;

        $this->xml = $grima->getSet($set_id);

    }

    // }}}


 

    // {{{ Set -> createFromImport


    function createFromImport($job_id, $population)

    {

        global $grima;

        $this->xml = $grima->createSetFromImport($job_id, $population);

    }

    // }}}


 

    // {{{ Set -> runOnElements


    function runOnElements($function, $args = array(), $filter = null, $filter_args = array())

    {

        global $grima;

        $xml = $grima->getSetMembers($this['set_id'], 0);

        $xpath = new DomXpath($xml);

        $this->size = $xpath->query("//members")->item(0)->getAttribute("total_record_count");

        $limit = $this->size;

        for ($j = 0; $j < ceil($limit/100); $j++) { // how many queries


            $xml = $grima->getSetMembers($this['id'], 100, $j*100);

            $xpath = new DomXpath($xml);

            foreach ($xpath->query("//member") as $member) {

                $id = $member->childNodes[0]->nodeValue;

                if (!isset($filter) or ($filter($id, $filter_args))) {

                    $function($id, $args);

                }

            }

        }

 

    }

    // }}}


 

    function getMembers($limit = -1)

    {

        // put in $members


        // limit -1 means all


        global $grima;

        if ($limit == -1) { // get them all


            $xml = $grima->getSetMembers($this['set_id'], 0);

            $xpath = new DomXpath($xml);

            $this->size = $xpath->query("//members")->item(0)->getAttribute("total_record_count");

            $limit = $this->size;

        }

 

        for ($j = 0; $j < ceil($limit/100); $j++) { // how many queries


            $xml = $grima->getSetMembers($this['id'], 100, $j*100);

            $xpath = new DomXpath($xml);

            foreach ($xpath->query("//member") as $member) {

                $this->members[] = new SetMember(

                    $member->childNodes[0]->nodeValue,

                    $member->childNodes[1]->nodeValue

                );

            }

        }

    }

 

    // {{{ Set -> deleteFromAlma (delete)


    function deleteFromAlma()

    {

        global $grima;

        $grima->deleteSet($this['set_id']);

    }

    // }}}


 

    // {{{ Set -> addMember (delete)


    function addMember($id)

    {

        $frag = "<member><id>$id</id></member>";

        $source = new DOMDocument();

        $source->loadXML($frag);

 

        $xpath = new DomXpath($this->xml);

        $members = $xpath->query('//members')->item(0);

        $members->appendChild($this->xml->importNode($source->documentElement, true));

 

    }

    // }}}


 

    // {{{ Set -> appendInAlma ()


    function appendInAlma($setToAppend)

    {

        global $grima;

        $grima->postSetManageMembers(

            $this['set_id'], null, 'add_members',

            $setToAppend->xml

        );

    }

    // }}}


 

    // {{{ Set -> removeAllMembersInAlma ()


    function removeAllMembersInAlma()

    {

        global $grima;

        $emptyset = new Set();

        $emptyset->addMember('9941266686802636'); /* hack */


        $grima->postSetManageMembers(

            $this['set_id'], null, 'replace_members',

            $emptyset->xml

        );

        $grima->postSetManageMembers(

            $this['set_id'], null, 'delete_members',

            $emptyset->xml

        );

    }

 

}

 

// }}}


 

// }}}


 

// {{{ class SetMember


class SetMember


{

    public $id;

    public $description;

 

    function __construct($id, $description)

    {

        $this->id = $id;

        $this->description = $description;

    }

}

 

// }}}


 

// {{{ class Library


class Library extends AlmaObject


{

    public $el_address = array(

        'code' => '//code',

        'path' => '//path',

        'name' => '//name',

        'resource_sharing' => '//resource_sharing',

    );

 

    // {{{ Library -> loadFromAlma


    function loadFromAlma($code)

    {

        global $grima;

        $this->xml = $grima->getLibrary($code);

    }

    // }}}


 

    // {{{ Library -> getAllLibraries


    public static function getAllLibraries()

    {

        global $grima;

        $xml = $grima->getAllLibraries();

        $xpath = new DomXpath($xml);

        $codes = $xpath->query('//library/code');

        $libarray = array();

        foreach ($codes as $code) {

            $lib = new Library();

            $lib->loadFromAlma($code->nodeValue);

            $libarray[] = $lib;

        }

        return $libarray;

    }

    // }}}


 

    // {{{ Library -> getOneLibrary


    public static function getOneLibrary($otherthan = array())

    {

        global $grima;

        $xml = $grima->getAllLibraries();

        $xpath = new DomXpath($xml);

        $codes = $xpath->query('//library/code');

 

        foreach ($codes as $code) {

            if (! in_array($code, $otherthan)) {

                $lib = new Library();

                $lib->loadFromAlma($code);

                return $lib;

            }

        }

        throw new Exception("No libraries found.");

    }

    // }}}


 

    // {{{ Library -> getAllLocations


    public function getAllLocations()

    {

        global $grima;

        $xml = $grima->getAllLocations($this['code']);

        $xpath = new DomXpath($xml);

        $codes = $xpath->query('//location/code');

        $locarray = array();

        foreach ($codes as $code) {

            $loc = new Location();

            $loc->loadFromAlma($this['code'], $code->nodeValue);

            $locarray[] = $loc;

        }

        return $locarray;

    }

    // }}}


 

    // {{{ Library -> getOneLocation


    public function getOneLocation($otherthan = array())

    {

        global $grima;

        $xml = $grima->getAllLocations($this['code']);

        $xpath = new DomXpath($xml);

        $codes = $xpath->query('//location/code');

        foreach ($codes as $code) {

            if (! in_array($code->nodeValue, $otherthan)) {

                $loc = new Location();

                $loc->loadFromAlma($this['code'], $code->nodeValue);

                return $loc;

            }

        }

        throw new Exception("No locations found.");

    }

    // }}}


 

    // {{{ Library -> getOneLibraryLocation


    public static function getOneLibraryLocation($otherthan = array())

    {

        global $grima;

 

        $xml = $grima->getAllLibraries();

        $xpath = new DomXpath($xml);

        $library_codes = $xpath->query('//library/code');

 

        foreach ($library_codes as $library_code) {

            $lib = new Library();

            $lib->loadFromAlma($library_code->nodeValue);

            $arr = array();

            foreach ($otherthan as $other) {

                if ($other[0] == $library_code->nodeValue) {

                    $arr[] = $other[1];

                }

            }

            try {

                $loc = $lib->getOneLocation($arr);

                return $loc;

            } catch (Exception $e) {

                continue;

            }

        }

        throw new Exception("No suitable library/location found.");

    }

    // }}}


 

}

 

// }}}


 

// {{{ class Location


class Location extends AlmaObject


{

 

    public $el_override_fields = array('library_code','flag');

 

    public $el_address = array(

        'code' => '//code',

        'name' => '//name',

        'external_name' => '//external_name',

        'type' => '//type',

        'remote_storage' => '//remote_storage',

        'map' => '//map',

        'suppress_from_publishing' => '//suppress_from_publishing',

        'fulfillment_unit' => '//fulfillment_unit',

        'accession_placement' => '//accession_placement',

        'call_number_type' => '//call_number_type',

    );

 

    function offsetSet($offset, $value)

    {

        if (in_array($offset, $this->el_override_fields)) {

            $this->el_override[$offset] = $value;

        } else {

            parent::offsetSet($offset, $value);

        }

        /*


        if ($offset == "library_code") {


            $this->el_override['library_code'] = $value;


        } else {


            parent::offsetSet($offset,$value);


        }


        */


    }

 

    // {{{ Location -> loadFromAlma


    function loadFromAlma($libraryCode, $locationCode)

    {

        global $grima;

        $this->xml = $grima->getLocation($libraryCode, $locationCode);

        $this['library_code'] = $libraryCode;

    }

    // }}}


 

}

 

// }}}


 

// {{{ class Job


class Job extends AlmaObject


{

    public $el_address = array(

        'id' => '//id',

        'name' => '//name',

        'description' => '//description',

        'type' => '//type',

        'category' => '//category',

        'content' => '//content',

        'schedule' => '//schedule',

        'creator' => '//creator',

        'next_run' => '//next_run',

        'related_profile' => '//related_profile',

        'additional_info' => '//additional_info',

    );

 

    // {{{ Job -> addParameter


    function addParameter($name, $value)

    {

        $frag = "<parameter><name>$name</name><value>$value</value></parameter>";

        $source = new DOMDocument();

        $source->loadXML($frag);

 

        $xpath = new DomXpath($this->xml);

        $members = $xpath->query('//parameters')->item(0);

        $members->appendChild($this->xml->importNode($source->documentElement, true));

    }

    // }}}


 

    // {{{ Job -> runInAlma


    function runInAlma()

    {

        global $grima;

        $grima->postJob($this['id'], 'run', $this->xml);

    }

    // }}}


 

}

 

// }}}


 

// {{{ class AnalyticsReport


class AnalyticsReport extends AlmaObject


{

 

    public $path;

    public $filter;

    public $reportXml;

    public $rows = array();

 

    // {{{ AnalyticsReport -> runReport


    function runReport($filter_params = array(), $limit = -1, $token = "")

    {

        global $grima;

        if (isset($this->filter)) {

            $passfilter = $this->filter;

            foreach ($filter_params as $k => $v) {

                $passfilter = str_replace('{'.$k.'}', urlencode($v), $passfilter);

            }

        } else {

            $passfilter = null;

        }

 

        if ($limit == -1) { $limit = 1000;

        }    // no limit


        if ($limit < 25) { $limit = 25;

        }       // must be in chunks of 25


        $this->reportXml = $grima->getAnalytics($this->path, $passfilter, $limit, $token);

 

        $xpath = new DomXpath($this->reportXml);

        $xpath->registerNamespace("x", "urn:schemas-microsoft-com:xml-analysis:rowset");

 

        $rows = $xpath->query('//x:Row');

        foreach ($rows as $row) {

            $newrow = array();

            $cols = $xpath->query("./*[contains(name(),'Column')]", $row);

            foreach ($cols as $col) {

                $newrow[] = $col->nodeValue;

            }

            $this->rows[] = $newrow;

        }

    }

 

    // }}}


 

 

}

 

// }}}


 

// {{{ class GrimaDB


 

// {{{ shared


function tableExists($pdo, $table)

{

    $table_esc = "\"" . preg_replace("/\"/", "\"\"", $table) . "\"";

    try {

        $result = $pdo->query("SELECT 1 FROM $table_esc LIMIT 1");

    } catch (Exception $e) {

        // We got an exception == table not found


        return false;

    }

    // Result is either boolean FALSE (no table found) or PDOStatement Object (table found)


    return $result !== false;

}

 

// }}}


 

// {{{ class GrimaDB


class GrimaDB implements ArrayAccess, IteratorAggregate

{

 

    private static $db = false;

    private $info;      // array


 

    static function init()

    {

        return self::getDb();

    }

 

    static function isEmpty()

    {

        $db = self::getDb();

        if ($db === 'stateless') {

            return true;

        }

        $result = $db->query('SELECT COUNT(*) as c FROM institutions');

        if ($result) {

            foreach ($result as $row) {

                if ($row['c']>0) { return false;

                }

            }

        }

        return true;

    }

 

    static function isStateless()

    {

        $db = self::getDb();

        return $db === 'stateless';

    }

 

    protected static function getDb()

    {

        if (!self::$db) {

            try {

                $db_url = getenvWithFileFallbackAndDefault('DATABASE_URL', '');

                $db_user = getenvWithFileFallbackAndDefault('DATABASE_USER', '');

                $db_pass = getenvWithFileFallbackAndDefault('DATABASE_PASS', '');

                if ($db_user && $db_pass) {

                    self::$db = new PDO($db_url, $db_user, $db_pass);

                } else {

                    self::$db = new PDO($db_url);

                }

                if (!tableExists(self::$db, "institutions")) {

                    self::$db->exec("CREATE TABLE institutions ( institution VARCHAR(100) PRIMARY KEY, apikey VARCHAR(100), server VARCHAR(100) )");

                }

                if (!tableExists(self::$db, "users")) {

                    self::$db->exec("CREATE TABLE users ( institution VARCHAR(100), username VARCHAR(100), password VARCHAR(255), isAdmin INTEGER )");

                }

            } catch (Exception $e) {

                self::$db = 'stateless';

            }

        }

        return self::$db;

    }

 

    protected function getPasswordAlgorithm()

    {

        return defined("PASSWORD_ARGON2I") ? constant("PASSWORD_ARGON2I") : PASSWORD_DEFAULT;

    }

 

    static function getInstitutions()

    {

        $ret = array();

        try {

            $db = self::getDb();

            if ($db === 'stateless') {

                return $ret;

            }

            $result = $db->query('SELECT institution FROM institutions');

            foreach ($result as $row) {

                $ret[] = $row['institution'];

            }

        } catch (Exception $e) {

        }

        return $ret;

    }

 

    function offsetExists($offset)

    {

        return isset($this->info[$offset]);

    }

 

    function offsetGet($offset)

    {

        return isset($this->info[$offset]) ? $this->info[$offset] : '';

    }

 

    function offsetSet($offset, $value)

    {

        $this->info[$offset] = $value;

    }

 

    function offsetUnset($offset)

    {

        unset($this->info[$offset]);

    }

 

    function getIterator()

    {

        return new ArrayIterator($this->info);

    }

 

}

 

// }}}


 

// {{{ class GrimaInstitution


class GrimaInstitution extends GrimaDB


{

    public function addToDB()

    {

        $db = $this->getDb();

        if ($db === 'stateless') {

            throw new Exception("No database has been specified. Grima cannot add an institution until it knows where to add it.");

        }

        $query = $db->prepare('INSERT INTO institutions(institution,apikey,server) VALUES (:institution,:apikey,:server)');

        if (!$query) {

            $errorCode = $db->errorCode();

            $errorInfo = $db->errorInfo();

            throw new Exception(

                "Could not even prepare to insert into institution database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

        $success = $query->execute(

            array(

            'institution' => $this['institution'],

            'apikey' => $this['apikey'],

            'server' => $this['server'],

            )

        );

        if (!$success) {

            $errorCode = $query->errorCode();

            $errorInfo = $query->errorInfo();

            throw new Exception(

                "Could not insert into user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

    }

}

 

// }}}


 

// {{{ class GrimaUser


class GrimaUser extends GrimaDB


{

    public static function FromArray($data)

    {

        $user = new GrimaUser();

        foreach ($data as $key => $val) {

            $user[$key] = $val;

        }

        return $user;

    }

 

    public static function LookupUser($username, $institution = '', $password = false)

    {

        $db = self::getDb();

        if ($db === 'stateless') {

            return false;

        }

        $query = $db->prepare(

            'SELECT * ' .

            'FROM institutions NATURAL JOIN users '.

            'WHERE institution=:institution '.

            'AND username=:username'


        );

        $success = $query->execute(

            array(

            'institution' => $institution,

            'username' => $username,

            )

        );

        if ($success) {

            $row = $query->fetch(PDO::FETCH_ASSOC);

            if ($row===false) { return false;

            }

            $user = GrimaUser::FromArray($row);

            if (($password !== false) && ($user['password']!='')) {

                if (!password_verify($password, $user['password'])) { return false;

                }

                if (password_needs_rehash($user['password'], $user->getPasswordAlgorithm())) {

                    $user['password'] = $password;

                    $user->updateDB();

                }

            }

            unset($user['password']);

            return $user;

        } else {

            $errorCode = $query->errorCode();

            $errorInfo = $query->errorInfo();

            throw new Exception(

                "Could not select from user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

    }

 

    public static function RenameUser($username, $institution, $newusername)

    {

        $db = self::getDb();

        if ($db === 'stateless') {

            throw new Exception("No database has been specified. Grima cannot save changes to users if it does not where to save them.");

        }

        $query = $db->prepare(

            'UPDATE users ' .

            'SET username=:newusername ' .

            'WHERE institution=:institution '.

            'AND username=:username'


        );

        $success = $query->execute(

            array(

            'institution'   => $institution,

            'username'      => $username,

            'newusername'   => $newusername,

            )

        );

        if ($success) {

            return true;

        } else {

            $errorCode = $query->errorCode();

            $errorInfo = $query->errorInfo();

            throw new Exception(

                "Could not update user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

    }

 

    public static function ResetPassword($username, $institution, $password)

    {

        $db = self::getDb();

        if ($db === 'stateless') {

            throw new Exception("No database specified. Grima cannot save changes to users if it doesn't know where to save them.");

        }

        $query = $db->prepare(

            'UPDATE users ' .

            'SET password=:password ' .

            'WHERE institution=:institution '.

            'AND username=:username'


        );

        $passwordHash = password_hash($password, self::getPasswordAlgorithm());

        $success = $query->execute(

            array(

            'institution'   => $institution,

            'username'      => $username,

            'password'      => $passwordHash,

            )

        );

        if ($success) {

            return true;

        } else {

            $errorCode = $query->errorCode();

            $errorInfo = $query->errorInfo();

            throw new Exception(

                "Could not update user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

    }

 

    public static function GetCurrentUser()

    {

        if (!isset($_SESSION)) { return false;

        }

        return GrimaUser::FromArray($_SESSION);

    }

 

    public static function SetCurrentUser($username, $password, $institution = '')

    {

        global $grima;

        $user = GrimaUser::LookupUser($username, $institution, $password);

        if ($user !== false) {

            $grima->sessionSave($user);

        } else {

            return false;

        }

    }

 

    public static function LogoutCurrentUser()

    {

        global $grima;

        $grima->sessionDestroy();

    }

 

    function addToDB()

    {

        $db = $this->getDb();

        if ($db === 'stateless') {

            throw new Exception("No database specified. Grima cannot add a user to the database, if it doesn't where to add it.");

        }

        $query = $db->prepare('INSERT INTO users( username, password, institution, isAdmin ) VALUES (:username, :password, :institution, :isAdmin)');

        if (!$query) {

            $errorCode = $db->errorCode();

            $errorInfo = $db->errorInfo();

            throw new Exception(

                "Could not even prepare to insert into user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

        $success = $query->execute(

            array(

            'username' => $this['username'],

            'password' => password_hash($this['password'], $this->getPasswordAlgorithm()),

            'institution' => $this['institution'],

            'isAdmin' => $this['isAdmin'],

            )

        );

        if (!$success) {

            $errorCode = $query->errorCode();

            $errorInfo = $query->errorInfo();

            throw new Exception(

                "Could not insert into user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

    }

 

    function updateDB()

    {

        $db = $this->getDb();

        if ($db === 'stateless') {

            throw new Exception("No database specified. Grima cannot save changes to users if it doesn't know where to save them.");

        }

        $query = $db->prepare('UPDATE users SET isAdmin=:isAdmin, password=:password WHERE username=:username AND institution=:institution');

        if (!$query) {

            $errorCode = $db->errorCode();

            $errorInfo = $db->errorInfo();

            throw new Exception(

                "Could not even prepare to update user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

        $success = $query->execute(

            array(

            'username'  => $this['username'],

            'password'  => password_hash($this['password'], $this->getPasswordAlgorithm()),

            'institution' => $this['institution'],

            'isAdmin'   => $this['isAdmin'],

            )

        );

        if (!$success) {

            $errorCode = $query->errorCode();

            $errorInfo = $query->errorInfo();

            throw new Exception(

                "Could not update user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

    }

 

    function deleteFromDB()

    {

        $db = $this->getDb();

        if ($db === 'stateless') {

            throw new Exception("No database specified. Grima cannot save changes to users if it doesn't know where to save them.");

        }

        $query = $db->prepare('DELETE FROM users WHERE username=:username AND institution=:institution');

        if (!$query) {

            $errorCode = $db->errorCode();

            $errorInfo = $db->errorInfo();

            throw new Exception(

                "Could not even prepare to delete from user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

        $success = $query->execute(

            array(

            'username' => $this['username'],

            'institution' => $this['institution'],

            )

        );

        if (!$success) {

            $errorCode = $query->errorCode();

            $errorInfo = $query->errorInfo();

            throw new Exception(

                "Could not delete from user database: [$errorCode] {$errorInfo[0]} {$errorInfo[2]}"


            );

        }

    }

}

 

// }}}


 

// }}}


 

// {{{ class EncryptedCookieSession


 

class EncryptedCookieSession


implements SessionHandlerInterface

{

 

    private $save_path;

    private $session_name;

    private $session_key;

    private $last_read;

 

    public function __construct($key)

    {

        $this->session_key = $key;

        $this->last_read = "Not This";

    }

 

    public function open($save_path, $session_name)

    {

        $this->save_path = $save_path;

        $this->session_name = $session_name;

        //error_log("session_open($save_path,$session_name)");


        return true;

    }

 

    public function close()

    {

        //error_log("session_close()");


        return true;

    }

 

    public function destroy($session_id)

    {

        //error_log("sessionDestroy($session_id)");


        $params = session_get_cookie_params();

        $params['expires'] = time() - 42000;

        unset($params['lifetime']);

        setcookie($this->session_name, '', $params);

        return true;

    }

 

    public function gc($maxlifetime)

    {

        //error_log("session_gc($maxlifetime)");


        return true;

    }

 

    public function read($session_id)

    {

        //error_log("session_read($session_id)");


        $nonce_ciphertext_b64 = isset($_COOKIE[$this->session_name]) ? $_COOKIE[$this->session_name] : "";

        if ($nonce_ciphertext_b64) {

            $nonce_ciphertext = base64_decode($nonce_ciphertext_b64);

            if (strlen($nonce_ciphertext)>24+16) {

                $nonce = substr($nonce_ciphertext, 0, 24);

                $ciphertext = substr($nonce_ciphertext, 24);

                $plaintext = sodium_crypto_secretbox_open($ciphertext, $nonce, $this->session_key);

                // error_log("session_read -> $plaintext");


                $this->last_read = $plaintext;

                return $plaintext ?: "";

            } else {

                error_log("cookie too short: $nonce_ciphertext_b64");

            }

        } else {

            //error_log("cookie not set or empty");


        }

        return "";

    }

 

    public function write($session_id, $session_data)

    {

        // error_log("session_write($session_id,$session_data)");


        if (!$session_data) { return true;

        }

        if ($this->last_read == $session_data) { return true;

        }

        $nonce = random_bytes(24);

        $ciphertext = sodium_crypto_secretbox($session_data, $nonce, $this->session_key);

        $nonce_ciphertext = $nonce.$ciphertext;

        $nonce_ciphertext_b64 = base64_encode($nonce_ciphertext);

        $options = session_get_cookie_params();

        if (isset($options['expires']) && $options['expires']) {

            $options['expires'] += time();

        }

        unset($options['lifetime']);

        setcookie($this->session_name, $nonce_ciphertext_b64, $options);

        return true;

    }

 

}

 

// }}}


 

$grima = new Grima();

 

/* vim: set foldmethod=marker noexpandtab shiftwidth=4 tabstop=4: */