sdr/search/SDRSearchService.php5

<?php
class SDRSearchService extends XSI {
    private $lastResponse = null;
    private $lastRequest = null;

    private $defaultOptions = array();

    // public only because SDRAlignmentList needs to know
    public static $WITH_ANCESTRY = false;

    public function setDefault($which, $what) {
        $this->defaultOptions[$which] = $what;
    }

    public function getDefault($which) {
        if(isset($this->defaultOptions[$which]))
            return $this->defaultOptions[$which];
        else
            return null;
    }

    private function mergeDefaults($options) {
        return array_merge($this->defaultOptions, $options);
    }

    private function processStandardOptions($req, $options, $type = SDRContract::REQUEST_TYPE_ADVANCED) {
        $req->setMethod(SDRContract::METHOD_FIND);
        $req->setType($type);
        if(isset($options['projectFilter']))
            $req->setProjectFilter($options['projectFilter']);
        if(isset($options['startingResult']))
            $req->setStartingResult($options['startingResult']);
        if(isset($options['numResultsPerPage']))
            $req->setNumResultsPerPage($options['numResultsPerPage']);
    }

    private function processDataOptions($req, $options) {
        if(isset($options['extra'])) {
            if(in_array('metadata', $options['extra']))
                $req->addDataSection(array(SDRContract::DATA_METADATA));
            if(in_array('relationships', $options['extra']))
                $req->addDataSection(array(SDRContract::DATA_RELATIONSHIPS));
            if(in_array('alignments', $options['extra']))
                $req->addDataSection(array(SDRContract::DATA_ALIGNMENTS));
        }
        if(isset($options['modeFilter']))
            $req->addConstraints(array('modeFilter' => $options['modeFilter']));
        if(isset($options['alignmentMode']))
            $req->addConstraints(array('alignmentMode' => $options['alignmentMode']));
        if(isset($options['state']))
            $req->setState($options['state']);
    }

    private function loadXML($xml) {
        $oldLUIE = libxml_use_internal_errors(true);
        $xml = @simplexml_load_string(utf8_encode($xml));
        $errors = libxml_get_errors();
        libxml_use_internal_errors($oldLUIE);
        if(!$xml || count($errors) > 0) {
            $html = "<ul>";
            foreach($errors as $e) {
                $html .= "<li>On line <b>$e->line</b>: $e->message</li>";
            }
            $html .= "</ul>";
            $this->setError($html);
            return false;
        }
        return $xml;
    }

    public function query($request) {
        $url = $request->buildQueryURL();
        $XMLData = $request->getXMLData();
        $key = $request->getKey();
        $result = self::queryURL($url, $XMLData, $key);
        return utf8_encode($result);
    }

    public function getResource($id, $options = array()) {
        STimer::start('getResource');
        $options = $this->mergeDefaults($options);
        $req = new SDRServiceRequest();
        $this->processStandardOptions($req, $options);
        $this->processDataOptions($req, $options);
        $req->addConstraints(array('cserdId' => $id));
        $this->lastRequest = $req;

        $results = $this->query($req);
        if(isset($options['asXML']) && $options['asXML']) {
            $xml = $this->loadXML($results);
            if(!$xml)
                return false;
            $this->lastResponse = $xml;
            return $this->lastResponse->SearchResults->resources[0];
        }

        if(isset($options['withAncestry']) && $options['withAncestry'])
            self::$WITH_ANCESTRY = true;
        else
            self::$WITH_ANCESTRY = false;

        $response = new SDRResourceResponse($results, $req);

        $this->lastResponse = $response;
        //var_dump($response);
        if(count($response->SearchResults->resources) == 0)
            return null;

        STimer::end('getResource');
        return $response->SearchResults->resources[0];
    }


    public function getResourceResponse($request) {
        return (new SDRResourceResponse(self::query($request), $request));
    }

    public function getByMetadata($constraints, $options = array()) {
        STimer::start('getByMetadata');
        $options = $this->mergeDefaults($options);
        $req = new SDRServiceRequest();
        $this->processStandardOptions($req, $options);
        $this->processDataOptions($req, $options);
        $req->addConstraints($constraints);
        $this->lastRequest = $req;

        $results = $this->query($req);
        if(isset($options['asXML']) && $options['asXML']) {
            $xml = $this->loadXML($results);
            if(!$xml)
                return false;
            $this->lastResponse = $xml;
            return $this->lastResponse->SearchResults->SDRResource;
        }

        if(isset($options['withAncestry']) && $options['withAncestry'])
            self::$WITH_ANCESTRY = true;
        else
            self::$WITH_ANCESTRY = false;

        if ($results == false)
            return false;
        $response = new SDRResourceResponse($results, $req);

        $this->lastResponse = $response;

        STimer::end('getByMetadata');
        return $response->SearchResults->resources;
    }

    // get all resources aligned to a tsd node
    // node type, node id
    public function getAlignedTo($nodeType, $nodeId, $options = array()) {
        STimer::start('getAlignedTo');
        $options = $this->mergeDefaults($options);
        $req = new SDRServiceRequest();
        $this->processStandardOptions($req, $options);
        $this->processDataOptions($req, $options);
        $req->addConstraints(array('alignedTo' => "$nodeType,$nodeId"));
        $this->lastRequest = $req;

        $results = $this->query($req);
        if(isset($options['asXML']) && $options['asXML']) {
            $xml = $this->loadXML($results);
            if(!$xml)
                return false;
            $this->lastResponse = $xml;
            return $this->lastResponse->SearchResults->SDRResource;
        }

        if(isset($options['withAncestry']) && $options['withAncestry'])
            self::$WITH_ANCESTRY = true;
        else
            self::$WITH_ANCESTRY = false;

        $response = new SDRResourceResponse($results, $req);

        $this->lastResponse = $response;

        STimer::end('getAlignedTo');
        return $response->SearchResults->resources;
    }

    public function getRelatedTo($cserdId, $options = array()) {
        STimer::start('getRelatedTo');
        $options = $this->mergeDefaults($options);
        $req = new SDRServiceRequest();
        $this->processStandardOptions($req, $options);
        $this->processDataOptions($req, $options);
        $req->addConstraints(array('relatedTo' => $cserdId));
        $this->lastRequest = $req;

        $results = $this->query($req);
        if(isset($options['asXML']) && $options['asXML']) {
            $xml = $this->loadXML($results);
            if(!$xml)
                return false;
            $this->lastResponse = $xml;
            return $this->lastResponse->SearchResults->SDRResource;
        }

        if(isset($options['withAncestry']) && $options['withAncestry'])
            self::$WITH_ANCESTRY = true;
        else
            self::$WITH_ANCESTRY = false;

        $response = new SDRResourceResponse($results, $req);

        $this->lastResponse = $response;

        STimer::end('getRelatedTo');
        if($response->SearchResults)
            return $response->SearchResults->resources;
        else
            return false;
    }

    // i.e., all resource that have standards alignments (at all)
    // ?type=advanced&withAlignments=dictionary,standards,etc.
    public function getWithAlignments($types, $options = array()) {
        STimer::start('getWithAlignments');
        $options = $this->mergeDefaults($options);
        $req = new SDRServiceRequest();
        $this->processStandardOptions($req, $options);
        $this->processDataOptions($req, $options);
        $req->addConstraints(array('withAlignments' => implode(',', $types)));
        $this->lastRequest = $req;

        $results = $this->query($req);
        if(isset($options['asXML']) && $options['asXML']) {
            $xml = $this->loadXML($results);
            if(!$xml)
                return false;
            $this->lastResponse = $xml;
            return $this->lastResponse->SearchResults->SDRResource;
        }

        if(isset($options['withAncestry']) && $options['withAncestry'])
            self::$WITH_ANCESTRY = true;
        else
            self::$WITH_ANCESTRY = false;

        $response = new SDRResourceResponse($results, $req);

        $this->lastResponse = $response;

        STimer::end('getWithAlignments');
        return $response->SearchResults->resources;
    }

    // get an alignments tree -- could do by just using the TSD API directly
    // implement later
    public function getAlignments($options = array()) {
        $this->setError("getAlignments() is not implemented yet; use TSD API instead");
        return null;
    }

    public function getRelationships($options = array()) {
        $this->setError("getRelationships() is not implemented yet; use TSD API instead");
        return null;
    }

    // specifiy a field -- for which you want the vocabulary
    public function getVocabulary($field, $options = array()) {
        STimer::start('getVocabulary');
        $options = $this->mergeDefaults($options);
        $req = new SDRServiceRequest();
        $req->usePreset(SDRServiceRequest::PRESET_VOCAB, array('field' => $field));
        $this->lastRequest = $req;

        $results = $this->query($req);
        if(isset($options['asXML']) && $options['asXML']) {
            $xml = $this->loadXML($results);
            if(!$xml)
                return false;
            $this->lastResponse = $xml;
            return $this->lastResponse->SearchResults->values;
        }

        $response = new SDRVocabResponse($results, $req);

        $this->lastRequest = $req;
        $this->lastResponse = $response;

        STimer::end('getVocabulary');
        return $response->SearchResults->values;
    }

    public function getLastRequest() {
        return $this->lastRequest;
    }

    public function getLastResponse() {
        return $this->lastResponse;
    }

    protected static function queryURL($url, $XMLData = null, $key = null) {
        $result = parent::queryURL($url, $XMLData, $key);
        $xml = utf8_encode($result);
        $xmlobj = @simplexml_load_string($xml);
        if (!$xmlobj) {
            self::setStaticError('Invalid response from search service URL ' . $url);
            return false;
        }
        if (isset($xmlobj->error)) {
            self::setStaticError('Error from server: ' . $xmlobj->error->asXML());
            return false;
        }
        return $result;
    }
}
?>

---