Fedora Repository Views
...
But the angle one views the repository might also affect the number of entries seen. The above, recursive approach will always lead to one entry per data object. The remedy for this is to mark some classes as Entries for a certain view angle. This means that to compute the records for a given view angle, the view of all objects of a class that is an Entry should be computed. This is the view of the repository.
Fedora Implementation
This section describes how the above could be implemented in Fedora.
...
We want to be able to return all Views in a given Collection for a given State that have been modified after a given Time. To do this, we maintain a database of Views that is updated on all changes of an object.
Maintaining state
Whenever one of the components of a View is changed, the whole View counts as updated. As such, any services that subscribe to the View in any way need to be notified. If there is a search index for the Views, and one is updated, its state in the index must be recomputed.
The problem arrives when trying to do this. The View system is designed to ease the computing of a View when knowing the Entry object. The reverse is finding the Views, ie. the Entry objects, that have this data object in their View. Rather than encoding this information in the model, we chose to keep an external record of all the views.
...
- objectPid: The pid of this object
- entryPid: The pid of the entry object that includes this object
- viewAngle: The name of the view angle by which the entry object includes this object
- state: The state of that object
Finding Changed objects
To find changed objects we will ask for a set of objects with the following criteria
...
- Active, if the new state is Active and all other objects in the view are current Active
- Deleted, if this is the entry objectsobject, and
- Inactive, otherwise
| Code Block | ||
|---|---|---|
| ||
void objectStateModified(String pid, Date date, String state) {
//Find the DomsObject rows that regard this object.
//There will be one per entry/viewAngle combination
results = OBJECTS.list(objectPid=pid);
//Find all Entries that include this object
//If the object does not previously exist, this list will be empty
for (result : results) {
if (result.entryPid != pid) {
if (viewAngle = 'Active') {
newState = && allActive(entryPid, viewangle);) {
} else { //If this makes the view active, mark it as updated
newState = 'Inactive'; updateEntry(result.entryPid,
} //Mark them as updated updateEntry(result.entryPid, 'Active',
newState, result.viewAngle,
result.viewAngle, date);
date);}
} } //Always Findmark them viewas Infoupdated for the thisinactive objectstate
List<ViewInfo> viewInfoList = fedora.getViewInfo(pidupdateEntry(result.entryPid,
date); for (ViewInfo viewInfo : viewInfoList) { //If it is an entry object, set it in the ENTRIES table 'Inactive',
if (viewInfo.isEntry()) { if (viewAngle = 'Active') { newState = allActive(pid, viewInfo.viewangle); result.viewAngle,
} else { date);
}
}
// Find view Info for this object
List<ViewInfo> viewInfoList = fedora.getViewInfo(pid, date);
for (ViewInfo viewInfo : viewInfoList) {
//If it is an entry object, set it in the ENTRIES table
if (viewInfo.isEntry()) {
if (viewAngle = 'Active' && allActive(pid, viewInfo.viewangle)) {
updateEntry(pid, 'Active', viewInfo.viewAngle, date);
updateEntry(pid, 'Inactive', viewInfo.viewAngle, date);
} else if (viewAngle = 'Deleted') {
// TODO: Should we remove all objects referring to this viewangle?
updateEntry(pid, 'Deleted', viewInfo.viewAngle, date);
newState = state; } else {
} updateEntry(pid, newState'Inactive', viewInfo.viewAngle, date);
updateDomsObjects(pid, pid, viewInfo.viewAngle, state); }
}
}
}
// Update the Entries table regarding a change
void updateEntry(String entryPid, String state, String viewAngle, Date date) {
//Find the Entry objects that fulfill these restrictions
List<Entry> results = ENTRIES.list(entrypid,state,viewangle)
//There might be no Entry, but if we are here, we know that an entry should exist, so create it.
if (results.size() == 0) {
ENTRIES.insert(new Entry(entryPid, viewAngle, state, date));
} else {
for (Entry result : results) {
//Is this entry older than the current change?
if (result.getDateForChange().getTime() < date.getTime()) {
result.setDateForChange(date);
result.setEntryPid(entryPid);
result.setState(state);
result.setViewAngle(viewAngle);
}
//Save the entry
ENTRIES.update(result);
}
}
}
void updateDomsObjects(String objectPid, String entryPid, String viewAngle, state) {
list<DomsObject> results = OBJECTS.list(objectPid,entryPid,viewAngle)
if (results.size() == 0) {
OBJECTS.insert(new DomsObject(objectPid, entryPid, viewAngle, state)); results = OBJECTS.list(objectPid,entryPid,viewAngle)
} elseif (results.size() == 0) {
OBJECTS.update(results[0], insert(new DomsObject(objectPid, entryPid, viewAngle, state));
}
}
|
Object Relations Changed
...
TODO: This may ALSO update content models or collections!!. I think we can fix this by calling objectModified when these specific relations are called
| Code Block |
|---|
void objectRelationsChanged(String pid, Date date) {
//This can change the structure of the views and we must therefore recaculate the views
//if a current entry object use this object, we will need to recalculate the view of that object
//This method will only be called on objects that already exist. Objects cannot change type once created.
//ObjectModified() creates an Entry row, if the object is an entry object. As such, there will always be
// the correct Entry entries when this method is called, and these should just be recalculated
List<DomsObject> results = OBJECTS.list(objectPid=pid);
//we now have a list of all the entries that include this object.
for (DomsObject result : results) {
//get the ViewBundle from fedora
ViewBundle bundle = fedora.calcViewBundle(result.getEntryPid(), result.getViewAngle(), date);
//First, remove all the objects in this bundle from the table
removeNotListedFromDomsObjects(bundle.getContained(), result.getEntryPid(), result.getViewAngle());
//Add all the objects from the bundle to the objects Table.
for (String objectPid : bundle.getContained()) {
updateDomsObjects(objectPid, bundle.getEntry(), bundle.getViewAngle());
}
updateEntry(bundle.getEntry(), STATE_INPROGRESS, bundle.getViewAngle(), date);
}
}
void removeNotListedFromDomsObjects(List<String> objectPid, String entryPid, String viewAngle) {
List<DomsObject> results = OBJECTS.list(entryPid,viewAngle);
for (DomsObject result : results) {
if (!objectPid.contains(result.getObjectPid())) {
OBJECTS.delete(result);
}
}
}
|
...