/**********************************************************************************
* $URL: https://source.sakaiproject.org/svn/osp/trunk/presentation/api/src/java/org/theospi/portfolio/presentation/PresentationManager.java $
* $Id: PresentationManager.java 64567 2009-07-02 20:40:39Z bkirschn@umich.edu $
***********************************************************************************
*
* Copyright (c) 2009 The Sakai Foundation
*
* Licensed under the Educational Community License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.opensource.org/licenses/ECL-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**********************************************************************************/
package org.theospi.portfolio.presentation.support;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.sakaiproject.component.api.ServerConfigurationService;
import org.sakaiproject.content.api.ContentCollection;
import org.sakaiproject.content.api.ContentCollectionEdit;
import org.sakaiproject.content.api.ContentHostingService;
import org.sakaiproject.content.api.ResourceEditingHelper;
import org.sakaiproject.entity.api.Entity;
import org.sakaiproject.entity.api.ResourceProperties;
import org.sakaiproject.exception.IdUnusedException;
import org.sakaiproject.exception.IdUsedException;
import org.sakaiproject.exception.PermissionException;
import org.sakaiproject.exception.TypeException;
import org.sakaiproject.metaobj.security.AuthenticationManager;
import org.sakaiproject.metaobj.shared.ArtifactFinder;
import org.sakaiproject.metaobj.shared.FormHelper;
import org.sakaiproject.metaobj.shared.mgt.AgentManager;
import org.sakaiproject.metaobj.shared.mgt.IdCustomEditor;
import org.sakaiproject.metaobj.shared.mgt.IdManager;
import org.sakaiproject.metaobj.shared.model.Agent;
import org.sakaiproject.metaobj.shared.model.Artifact;
import org.sakaiproject.metaobj.shared.model.ContentResourceArtifact;
import org.sakaiproject.metaobj.shared.model.StructuredArtifact;
import org.sakaiproject.metaobj.utils.mvc.intf.TypedPropertyEditor;
import org.sakaiproject.site.api.SiteService;
import org.sakaiproject.tool.api.Placement;
import org.sakaiproject.tool.api.ToolManager;
import org.sakaiproject.user.api.User;
import org.sakaiproject.user.cover.UserDirectoryService;
import org.sakaiproject.util.ResourceLoader;
import org.sakaiproject.entity.cover.EntityManager;
import org.sakaiproject.entity.api.Reference;
import org.theospi.portfolio.presentation.PresentationFunctionConstants;
import org.theospi.portfolio.presentation.PresentationManager;
import org.theospi.portfolio.presentation.model.Presentation;
import org.theospi.portfolio.presentation.model.PresentationComment;
import org.theospi.portfolio.presentation.model.PresentationItem;
import org.theospi.portfolio.presentation.model.PresentationItemDefinition;
import org.theospi.portfolio.presentation.model.PresentationTemplate;
import org.theospi.portfolio.presentation.model.PresentationTemplateNameComparator;
import org.theospi.portfolio.security.AuthorizationFacade;
import org.theospi.portfolio.wizard.model.CompletedWizard;
import org.sakaiproject.metaobj.security.AuthenticationManager;
import org.theospi.portfolio.security.Authorization;
import org.theospi.portfolio.security.AudienceSelectionHelper;
public class PresentationService {
private IdManager idManager;
private AuthenticationManager authnManager;
private AgentManager agentManager;
private AuthorizationFacade authzManager;
private PresentationManager presentationManager;
private ToolManager toolManager;
private IdCustomEditor idCustomEditor;
private TypedPropertyEditor presentationItemCustomEditor;
private TypedPropertyEditor presentationViewerCustomEditor;
private ArtifactFinder artifactFinder;
private SiteService siteService;
private ContentHostingService contentHostingService;
private ServerConfigurationService serverConfigurationService;
private static final Log log = LogFactory.getLog(PresentationService.class);
private static final String WIZARD_ITEM_PLACEHOLDER = "Wizard/Matrix";
private static final ResourceLoader resourceBundle = new ResourceLoader(PresentationManager.PRESENTATION_MESSAGE_BUNDLE);
public static final String VIEW_PRESENTATION_URL = "/osp-presentation-tool/viewPresentation.osp?id=";
public static final String PROP_FREEFORM_DISABLED = "osp.freeform.disabled";
//TODO: Add signature for more parameterized creation -- not just complete current context (user, site, tool)
public Presentation createPresentation(String presentationType, String templateId) {
if (!Presentation.FREEFORM_TYPE.equals(presentationType) && !Presentation.TEMPLATE_TYPE.equals(presentationType)) {
log.warn("Cannot Create Presentation -- Invalid Presentation Type (" + presentationType + ") -- Must be template or free-form.");
return null;
}
Agent agent = authnManager.getAgent();
PresentationTemplate template = presentationManager.getPresentationTemplate(idManager.getId(templateId));
if (template == null) {
log.warn("Cannot Create Presentation -- Invalid Presentation Template ID: " + templateId);
return null;
}
Presentation presentation = new Presentation();
presentation.setNewObject(true);
//presentation.setId(idManager.createId());
//The Site ID is coalesced in PresentationManager -- the Tool ID should be too, but is not
presentation.setToolId(toolManager.getCurrentPlacement().getId());
presentation.setPresentationType(presentationType);
presentation.setTemplate(template);
presentation.setName(template.getName()+" - "+agent.getDisplayName());
return presentationManager.storePresentation(presentation);
}
//NOTE: This method is context-aware, returning available templates for the current user/site/tool
public List<PresentationTemplate> getAvailableTemplates() {
Agent agent = authnManager.getAgent();
TreeSet<PresentationTemplate> availableTemplates = new TreeSet<PresentationTemplate>(new PresentationTemplateNameComparator());
availableTemplates.addAll(presentationManager.findTemplatesByOwner(agent, toolManager.getCurrentPlacement().getContext()));
availableTemplates.addAll(presentationManager.findPublishedTemplates(toolManager.getCurrentPlacement().getContext()));
availableTemplates.addAll(presentationManager.findGlobalTemplates());
return new ArrayList<PresentationTemplate>(availableTemplates);
}
//NOTE: This method is context-aware, checking properties of the current tool
public boolean isFreeFormEnabled() {
//Leave free-form on by default if not configured
boolean disabled = serverConfigurationService.getBoolean(PROP_FREEFORM_DISABLED, false);
try {
String siteWide = siteService.findTool(toolManager.getCurrentPlacement().getId())
.getContainingPage().getContainingSite().getProperties()
.getProperty(PROP_FREEFORM_DISABLED);
//We want to allow sites to turn free-form back on if off system-wide, or off if on by default
//But be specific about the property values
if ("true".equalsIgnoreCase(siteWide) || "1".equals(siteWide))
disabled = true;
else if ("false".equalsIgnoreCase(siteWide) || "0".equals(siteWide))
disabled = false;
}
catch (Exception e) {
if (log.isDebugEnabled())
log.debug("Error retrieving site properties for tool placement: " + toolManager.getCurrentPlacement());
}
//NOTE: This method inverts the logic. To admins, disabling is the natural action because enabled is default.
// In the code, enabled is the more natural state.
return !disabled;
}
public boolean updatePresentation(String presentationId, String name, String description, Boolean active, Boolean allowComments, Boolean searchable) {
Presentation presentation = getPresentation(presentationId);
if (name != null)
presentation.setName(name);
if (description != null)
presentation.setDescription(description);
if (Boolean.TRUE.equals(active))
presentation.setExpiresOn(null);
else if (Boolean.FALSE.equals(active))
presentation.setExpiresOn(new GregorianCalendar(1970, 1, 1).getTime());
if (Boolean.TRUE.equals(allowComments))
presentation.setAllowComments(true);
else if (Boolean.FALSE.equals(allowComments))
presentation.setAllowComments(false);
if (Boolean.TRUE.equals(searchable)) {
presentation.setIsSearchable(true);
}
else {
presentation.setIsSearchable(false);
}
presentation = presentationManager.storePresentation(presentation, false, true);
return (presentation != null);
}
public Presentation getPresentation(String id) {
return getPresentation(id, true);
}
public Presentation getPresentation(String id, boolean checkAuthz) {
Presentation presentation = presentationManager.getPresentation( idManager.getId(id), checkAuthz );
if (presentation == null)
throw new IllegalArgumentException("Portfolio does not exist with ID: " + id);
return presentation;
}
public PresentationItemDefinition getPresentationItemDefinition(String id) {
PresentationItemDefinition presentationItemDef = presentationManager.getPresentationItemDefinition(idManager.getId(id));
if (presentationItemDef == null)
throw new IllegalArgumentException("Portfolio Item Definition does not exist with ID: " + id);
return presentationItemDef;
}
public Presentation savePresentation(Presentation presentation) {
return presentationManager.storePresentation(presentation);
}
public Presentation savePresentation(Presentation presentation, boolean checkAuthz, boolean updateDates) {
return presentationManager.storePresentation(presentation, checkAuthz, updateDates);
}
public List<PresentationComment> getComments(String presentationId) {
return presentationManager.getPresentationComments(idManager.getId(presentationId), authnManager.getAgent());
}
/** Returns true if current user is owner of specified presentation
**/
public boolean isOwner(Presentation presentation) {
Agent agent = authnManager.getAgent();
return presentation.getOwner().getId().getValue().equals(agent.getId().getValue());
}
public Map<String, Object> editOptions(String presentationId) {
HashMap<String, Object> params = new HashMap<String, Object>();
Presentation presentation = getPresentation(presentationId);
PresentationTemplate template = presentation.getTemplate();
if (template.getPropertyFormType() == null || Presentation.FREEFORM_TYPE.equals(presentation.getPresentationType()))
throw new IllegalArgumentException("Portfolio Type does not accept options.");
//Try to find the attached form
String formId = null;
if (presentation.getPropertyForm() != null)
formId = contentHostingService.resolveUuid(presentation.getPropertyForm().getValue());
//No form or invalid attachment results in creation, otherwise edit existing
if (formId == null) {
//Create or locate the folder to hold the new form
String folderPath = getPropertiesFolder();
params.put(FormHelper.PARENT_ID_TAG, folderPath);
params.put(FormHelper.NEW_FORM_DISPLAY_NAME_TAG, presentation.getName() + " (" + presentationId + ")");
}
else {
params.put(ResourceEditingHelper.ATTACHMENT_ID, formId);
}
params.put(ResourceEditingHelper.CREATE_TYPE, ResourceEditingHelper.CREATE_TYPE_FORM);
params.put(ResourceEditingHelper.CREATE_SUB_TYPE, template.getPropertyFormType().getValue());
return params;
}
public Map<String, Object> createForm(String presentationId, String formTypeId, String itemDefId) {
return editForm(presentationId, formTypeId, null, itemDefId, true);
}
/**
*
* @param presentationId
* @param formTypeId
* @param formId
* @return
*/
public Map<String, Object> copyForm(String presentationId, String formTypeId, String formId) {
HashMap<String, Object> params = new HashMap<String, Object>();
if (formTypeId == null)
formTypeId = getFormType(formId);
if (formTypeId == null)
throw new IllegalArgumentException("Cannot edit with null form type");
if (formId == null)
throw new IllegalArgumentException("Cannot edit null form");
formId = contentHostingService.resolveUuid(formId);
if (formId == null)
throw new IllegalArgumentException("Cannot edit nonexistent form");
String copyId = null;
try {
copyId = contentHostingService.copy(formId, formId);
} catch (Exception e) {
// This copy method wanted me to catch 7 different exceptions. That seemed excessive, so just catching Exception.
log.error("Error copying form", e);
}
params.put(ResourceEditingHelper.ATTACHMENT_ID, copyId);
params.put(ResourceEditingHelper.CREATE_TYPE, ResourceEditingHelper.CREATE_TYPE_FORM);
params.put(ResourceEditingHelper.CREATE_SUB_TYPE, formTypeId);
return params;
}
public Map<String, Object> editForm(String presentationId, String formTypeId, String formId, String itemDefId) {
return editForm(presentationId, formTypeId, formId, itemDefId, false);
}
public Map<String, Object> editForm(String presentationId, String formId, String itemDefId) {
return editForm(presentationId, getFormType(formId), formId, itemDefId);
}
protected Map<String, Object> editForm(String presentationId, String formTypeId, String formId, String itemDefId, boolean newItem) {
// Sanity check parameters (will throw an exception for any unacceptable conditions)
if (newItem)
checkFormCreateParameters(presentationId, formTypeId, itemDefId);
else
checkFormEditParameters(presentationId, formTypeId, formId, itemDefId);
Presentation presentation = getPresentation(presentationId);
PresentationTemplate template = presentation.getTemplate();
PresentationItemDefinition itemDef = null;
for (PresentationItemDefinition def : (Collection<PresentationItemDefinition>) template.getItemDefinitions())
if (def.getId().getValue().equals(itemDefId))
itemDef = def;
String folderPath = getFormsFolder();
HashMap<String, Object> params = new HashMap<String, Object>();
if (newItem)
params.put(FormHelper.PARENT_ID_TAG, folderPath);
else
params.put(ResourceEditingHelper.ATTACHMENT_ID, contentHostingService.resolveUuid(formId));
params.put(ResourceEditingHelper.CREATE_TYPE, ResourceEditingHelper.CREATE_TYPE_FORM);
params.put(ResourceEditingHelper.CREATE_SUB_TYPE, formTypeId);
params.put(FormHelper.PRESENTATION_TEMPLATE_ID, template.getId().getValue());
params.put(FormHelper.PRESENTATION_ITEM_DEF_ID, itemDefId);
params.put(FormHelper.PRESENTATION_ITEM_DEF_NAME, itemDef.getName());
return params;
}
/**
* Check to see that all form creation parameters are set and valid. Throws IllegalArgumentException on any errors.
*
* @param presentationId
* Presentation from which the form is being edited
* @param formTypeId
* Form type ID for the form to be edited
* @param itemDefId
* Presentation Item Definition ID of the "slot" for the item
*/
protected void checkFormCreateParameters(String presentationId, String formTypeId, String itemDefId) {
Presentation presentation = getPresentation(presentationId);
if (presentation == null)
throw new IllegalArgumentException("Cannot edit nonexistent presentation");
PresentationTemplate template = presentation.getTemplate();
if (!Presentation.TEMPLATE_TYPE.equals(presentation.getPresentationType()) || template == null)
throw new IllegalArgumentException("Cannot edit form because presentation [ID: " + presentationId + "] has no template.");
if (formTypeId == null)
throw new IllegalArgumentException("Cannot create null-typed forms");
PresentationItemDefinition itemDef = null;
for (PresentationItemDefinition def : (Collection<PresentationItemDefinition>) presentation.getTemplate().getItemDefinitions())
if (def.getId().getValue().equals(itemDefId))
itemDef = def;
if (itemDef == null)
throw new IllegalArgumentException("Cannot edit form because presentation [ID: " + presentationId + "] "
+ "does not contain item definition [ID: " + itemDefId + "].");
if (!formTypeId.equals(itemDef.getType()))
throw new IllegalArgumentException("Presentation [ID: " + presentationId + "] does not accept forms of type: " + formTypeId);
}
/**
* Check to see that all form editing parameters are set and valid. Throws IllegalArgumentException on any errors.
*
* @param presentationId
* Presentation from which the form is being edited
* @param formTypeId
* Form type ID for the form to be edited
* @param formId
* The specific artifact ID to edit
* @param itemDefId
* Presentation Item Definition ID of the "slot" for the item
*/
protected void checkFormEditParameters(String presentationId, String formTypeId, String formId, String itemDefId) {
checkFormCreateParameters(presentationId, formTypeId, itemDefId);
if (formId == null)
throw new IllegalArgumentException("Cannot edit null form");
if (contentHostingService.resolveUuid(formId) == null)
throw new IllegalArgumentException("Cannot edit nonexistent form");
}
public String getFormType(String formId) {
return null;
}
public void saveOptions(String presentationId, String artifactId) {
try {
Presentation presentation = getPresentation(presentationId);
String formId = contentHostingService.resolveUuid(artifactId);
contentHostingService.checkResource(formId);
// Check the form type with the options form type. Multiple tabs can stomp each others' session state,
// forcing an attempt to save the wrong type as the options form, which is unrecoverable from the UI.
PresentationTemplate template = presentation.getTemplate();
StructuredArtifact bean = (StructuredArtifact) artifactFinder.load(idManager.getId(artifactId));
if (template == null || Presentation.FREEFORM_TYPE.equals(presentation.getPresentationType()))
throw new IllegalArgumentException("Presentation has no template or is free-form, so options cannot be saved.");
else if (template.getPropertyFormType() == null)
throw new IllegalArgumentException("Presentation has no options form type set, so options cannot be saved.");
else if (bean == null || !template.getPropertyFormType().equals(bean.getHome().getType().getId()))
throw new IllegalArgumentException(
"Form type mismatch, so options cannot be saved. Are you attempting to edit multiple forms simultaneously?");
presentation.setPropertyForm(idManager.getId(artifactId));
presentationManager.storePresentation(presentation);
} catch (PermissionException e) {
log.warn("Cannot attach unreadable options form [] to presentation [].");
} catch (IdUnusedException e) {
throw new IllegalArgumentException("Cannot find options form: " + artifactId);
} catch (TypeException e) {
throw new RuntimeException("Cannot attach collection [" + artifactId + "] to presentation [" + presentationId + "] as options form.");
}
}
/**
** Parse role id and return Site title
**/
private String getSiteFromRoleMember( String roleMember ) {
Reference ref = EntityManager.newReference( roleMember );
String siteId = ref.getContainer();
String siteTitle = "";
try {
siteTitle = siteService.getSite(siteId).getTitle();
}
catch (IdUnusedException e) {
log.warn(e.toString());
}
return siteTitle;
}
/**
** Get authorized share list from the database for this portfolio, return a list of Agent objects
**/
public List getShareList( Presentation presentation ) {
List authzList = authzManager.getAuthorizations(null,
AudienceSelectionHelper.AUDIENCE_FUNCTION_PORTFOLIO,
presentation.getId() );
ArrayList shareList = new ArrayList(authzList.size());
for (Iterator it=authzList.iterator(); it.hasNext(); ) {
Agent agent = ((Authorization)it.next()).getAgent();
if ( agent.isRole() ) {
String worksiteName = getSiteFromRoleMember(agent.getId().getValue());
agent = new AgentWrapper( agent, worksiteName );
}
shareList.add( agent );
}
return shareList;
}
public Map<String, Object> getPresentationArtifacts(String presentationId) {
Presentation presentation = getPresentation(presentationId);
Map<String, Object> model = new HashMap<String, Object>();
Map<String, Object> artifacts = new HashMap<String, Object>();
Map<String, Object> artifactCache = new HashMap<String, Object>();
Map<String, Object> itemHash = new HashMap<String, Object>();
Agent agent = authnManager.getAgent();
// Create list of item definition types for this template
PresentationTemplate template = presentationManager.getPresentationTemplate(presentation.getTemplate().getId());
presentation.setTemplate(template);
model.put("types", template.getSortedItems());
// Create sorted list of artifacts eligible for inclusion in portfolio
for (PresentationItemDefinition itemDef : (Set<PresentationItemDefinition>) template.getSortedItems()) {
if (artifactCache.containsKey(itemDef.getType()) && !itemDef.getHasMimeTypes()){
artifacts.put(itemDef.getId().getValue(), artifactCache.get(itemDef.getType()));
}
else {
List itemArtifacts = (List)presentationManager.loadArtifactsForItemDef(itemDef, agent);
// Update display name of resource content to include abbreviated folder name
if (itemArtifacts.size() > 0 && itemArtifacts.get(0) instanceof ContentResourceArtifact) {
// don't do this for forms, as their display name is OK as is
if (! ((ContentResourceArtifact)itemArtifacts.get(0)).getBase().getContentType().equals("application/x-osp"))
for (ContentResourceArtifact art: (List<ContentResourceArtifact>)itemArtifacts)
art.setDisplayName( abbreviateResourceName(art) );
}
// Sort artifacts by display name (wizards also sorted by date)
if (itemArtifacts.size() > 0 && itemArtifacts.get(0) instanceof CompletedWizard)
Collections.sort((List<CompletedWizard>)itemArtifacts, new SortWizards());
else
Collections.sort((List<Artifact>)itemArtifacts, new SortArtifacts());
// cache only full list
if (!itemDef.getHasMimeTypes()) {
artifactCache.put(itemDef.getType(), itemArtifacts);
}
artifacts.put(itemDef.getId().getValue(), itemArtifacts);
}
}
// Create map of presentation items currently included in portfolio
for (Iterator it = presentation.getPresentationItems().iterator(); it.hasNext();) {
PresentationItem item = (PresentationItem) it.next();
String itemId = item.getDefinition().getId().getValue() + "." + item.getArtifactId();
if ( ! item.getDefinition().getIsFormType().booleanValue() )
{
itemHash.put( itemId, WIZARD_ITEM_PLACEHOLDER );
continue;
}
List artifactList = (List)artifacts.get( item.getDefinition().getId().getValue() );
ContentResourceArtifact itemArtifact = null;
// search for artifact corresponding to presentation item
for (Iterator aIt = artifactList.iterator(); aIt.hasNext();) {
ContentResourceArtifact artifact = (ContentResourceArtifact)aIt.next();
if ( artifact.getId().getValue().equals(item.getArtifactId().getValue()) ) {
itemArtifact = artifact;
break;
}
}
// load artifact if not found (e.g. artifact added by collaborative author)
if ( itemArtifact == null ) {
itemArtifact = presentationManager.loadArtifactForItem(item);
if ( itemArtifact != null )
artifactList.add(itemArtifact);
}
// add itemArtifact to map
itemHash.put( itemId, itemArtifact );
}
model.put("itemHash", itemHash);
model.put("artifacts", artifacts);
return model;
}
private int FOLDER_MAX_LEN = 16; // maximum display size for folder name
private int FOLDER_ABBR_SIZE = 7; // abbreviated folder name prefix/suffix size
private String FOLDER_ABBR_TOKEN = ".."; // abbreviated folder name token
/**
* Prepend containing folder name to resource name, abbreviating if too long
*/
private String abbreviateResourceName(ContentResourceArtifact art) {
String folder = art.getBase().getContainingCollection().getProperties().getProperty(ResourceProperties.PROP_DISPLAY_NAME);
if (folder.length() > FOLDER_MAX_LEN) {
int len = folder.length();
StringBuilder newFolder = new StringBuilder(folder.substring(0, FOLDER_ABBR_SIZE));
newFolder.append(FOLDER_ABBR_TOKEN);
newFolder.append(folder.substring(len - FOLDER_ABBR_SIZE, len));
folder = newFolder.toString();
}
StringBuilder resourceName = new StringBuilder(folder);
resourceName.append(Entity.SEPARATOR);
resourceName.append(art.getDisplayName());
return resourceName.toString();
}
/**
* Sort artifacts by display name
*/
protected class SortArtifacts implements Comparator<Artifact> {
public int compare(Artifact o1, Artifact o2) {
return o1.getDisplayName().compareTo(o2.getDisplayName());
}
}
/**
* Sort Wizards by name and date (in case any share the same name)
*/
protected class SortWizards implements Comparator<CompletedWizard> {
public int compare(CompletedWizard o1, CompletedWizard o2) {
if (o1.getDisplayName().equals(o2.getDisplayName())) {
return o1.getCreated().compareTo(o2.getCreated());
}
else {
return o1.getDisplayName().compareTo(o2.getDisplayName());
}
}
}
protected String getFormsFolder() {
String idChunk = PresentationManager.PRESENTATION_FORMS_FOLDER;
String displayName = resourceBundle.getString(PresentationManager.PRESENTATION_FORMS_FOLDER_DISPNAME);
String description = resourceBundle.getString(PresentationManager.PRESENTATION_FORMS_FOLDER_DESC);
return getFolder(idChunk, displayName, description);
}
protected String getPropertiesFolder() {
String idChunk = PresentationManager.PRESENTATION_PROPERTIES_FOLDER;
String displayName = resourceBundle.getString(PresentationManager.PRESENTATION_PROPERTIES_FOLDER_DISPNAME);
String description = resourceBundle.getString(PresentationManager.PRESENTATION_PROPERTIES_FOLDER_DESC);
return getFolder(idChunk, displayName, description);
}
protected String getFolder(String idChunk, String displayName, String description) {
try {
String folderBase = getUserCollection().getId();
Placement placement = toolManager.getCurrentPlacement();
String currentSite = placement.getContext();
String rootDisplayName = resourceBundle.getString(PresentationManager.PORTFOLIO_INTERACTION_FOLDER_DISPNAME);
String rootDescription = resourceBundle.getString(PresentationManager.PORTFOLIO_INTERACTION_FOLDER_DESC);
String folderPath = createFolder(folderBase, "portfolio-interaction", rootDisplayName, rootDescription);
folderPath = createFolder(folderPath, currentSite, siteService.getSiteDisplay(currentSite), null);
folderPath = createFolder(folderPath, idChunk, displayName, description);
return folderPath;
} catch (TypeException e) {
throw new RuntimeException("Failed to redirect to helper", e);
} catch (IdUnusedException e) {
throw new RuntimeException("Failed to redirect to helper", e);
} catch (PermissionException e) {
throw new RuntimeException("Failed to redirect to helper", e);
}
}
protected ContentCollection getUserCollection() throws TypeException, IdUnusedException, PermissionException {
User user = UserDirectoryService.getCurrentUser();
String userId = user.getId();
String wsId = siteService.getUserSiteId(userId);
String wsCollectionId = contentHostingService.getSiteCollection(wsId);
ContentCollection collection = contentHostingService.getCollection(wsCollectionId);
return collection;
}
protected String createFolder(String base, String append, String appendDisplay, String appendDescription) {
String folder = base + append + "/";
try {
ContentCollectionEdit propFolder = contentHostingService.addCollection(folder);
propFolder.getPropertiesEdit().addProperty(ResourceProperties.PROP_DISPLAY_NAME, appendDisplay);
propFolder.getPropertiesEdit().addProperty(ResourceProperties.PROP_DESCRIPTION, appendDescription);
contentHostingService.commitCollection(propFolder);
return propFolder.getId();
} catch (IdUsedException e) {
// ignore... it is already there.
} catch (Exception e) {
throw new RuntimeException(e);
}
return folder;
}
public void setIdManager(IdManager idManager) {
this.idManager = idManager;
}
public void setAuthnManager(AuthenticationManager authnManager) {
this.authnManager = authnManager;
}
public void setAgentManager(AgentManager agentManager) {
this.agentManager = agentManager;
}
public void setAuthzManager(AuthorizationFacade authzManager) {
this.authzManager = authzManager;
}
public void setPresentationManager(PresentationManager presentationManager) {
this.presentationManager = presentationManager;
}
public void setToolManager(ToolManager toolManager) {
this.toolManager = toolManager;
}
public IdCustomEditor getIdCustomEditor() {
return idCustomEditor;
}
public void setIdCustomEditor(IdCustomEditor idCustomEditor) {
this.idCustomEditor = idCustomEditor;
}
public TypedPropertyEditor getPresentationItemCustomEditor() {
return presentationItemCustomEditor;
}
public void setPresentationItemCustomEditor(TypedPropertyEditor presentationItemCustomEditor) {
this.presentationItemCustomEditor = presentationItemCustomEditor;
}
public TypedPropertyEditor getPresentationViewerCustomEditor() {
return presentationViewerCustomEditor;
}
public void setPresentationViewerCustomEditor(TypedPropertyEditor presentationViewerCustomEditor) {
this.presentationViewerCustomEditor = presentationViewerCustomEditor;
}
public void setSiteService(SiteService siteService) {
this.siteService = siteService;
}
public void setContentHostingService(ContentHostingService contentHostingService) {
this.contentHostingService = contentHostingService;
}
public void setServerConfigurationService(ServerConfigurationService serverConfigurationService) {
this.serverConfigurationService = serverConfigurationService;
}
public void setArtifactFinder(ArtifactFinder artifactFinder) {
this.artifactFinder = artifactFinder;
}
}