/**********************************************************************************
* $URL:https://source.sakaiproject.org/svn/osp/trunk/presentation/tool/src/java/org/theospi/portfolio/presentation/control/ListPresentationController.java $
* $Id:ListPresentationController.java 9134 2006-05-08 20:28:42Z chmaurer@iupui.edu $
***********************************************************************************
*
* Copyright (c) 2005, 2006, 2007, 2008 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.osedu.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.control;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Collection;
import java.util.Iterator;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.sakaiproject.component.api.ServerConfigurationService;
import org.sakaiproject.entity.api.ResourceProperties;
import org.sakaiproject.exception.IdUnusedException;
import org.sakaiproject.exception.IdUsedException;
import org.sakaiproject.exception.InUseException;
import org.sakaiproject.exception.PermissionException;
import org.sakaiproject.metaobj.shared.model.Agent;
import org.sakaiproject.metaobj.utils.mvc.intf.ListScrollIndexer;
import org.sakaiproject.site.cover.SiteService;
import org.sakaiproject.spring.util.SpringTool;
import org.sakaiproject.tool.cover.ToolManager;
import org.sakaiproject.tool.cover.SessionManager;
import org.sakaiproject.tool.api.Tool;
import org.sakaiproject.user.api.Preferences;
import org.sakaiproject.user.api.PreferencesEdit;
import org.sakaiproject.user.cover.PreferencesService;
import org.springframework.validation.Errors;
import org.springframework.web.servlet.ModelAndView;
import org.theospi.portfolio.presentation.model.Presentation;
import org.theospi.portfolio.presentation.PresentationManager;
import org.theospi.portfolio.presentation.PresentationFunctionConstants;
import org.theospi.portfolio.presentation.model.Presentation;
import org.theospi.portfolio.security.AudienceSelectionHelper;
import org.theospi.portfolio.presentation.support.PresentationService;
public class ListPresentationController extends AbstractPresentationController {
protected final Log logger = LogFactory.getLog(getClass());
private ListScrollIndexer listScrollIndexer;
private ServerConfigurationService serverConfigurationService;
protected PresentationService presentationService;
private final static String PORTFOLIO_PREFERENCES = "org.theospi.portfolio.presentation.placement.";
private final static String PREF_HIDDEN = "org.theospi.portfolio.presentation.hidden.";
private final static String PREF_FILTER = "org.theospi.portfolio.presentation.filter.";
private final static String PREF_SORT_ORDER = "org.theospi.portfolio.presentation.sortOrder.";
private final static String PREF_SORT_KEY = "org.theospi.portfolio.presentation.sortKey.";
private final static String PREF_FILTER_VALUE_ALL = "all"; // deprecated - but keep for parsing old preferences
private final static String PREF_FILTER_VALUE_PUBLIC = "public";
private final static String PREF_FILTER_VALUE_MINE = "mine";
private final static String PREF_FILTER_VALUE_SHARED = "shared";
private final static String SORTCOLUMN_KEY = "sortOn";
private static final Object SORTORDER_KEY = "sortorder";
private static final String SORTORDER_ISASCENDING_KEY = "sortOrderIsAscending";
// NOTE that this list needs to be synced with the values in the listPresention.jsp
private static final String SORTORDER_ASCENDING = "ascending";
private static final String NAME_COLUMNKEY = "name";
private static final String DATEMODIFIED_COLUMNKEY = "dateModified";
private static final String OWNER_COLUMNKEY = "owner";
private static final String REVIEWED_COLUMNKEY = "reviewed";
private static final Map<String, Comparator<Presentation>> sortName2PresentationComparator = initSortName2PresentationComparator();
private static final Map<String, Comparator<Presentation>> initSortName2PresentationComparator() {
Map<String, Comparator<Presentation>> result = new HashMap<String, Comparator<Presentation>>(4);
result.put(NAME_COLUMNKEY,
new PresentationComparators.ByNameComparator());
result.put(DATEMODIFIED_COLUMNKEY,
new PresentationComparators.ByDateModifiedComparator());
result.put(OWNER_COLUMNKEY,
new PresentationComparators.ByOwnerComparator());
result.put(REVIEWED_COLUMNKEY,
new PresentationComparators.ByReviewedComparator());
return result;
}
@SuppressWarnings("unchecked")
public ModelAndView handleRequest(Object requestModel, Map request, Map session, Map application, Errors errors) {
Hashtable<String, Object> model = new Hashtable<String, Object>();
Agent currentAgent = getAuthManager().getAgent();
String currentToolId = ToolManager.getCurrentPlacement().getId();
String worksiteId = getWorksiteManager().getCurrentWorksiteId().getValue();
String showHidden = getUserPreferenceProperty(PREF_HIDDEN,
(String)request.get("showHiddenKey"),
PresentationManager.PRESENTATION_VIEW_VISIBLE);
String filterList = getUserPreferenceProperty(PREF_FILTER,
(String)request.get("filterListKey"),
PREF_FILTER_VALUE_MINE);
String sortColumn = getUserPreferenceProperty(PREF_SORT_KEY,
(String)request.get(SORTCOLUMN_KEY),
NAME_COLUMNKEY);
String sortOrder = getUserPreferenceProperty(PREF_SORT_ORDER,
(String)request.get(SORTORDER_KEY),
SORTORDER_ASCENDING);
// Reset deprecated 'ALL' preference with 'MINE' preference
if ( filterList.equals(PREF_FILTER_VALUE_ALL) )
filterList = PREF_FILTER_VALUE_MINE;
Collection presentations = null;
String filterToolId = null;
boolean viewAll = getServerConfigurationService().getBoolean("osp.presentation.viewall", false) &&
getAuthzManager().isAuthorized(PresentationFunctionConstants.REVIEW_PRESENTATION,
getIdManager().getId(ToolManager.getCurrentPlacement().getContext()));
// If not on MyWorkspace, grab presentations for this tool only
if ( ! isOnWorkspaceTab() )
filterToolId = currentToolId;
if ( filterList.equals(PREF_FILTER_VALUE_MINE) )
{
presentations = getPresentationManager().findOwnerPresentations(currentAgent, filterToolId, showHidden);
}
else if ( filterList.equals(PREF_FILTER_VALUE_SHARED) )
{
if ( viewAll && !isOnWorkspaceTab() )
presentations = getPresentationManager().findOtherPresentationsUnrestricted(currentAgent, filterToolId, showHidden);
else
presentations = getPresentationManager().findSharedPresentations(currentAgent, filterToolId, showHidden);
}
else // ( filterList.equals(PREF_FILTER_VALUE_PUBLIC) )
{
presentations = getPresentationManager().findPublicPresentations(currentAgent, filterToolId, showHidden);
}
// Sort the presentations
Boolean sortOrderIsAscending = SORTORDER_ASCENDING.equals(sortOrder) ? true : false;
sortPresentations(presentations, sortColumn, sortOrderIsAscending);
List presSubList = getListScrollIndexer().indexList(request, model, new ArrayList(presentations), true);
model.put("presentations", getPresentationData(presSubList) );
List templates = presentationService.getAvailableTemplates();
model.put("createAvailable", presentationService.isFreeFormEnabled() || templates.size() > 0);
model.put(SORTORDER_ISASCENDING_KEY, sortOrderIsAscending);
model.put(SORTCOLUMN_KEY, sortColumn);
model.put("baseUrl", PresentationService.VIEW_PRESENTATION_URL);
model.put("worksite", getWorksiteManager().getSite(worksiteId));
model.put("tool", getWorksiteManager().getTool(currentToolId));
model.put("isMaintainer", isMaintainer());
model.put("osp_agent", currentAgent);
model.put("showHidden", showHidden);
model.put("filterList", filterList);
model.put("myworkspace", isOnWorkspaceTab() );
model.put("lastViewKey", SpringTool.LAST_VIEW_VISITED);
return new ModelAndView("success", model);
}
/** Sort given collection of presentations, using given sortColumn in ascending or descending order
**
**/
private void sortPresentations(final Collection<Presentation> presentations,
final String sortColumn, final Boolean inAscendingOrder)
{
Comparator<Presentation> comparator = sortName2PresentationComparator.get(sortColumn);
if (comparator != null) {
if (!inAscendingOrder) {
comparator = Collections.reverseOrder(comparator);
}
Collections.sort((List)presentations, comparator);
}
else {
logger.error("no comparator defined for column " + sortColumn);
}
}
/**
** If prefValue provided, save it and return,
** otherwise retrieve stored prefValue for given prefKey
**
** @param prefKey preference key
** @param prefValue optional new value to save
** @param dfltValue default value
*/
protected String getUserPreferenceProperty(String prefKey, String prefValue, String dfltValue)
{
String propsName = PORTFOLIO_PREFERENCES + ToolManager.getCurrentPlacement().getId();
String userId = getAuthManager().getAgent().getId().getValue();
// If no preference was provided in request, then get saved preference
if ( prefValue == null ) {
Preferences userPreferences = PreferencesService.getPreferences(userId);
ResourceProperties portfolioPrefs = userPreferences.getProperties(propsName);
prefValue = portfolioPrefs.getProperty(prefKey);
// If prefValue found, just return
if ( prefValue != null )
return prefValue;
// Otherwise, use the default value and continue to save
else
prefValue = dfltValue;
}
// Otherwise, save preference and return
PreferencesEdit prefEdit = null;
try {
prefEdit = (PreferencesEdit) PreferencesService.add(userId);
}
catch (PermissionException e) {
logger.warn(e.toString());
}
catch (IdUsedException e) {
// Preferences already exist, just edit
try {
prefEdit = (PreferencesEdit) PreferencesService.edit(userId);
}
catch (Exception e2) {
logger.warn(e2.toString());
}
}
if (prefEdit != null) {
try {
ResourceProperties propEdit = prefEdit.getPropertiesEdit(propsName);
propEdit.addProperty(prefKey, prefValue);
PreferencesService.commit(prefEdit);
}
catch (Exception e) {
logger.warn(e.toString());
}
}
return prefValue;
}
/**
* See if the current tab is the workspace tab.
* @return true if we are currently on the "My Workspace" tab.
*/
private boolean isOnWorkspaceTab()
{
return SiteService.isUserSite(ToolManager.getCurrentPlacement().getContext());
}
public ListScrollIndexer getListScrollIndexer() {
return listScrollIndexer;
}
public void setListScrollIndexer(ListScrollIndexer listScrollIndexer) {
this.listScrollIndexer = listScrollIndexer;
}
public ServerConfigurationService getServerConfigurationService() {
return serverConfigurationService;
}
public void setServerConfigurationService(
ServerConfigurationService serverConfigurationService) {
this.serverConfigurationService = serverConfigurationService;
}
public void setPresentationService(PresentationService presentationService) {
this.presentationService = presentationService;
}
/** Given a list of presentations, this method returns a list of PresentationDataBean objects
**/
public List getPresentationData( List presList ) {
ArrayList presData = new ArrayList( presList.size() );
for (Iterator it = presList.iterator(); it.hasNext();) {
Presentation pres = (Presentation) it.next();
presData.add( new PresentationDataBean( pres ) );
}
return presData;
}
/** This class provides auxiliary data (comments, shared status) for a given presentation
**/
public class PresentationDataBean {
Presentation m_presentation;
int m_commentNum;
boolean m_shared = false;
boolean m_public = false;
boolean m_collab = false;
public PresentationDataBean( Presentation presentation ) {
m_presentation = presentation;
// determine shared attributes (public is considered shared)
if ( presentation.getIsPublic() ) {
m_public = true;
}
List authzs = getAuthzManager().getAuthorizations(null, AudienceSelectionHelper.AUDIENCE_FUNCTION_PORTFOLIO, presentation.getId());
if (authzs.size() > 0)
m_shared = true;
// Determine if user can collaboratively edit this portfolio
if ( presentation.getIsCollab() &&
getAuthzManager().isAuthorized(PresentationFunctionConstants.VIEW_PRESENTATION, presentation.getId()) ) {
m_collab = true;
}
// find number of comments
List comments = getPresentationManager().getPresentationComments( presentation.getId(), getAuthManager().getAgent() );
if ( comments.size() > 0 || presentation.isAllowComments() ) {
m_commentNum = comments.size();
}
else {
m_commentNum = -1; // comments not allowed
}
}
public Presentation getPresentation() {
return m_presentation;
}
public int getCommentNum() {
return m_commentNum;
}
public String getCommentNumAsString() {
StringBuilder commentStr = new StringBuilder();
if ( m_commentNum >= 0 ) {
commentStr.append( "(" );
commentStr.append( String.valueOf(m_commentNum) );
commentStr.append( ")" );
}
return commentStr.toString();
}
public boolean getShared() {
return m_shared;
}
public boolean getPublic() {
return m_public;
}
public boolean getIsCollab() {
return m_collab;
}
}
}