Infrastructure

In Morpho code, a data package is presented by an AbtractDataPackage class. This class is oriented by EML document. It has both the metadata and data information. Now Dataone introduced a new class - DataPackage. This new class is collection of D1Object. The DataPackage can be serialized as an OAI-ORE ResourceMap that details the linkages among data objects and science metadata objects.

Now Morpho will handle ORE document as well. So Ben suggested we may reuse the Dataone DataPackage. Dataone DataPackage object will be a member field in the AbstractDataPackage. We also may developer a utility method to transform AbstractDataPackage to the Dataone DataPackage.

Methods in AbstractDataPackage involving the Dataone API:

public void serialize(String location); // save action in morpho including create and update

public void delete(String location);// delete action in morpho

public void load(String location, String pid); // open a package

We also redefined the methods in DataoneDataStore (FileSystemDataStore):

public File read(String pid) throws FileNotFoundException, CacheAccessException;

public String save(AbstractDataPackage package) throws Exception; //this method will figure out which method should be used -- create or update.

public boolean delete(AbstractDataPackage package) throws Exception;

Here is the algorithm of how serialize method to call DataStore method:
abstractDataPackage.serialize(String location)
{
if(location == Network || location == Both)
{
dataoneDataStore.save(this);
}

if(location == local || location == Both)
{
fileSystemDataStore.save(this);
}
}

Here is the algorithm for DataoneDataStore.save(AbstractDataPackage abstractDataPackage)
DataoneDataStore.save(AbstractDataPackage abstractDataPackage)
{
dataPackage = buildDataPackage(abstractDataPackage);//This method will build the DataPackage object
dataPackage.save();//save method will figure out to use create or update method.
}

DataoneDataStore.buildDataPackage(AbstractDataPackage abstractDataPackage)
{
Identifier oreID = getIdentifier();
DataPackage dataPackage = new DataPackage(oreID)

if(abstractDataPackage.getDataPackage() != null)
{
dataPackage.setNewPackage(false);
}

//metadata part
if(abstractDataPackage.newMetadata())
{
//new metadata
d1Ojbect = new D1Object(abstractDataPackage.getIdentifier(), metadataByte[], abstractDataPackage.getFormatId(), abstractDataPackage.getSubmitter(), getActiveNodeId());
d1Object.setNewObject(true);
//generate sysMetadata
sysMetadata.setSubmitter(abstractDataPackage.getSubmitter());
........
d1Object.setSystemMetadata(sysMetadata);
dataPackage.add(d1Object);
}
else if(isDirty())
{
//updated metadata
Identifier newID = getIdentifier();
abstractDataPackage.setIdentifier(newID);
d1Ojbect = new D1Object=(abstractDataPackage.getIdentifier(), metadataByte[], abstractDataPackage.getFormatId(), abstractDataPackagegetSubmitter(), getActiveNodeId());
d1Object.setNewObject(false);
d1Object.setDirty(true);
//generate sysMetadata
sysMetadata = abstractDataPackage.getMetadataSysMetadata();
sysMetadata.setSubmitter(abstractDataPackage.getSubmitter());
........
d1Object.setSystemMetadata(sysMetadata);
dataPackage.add(d1Object);
}

//data part
for(Entity entity: abatractDataPackage.getEntityList())
{
if(entity.isNewEntity())
{
.....
dataPackage.addData(entity);
}
else (entity.isDirty())
{
....
dataPackage.addData(entity);
}

// add relationship
dataPackage.addRelationshitp(abstractDataPackage.getIdentifier(), entityIDlist);

// add sysMetadata to the dataPackage
oreSysMetadata= abractDataPackage.getDataPackage().getSysMetadata();
oreSysMetadata.set.....
dataPackage.setSysMetadata(oreSysMetadata);

}

// new method in the Dataone DataPackage class
DataPackage.save()
{
for(Map.Entry d1Object: dataStroe.entrySet())
{
if(d1Object.isNewObject())
{
d1Object.create();
}
else(d1Object.isDirty())
{

d1Object.update();
}
}

//create or update the ORE document
String ore = serializePackage();
if(this.newPackage())
{
D1Client.create();
}
else
{
D1Client.update();
}
}