@Override
public void update(Context context, Community community) throws SQLException, AuthorizeException {
// Check authorisation
canEdit(context, community);
log.info(
LogManager.getHeader(context, "update_community", "community_id=" + community.getID()));
communityDAO.save(context, community);
if (community.isModified()) {
context.addEvent(
new Event(
Event.MODIFY,
Constants.COMMUNITY,
community.getID(),
null,
getIdentifiers(context, community)));
community.setModified();
}
if (community.isMetadataModified()) {
context.addEvent(
new Event(
Event.MODIFY_METADATA,
Constants.COMMUNITY,
community.getID(),
community.getDetails(),
getIdentifiers(context, community)));
community.clearModified();
}
community.clearDetails();
}
@Override
public void removeSubcommunity(
Context context, Community parentCommunity, Community childCommunity)
throws SQLException, AuthorizeException, IOException {
// Check authorisation
authorizeService.authorizeAction(context, parentCommunity, Constants.REMOVE);
ArrayList<String> removedIdentifiers = getIdentifiers(context, childCommunity);
String removedHandle = childCommunity.getHandle();
UUID removedId = childCommunity.getID();
parentCommunity.removeSubCommunity(childCommunity);
childCommunity.getParentCommunities().remove(parentCommunity);
if (CollectionUtils.isEmpty(childCommunity.getParentCommunities())) {
rawDelete(context, childCommunity);
}
log.info(
LogManager.getHeader(
context,
"remove_subcommunity",
"parent_comm_id="
+ parentCommunity.getID()
+ ",child_comm_id="
+ childCommunity.getID()));
context.addEvent(
new Event(
Event.REMOVE,
Constants.COMMUNITY,
parentCommunity.getID(),
Constants.COMMUNITY,
removedId,
removedHandle,
removedIdentifiers));
}
@Override
public void removeCollection(Context context, Community community, Collection collection)
throws SQLException, AuthorizeException, IOException {
// Check authorisation
authorizeService.authorizeAction(context, community, Constants.REMOVE);
community.removeCollection(collection);
ArrayList<String> removedIdentifiers = collectionService.getIdentifiers(context, collection);
String removedHandle = collection.getHandle();
UUID removedId = collection.getID();
collection.removeCommunity(community);
if (CollectionUtils.isEmpty(collection.getCommunities())) {
collectionService.delete(context, collection);
}
log.info(
LogManager.getHeader(
context,
"remove_collection",
"community_id=" + community.getID() + ",collection_id=" + collection.getID()));
// Remove any mappings
context.addEvent(
new Event(
Event.REMOVE,
Constants.COMMUNITY,
community.getID(),
Constants.COLLECTION,
removedId,
removedHandle,
removedIdentifiers));
}
@Override
public void addSubcommunity(Context context, Community parentCommunity, Community childCommunity)
throws SQLException, AuthorizeException {
// Check authorisation
authorizeService.authorizeAction(context, parentCommunity, Constants.ADD);
log.info(
LogManager.getHeader(
context,
"add_subcommunity",
"parent_comm_id="
+ parentCommunity.getID()
+ ",child_comm_id="
+ childCommunity.getID()));
if (!parentCommunity.getSubcommunities().contains(childCommunity)) {
parentCommunity.addSubCommunity(childCommunity);
childCommunity.addParentCommunity(parentCommunity);
}
context.addEvent(
new Event(
Event.ADD,
Constants.COMMUNITY,
parentCommunity.getID(),
Constants.COMMUNITY,
childCommunity.getID(),
parentCommunity.getHandle(),
getIdentifiers(context, parentCommunity)));
}
@Override
public void addCollection(Context context, Community community, Collection collection)
throws SQLException, AuthorizeException {
// Check authorisation
authorizeService.authorizeAction(context, community, Constants.ADD);
log.info(
LogManager.getHeader(
context,
"add_collection",
"community_id=" + community.getID() + ",collection_id=" + collection.getID()));
if (!community.getCollections().contains(collection)) {
community.addCollection(collection);
collection.addCommunity(community);
}
context.addEvent(
new Event(
Event.ADD,
Constants.COMMUNITY,
community.getID(),
Constants.COLLECTION,
collection.getID(),
community.getHandle(),
getIdentifiers(context, community)));
}
/** Update the group - writing out group object and EPerson list if necessary */
public void update() throws SQLException, AuthorizeException {
// FIXME: Check authorisation
DatabaseManager.update(myContext, myRow);
if (modifiedMetadata) {
myContext.addEvent(new Event(Event.MODIFY_METADATA, Constants.GROUP, getID(), getDetails()));
modifiedMetadata = false;
clearDetails();
}
// Redo eperson mappings if they've changed
if (epeopleChanged) {
// Remove any existing mappings
DatabaseManager.updateQuery(
myContext, "delete from epersongroup2eperson where eperson_group_id= ? ", getID());
// Add new mappings
Iterator<EPerson> i = epeople.iterator();
while (i.hasNext()) {
EPerson e = i.next();
TableRow mappingRow = DatabaseManager.row("epersongroup2eperson");
mappingRow.setColumn("eperson_id", e.getID());
mappingRow.setColumn("eperson_group_id", getID());
DatabaseManager.insert(myContext, mappingRow);
}
epeopleChanged = false;
}
// Redo Group mappings if they've changed
if (groupsChanged) {
// Remove any existing mappings
DatabaseManager.updateQuery(
myContext, "delete from group2group where parent_id= ? ", getID());
// Add new mappings
Iterator<Group> i = groups.iterator();
while (i.hasNext()) {
Group g = i.next();
TableRow mappingRow = DatabaseManager.row("group2group");
mappingRow.setColumn("parent_id", getID());
mappingRow.setColumn("child_id", g.getID());
DatabaseManager.insert(myContext, mappingRow);
}
// groups changed, now change group cache
rethinkGroupCache();
groupsChanged = false;
}
log.info(LogManager.getHeader(myContext, "update_group", "group_id=" + getID()));
}
/**
* remove group from this group
*
* @param g
*/
public void removeMember(Group g) {
loadData(); // make sure Group has data loaded
if (groups.remove(g)) {
groupsChanged = true;
myContext.addEvent(
new Event(
Event.REMOVE, Constants.GROUP, getID(), Constants.GROUP, g.getID(), g.getName()));
}
}
/**
* remove an eperson from a group
*
* @param e eperson
*/
public void removeMember(EPerson e) {
loadData(); // make sure Group has data loaded
if (epeople.remove(e)) {
epeopleChanged = true;
myContext.addEvent(
new Event(
Event.REMOVE, Constants.GROUP, getID(), Constants.EPERSON, e.getID(), e.getEmail()));
}
}
@Override
public void updateLastModified(Context context, Community community) {
// Also fire a modified event since the community HAS been modified
context.addEvent(
new Event(
Event.MODIFY,
Constants.COMMUNITY,
community.getID(),
null,
getIdentifiers(context, community)));
}
/**
* Internal method to remove the community and all its children from the database, and perform any
* pre/post-cleanup
*
* @throws SQLException
* @throws AuthorizeException
* @throws IOException
*/
protected void rawDelete(Context context, Community community)
throws SQLException, AuthorizeException, IOException {
log.info(
LogManager.getHeader(context, "delete_community", "community_id=" + community.getID()));
context.addEvent(
new Event(
Event.DELETE,
Constants.COMMUNITY,
community.getID(),
community.getHandle(),
getIdentifiers(context, community)));
// Remove collections
Iterator<Collection> collections = community.getCollections().iterator();
while (collections.hasNext()) {
Collection collection = collections.next();
collections.remove();
removeCollection(context, community, collection);
}
// delete subcommunities
Iterator<Community> subCommunities = community.getSubcommunities().iterator();
while (subCommunities.hasNext()) {
Community subComm = subCommunities.next();
subCommunities.remove();
delete(context, subComm);
}
// Remove the logo
setLogo(context, community, null);
// Remove all authorization policies
authorizeService.removeAllPolicies(context, community);
// Remove any Handle
handleService.unbindHandle(context, community);
deleteMetadata(context, community);
Group g = community.getAdministrators();
// Delete community row
communityDAO.delete(context, community);
// Remove administrators group - must happen after deleting community
if (g != null) {
groupService.delete(context, g);
}
}
/**
* add an eperson member
*
* @param e eperson
*/
public void addMember(EPerson e) {
loadData(); // make sure Group has data loaded
if (isMember(e)) {
return;
}
epeople.add(e);
epeopleChanged = true;
myContext.addEvent(
new Event(Event.ADD, Constants.GROUP, getID(), Constants.EPERSON, e.getID(), e.getEmail()));
}
/**
* add group to this group
*
* @param g
*/
public void addMember(Group g) {
loadData(); // make sure Group has data loaded
// don't add if it's already a member
// and don't add itself
if (isMember(g) || getID() == g.getID()) {
return;
}
groups.add(g);
groupsChanged = true;
myContext.addEvent(
new Event(Event.ADD, Constants.GROUP, getID(), Constants.GROUP, g.getID(), g.getName()));
}
@Override
public void delete(Context context, Community community)
throws SQLException, AuthorizeException, IOException {
// Check authorisation
// FIXME: If this was a subcommunity, it is first removed from it's
// parent.
// This means the parentCommunity == null
// But since this is also the case for top-level communities, we would
// give everyone rights to remove the top-level communities.
// The same problem occurs in removing the logo
if (!authorizeService.authorizeActionBoolean(
context, getParentObject(context, community), Constants.REMOVE)) {
authorizeService.authorizeAction(context, community, Constants.DELETE);
}
ArrayList<String> removedIdentifiers = getIdentifiers(context, community);
String removedHandle = community.getHandle();
UUID removedId = community.getID();
// If not a top-level community, have parent remove me; this
// will call rawDelete() before removing the linkage
Community parent = (Community) getParentObject(context, community);
if (parent != null) {
// remove the subcommunities first
Iterator<Community> subcommunities = community.getSubcommunities().iterator();
while (subcommunities.hasNext()) {
Community subCommunity = subcommunities.next();
subcommunities.remove();
delete(context, subCommunity);
}
// now let the parent remove the community
removeSubcommunity(context, parent, community);
return;
}
rawDelete(context, community);
context.addEvent(
new Event(
Event.REMOVE,
Constants.SITE,
siteService.findSite(context).getID(),
Constants.COMMUNITY,
removedId,
removedHandle,
removedIdentifiers));
}
/**
* Create a new group
*
* @param context DSpace context object
*/
public static Group create(Context context) throws SQLException, AuthorizeException {
// FIXME - authorization?
if (!AuthorizeManager.isAdmin(context)) {
throw new AuthorizeException("You must be an admin to create an EPerson Group");
}
// Create a table row
TableRow row = DatabaseManager.create(context, "epersongroup");
Group g = new Group(context, row);
log.info(LogManager.getHeader(context, "create_group", "group_id=" + g.getID()));
context.addEvent(new Event(Event.CREATE, Constants.GROUP, g.getID(), null));
return g;
}
/** Delete a group */
public void delete() throws SQLException {
// FIXME: authorizations
myContext.addEvent(new Event(Event.DELETE, Constants.GROUP, getID(), getName()));
// Remove from cache
myContext.removeCached(this, getID());
// Remove any ResourcePolicies that reference this group
AuthorizeManager.removeGroupPolicies(myContext, getID());
// Remove any group memberships first
DatabaseManager.updateQuery(
myContext, "DELETE FROM EPersonGroup2EPerson WHERE eperson_group_id= ? ", getID());
// remove any group2groupcache entries
DatabaseManager.updateQuery(
myContext,
"DELETE FROM group2groupcache WHERE parent_id= ? OR child_id= ? ",
getID(),
getID());
// Now remove any group2group assignments
DatabaseManager.updateQuery(
myContext, "DELETE FROM group2group WHERE parent_id= ? OR child_id= ? ", getID(), getID());
// don't forget the new table
deleteEpersonGroup2WorkspaceItem();
// Remove ourself
DatabaseManager.delete(myContext, myRow);
epeople.clear();
log.info(LogManager.getHeader(myContext, "delete_group", "group_id=" + getID()));
}
@Override
public Community create(Community parent, Context context, String handle)
throws SQLException, AuthorizeException {
if (!(authorizeService.isAdmin(context)
|| (parent != null
&& authorizeService.authorizeActionBoolean(context, parent, Constants.ADD)))) {
throw new AuthorizeException("Only administrators can create communities");
}
Community newCommunity = communityDAO.create(context, new Community());
try {
if (handle == null) {
handleService.createHandle(context, newCommunity);
} else {
handleService.createHandle(context, newCommunity, handle);
}
} catch (IllegalStateException ie) {
// If an IllegalStateException is thrown, then an existing object is already using this handle
throw ie;
}
if (parent != null) {
parent.addSubCommunity(newCommunity);
newCommunity.addParentCommunity(parent);
}
// create the default authorization policy for communities
// of 'anonymous' READ
Group anonymousGroup = groupService.findByName(context, Group.ANONYMOUS);
authorizeService.createResourcePolicy(
context, newCommunity, anonymousGroup, null, Constants.READ, null);
communityDAO.save(context, newCommunity);
context.addEvent(
new Event(
Event.CREATE,
Constants.COMMUNITY,
newCommunity.getID(),
newCommunity.getHandle(),
getIdentifiers(context, newCommunity)));
// if creating a top-level Community, simulate an ADD event at the Site.
if (parent == null) {
context.addEvent(
new Event(
Event.ADD,
Constants.SITE,
siteService.findSite(context).getID(),
Constants.COMMUNITY,
newCommunity.getID(),
newCommunity.getHandle(),
getIdentifiers(context, newCommunity)));
}
log.info(
LogManager.getHeader(context, "create_community", "community_id=" + newCommunity.getID())
+ ",handle="
+ newCommunity.getHandle());
return newCommunity;
}
public void updateMetadata() throws SQLException, AuthorizeException {
// Map counting number of values for each element/qualifier.
// Keys are Strings: "element" or "element.qualifier"
// Values are Integers indicating number of values written for a
// element/qualifier
Map<String, Integer> elementCount = new HashMap<String, Integer>();
modifiedMetadata = false;
// Arrays to store the working information required
int[] placeNum = new int[getMetadata().size()];
boolean[] storedDC = new boolean[getMetadata().size()];
MetadataField[] dcFields = new MetadataField[getMetadata().size()];
// Work out the place numbers for the in memory DC
for (int dcIdx = 0; dcIdx < getMetadata().size(); dcIdx++) {
DCValue dcv = getMetadata().get(dcIdx);
// Work out the place number for ordering
int current = 0;
// Key into map is "element" or "element.qualifier"
String key = dcv.element + ((dcv.qualifier == null) ? "" : ("." + dcv.qualifier));
Integer currentInteger = elementCount.get(key);
if (currentInteger != null) {
current = currentInteger.intValue();
}
current++;
elementCount.put(key, Integer.valueOf(current));
// Store the calculated place number, reset the stored flag, and cache the metadatafield
placeNum[dcIdx] = current;
storedDC[dcIdx] = false;
dcFields[dcIdx] = getMetadataField(dcv);
if (dcFields[dcIdx] == null) {
// Bad DC field, log and throw exception
log.warn("Invalid metadata field: [" + dcv.getField() + "] : [" + dcv.value + "]");
throw new SQLException("Invalid metadata field: [" + dcv.getField() + "]");
}
}
// Now the precalculations are done, iterate through the existing metadata
// looking for matches
TableRowIterator tri = retrieveMetadata();
if (tri != null) {
try {
while (tri.hasNext()) {
TableRow tr = tri.next();
// Assume that we will remove this row, unless we get a match
boolean removeRow = true;
// Go through the in-memory metadata, unless we've already decided to keep this row
for (int dcIdx = 0; dcIdx < getMetadata().size() && removeRow; dcIdx++) {
// Only process if this metadata has not already been matched to something in the DB
if (!storedDC[dcIdx]) {
boolean matched = true;
DCValue dcv = getMetadata().get(dcIdx);
// Check the metadata field is the same
if (matched && dcFields[dcIdx].getFieldID() != tr.getIntColumn("metadata_field_id")) {
matched = false;
}
// Check the place is the same
if (matched && placeNum[dcIdx] != tr.getIntColumn("place")) {
matched = false;
}
// Check the text is the same
if (matched) {
String text = tr.getStringColumn("text_value");
if (dcv.value == null && text == null) {
matched = true;
} else if (dcv.value != null && dcv.value.equals(text)) {
matched = true;
} else {
matched = false;
}
}
// Check the language is the same
if (matched) {
String lang = tr.getStringColumn("text_lang");
if (dcv.language == null && lang == null) {
matched = true;
} else if (dcv.language != null && dcv.language.equals(lang)) {
matched = true;
} else {
matched = false;
}
}
// check that authority and confidence match
if (matched) {
String auth = tr.getStringColumn("authority");
int conf = tr.getIntColumn("confidence");
if (!((dcv.authority == null && auth == null)
|| (dcv.authority != null && auth != null && dcv.authority.equals(auth))
&& dcv.confidence == conf)) {
matched = false;
}
}
// If the db record is identical to the in memory values
if (matched) {
// Flag that the metadata is already in the DB
storedDC[dcIdx] = true;
// Flag that we are not going to remove the row
removeRow = false;
}
}
}
// If after processing all the metadata values, we didn't find a match
// delete this row from the DB
if (removeRow) {
DatabaseManager.delete(ourContext, tr);
modifiedMetadata = true;
}
}
} finally {
tri.close();
}
}
// Add missing in-memory DC
for (int dcIdx = 0; dcIdx < getMetadata().size(); dcIdx++) {
// Only write values that are not already in the db
if (!storedDC[dcIdx]) {
DCValue dcv = getMetadata().get(dcIdx);
// Write DCValue
MetadataValue metadata = new MetadataValue();
metadata.setResourceId(getID());
metadata.setResourceTypeId(getType());
metadata.setFieldId(dcFields[dcIdx].getFieldID());
metadata.setValue(dcv.value);
metadata.setLanguage(dcv.language);
metadata.setPlace(placeNum[dcIdx]);
metadata.setAuthority(dcv.authority);
metadata.setConfidence(dcv.confidence);
metadata.create(ourContext);
modifiedMetadata = true;
}
}
if (modifiedMetadata) {
ourContext.addEvent(
new Event(
Event.MODIFY_METADATA, getType(), getID(), getDetails(), getIdentifiers(ourContext)));
modifiedMetadata = false;
}
}
