$datastream = islandora_datastream_load($dsid, $object);

where $dsid is the datastream identifier as a string, and $object is either an object PID or a loaded Fedora object.

This loads the datastream as a FedoraDatastream object. From there, it can be manipulated using the following properties and methods:where $dsid is the datastream identifier as a string, and $object is a loaded Fedora object.

Properties

Methods

Iterating over all of an object's datastreams

Since they exist on an object as an array, datastreams can be iterated over using standard array iteration methods, e.g.:

foreach ($object as $datastream) {
  strtoupper($datastream->id);
  $datastream->label = "new label";
  $datastream_content = $datastream->getContent();
}

Example of creating or updating a datastream

$dsid = 'DSID';
// Before we do anything, check if the datastream exists. If it does, load it; otherwise construct it.
// The easiest way to do this, as opposed to a string of cases or if/then/elses, is the ternary operator, e.g.
// $variable = isThisThingTrueOrFalse($thing) ? setToThisIfTrue() : setToThisIfFalse();
$datastream = isset($object[$dsid]) ? $object[$dsid] : $object->constructDatastream($dsid);
$datastream->label = 'Datastream Label';
$datastream->mimeType = 'datastream/mimetype';
$datastream->setContentFromFile('path/to/file');
// There's no harm in doing this if the datastream is already ingested or if the object is only constructed.
$object->ingestDatastream($datastream);
// If the object IS only constructed, ingesting it here also ingests the datastream.
$repository->ingestObject($object);

Creating new objects and datastreams

When using Tuque, Fedora objects and datastreams must first be constructed as PHP objects before being ingested into Fedora. Un-ingested, PHP-constructed Fedora objects and datastreams function nearly identically to their ingested counterparts, as far as Tuque is concerned, with only a few exceptions noted in the properties and methods tables below.

Constructing and ingesting an object

 $object = $repository->constructObject($pid); // $pid may also be a namespace.
/**
 * Here, you can manipulate the constructed object using the properties and methods described above.
 */
$repository->ingestObject($object);

 $datastream = $object->constructDatastream($dsid) // You may also set the $control_group.
/**
 * Here, you can manipulate the constructed datastream using the properties and methods described above.
 */
$object->ingestDatastream($dsid, $object);

Accessing an object's relationships

$relationships = $object->relationships;

From there, the object's relationships can be viewed and manipulated using the following properties and methods:

Properties

Methods

Example of retrieving a filtered relationship

$object_content_models = $object->relationships->get('info:fedora/fedora-system:def/model#', 'hasModel');

This would return an array containing only the object's hasModel relationships.

Example of setting an isMemberOfCollection relationship

Islandora provides the constant FEDORA_RELS_EXT_URI to make it easy to set the predicate as the first variable here:

Example of a retrieved relationship array

Array
(
    [0] => Array
        (
            [predicate] => Array
                (
                    [value] => isMemberOfCollection
                    [alias] => fedora
                    [namespace] => info:fedora/fedora-system:def/relations-external#
                )
            [object] => Array
                (
                    [literal] => FALSE
                    [value] => islandora:sp_basic_image_collection
                )
        )

    [1] => Array
        (
            [predicate] => Array
                (
                    [value] => hasModel
                    [alias] => fedora-model
                    [namespace] => info:fedora/fedora-system:def/model#
                )
            [object] => Array
                (
                    [literal] => FALSE
                    [value] => islandora:sp_basic_image
                )
        )
)

Using the Fedora A and M APIs

Tuque can work with the Fedora repository's "Access" and "Manage" API services in much the same way one would using standard Fedora API requests. This functionality is mimicked using an instantiated $repository's api property.

Note that the methods above provide a much more PHP-friendly way of performing many of the tasks provided by API-A and API-M. They are nonetheless listed in full below for documentation purposes. When a method in this section and a method above share functionality (e.g. addRelationship()here versus $repository->relationships->add() above, or listDatastreams()here versus foreach ($object as $datastream) { print_r($datastream); }above), it is always recommended to use the method above, as we cannot predict the composition of the Fedora APIs in the future; if any Fedora functionality changes or is removed, your code may also lose functionality.

Note that the methods above provide a much more PHP-friendly way of performing many of the tasks provided by API-A and API-M. They are nonetheless listed in full below for documentation purposes. When a method in this section and a method above share functionality, it is always recommended to use the method above, as not only is it nearly guaranteed to be easier to work with, but also we cannot predict the nature of the Fedora APIs in the future; if any Fedora functionality changes or is removed, your code may also lose functionality. For example:

/**
 * Adding a relationship to an object. The API method is clunky and requires information you wouldn't
 * need if you did things the tuque way, which is more Drupal-friendly as well.
 */
// API method.
$repository->api->m->addRelationship();
// Tuque method.
$object->relationships->add();
 
/**
 * Iterating through datastreams. The API method only gives you an associative array of DSIDs
 * containing the label and mimetype - you would have to load each datastream if you wanted to
 * work with it. Working through tuque is faster.
 */
// API method.
$array = $repository->api->a->listDatastreams($object->id);
foreach ($array as $dsid => $properties) {
 $datastream = islandora_datastream_load($dsid, $object);
 // Now you can do stuff with the datastream.
}
// Tuque method.
foreach ($object as $datastream) {
 // Do stuff with the datastream.
}

Documentation for the most current versions of each API can be found at:

• https://wiki.duraspace.org/display/FEDORA37/API-A
• https://wiki.duraspace.org/display/FEDORA37/API-M
• https://wiki.duraspace.org/display/FEDORA38/API-A
• https://wiki.duraspace.org/display/FEDORA38/API-M

Each API exists as a PHP object through Tuque, and can be created using:

$api_a = $repository->api->a; // For an Access API.
$api_m = $repository->api->m; // For a Management API.

From here, the functionality provided by each API mimics the functionality provided by the actual Fedora APIs, where the standard Fedora endpoints can be called as API object methods, e.g.:

$datastreams = $api_a->listDatastreams('islandora:1');

The following methods are available for each type of API:

FedoraApiA

All of these return results described in an array.

FedoraApiM

All of these return results described in an array.

Using the Resource Index

The resource index can be queried from the repository using:

$ri = $repository->ri;

From there, queries can be made to the resource index. It is generally best to use SPARQL queries for forwards compatibility:

$itql_query_results = $ri->itqlQuery($query, $limit); // For an iTQL query.
$sparql_query_results = $ri->sparqlQuery($query, $limit); // For a SPARQL query.

Methods