Java ToolConfiguration类代码示例

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
private void addSynopticTool(SitePage page, String toolId,
		String toolTitle, String layoutHint, int position) {
	page.setLayout(SitePage.LAYOUT_DOUBLE_COL);
	
	// Add synoptic announcements tool
	ToolConfiguration tool = page.addTool();
	Tool reg = ToolManager.getTool(toolId);
	tool.setTool(toolId, reg);
	tool.setTitle(toolTitle);
	tool.setLayoutHints(layoutHint);
	
	// count how many synoptic tools in the second/right column
	int totalSynopticTools = 0;
	for (ToolConfiguration t : page.getTools())
	{
		if (t.getToolId() != null && SYNOPTIC_TOOL_ID_MAP.containsKey(t.getToolId()))
		{
			totalSynopticTools++;
		}
	}
	// now move the newly added synoptic tool to proper position
	for (int i=0; i< (totalSynopticTools-position-1);i++)
	{
		tool.moveUp();
	}
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
/**
 * Helper to add a tool to a site if the site does not contain an instance of the tool.
 * <p>
 * Note that it does NOT save the site. The caller must handle this.
 *
 * @param site   the site to check
 * @param toolId the tool to add (eg sakai.resources)
 * @return site the updated site object
 */
private Site addToolToSiteIfMissing(Site site, String toolId) {

    if (site.getToolForCommonId(toolId) != null) {
        return site;
    }

    log.debug("Adding tool to site: {}, tool: {}", site.getId(), toolId);

    SitePage page = site.addPage(); //inherit the tool's title.

    ToolConfiguration tool = page.addTool();
    tool.setTool(toolId, toolManager.getTool(toolId));
    tool.setTitle(toolManager.getTool(toolId).getTitle());

    return site;
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
/**
 * Process tool adds
 * @return
 */
public String addTools () {    
    for (int i = 0; i < selectedTools.length; i++) {
        SitePage page;
        try {
            page = site.addPage();
            Tool tool = toolManager.getTool(selectedTools[i]);
            page.setTitle(tool.getTitle());
            ToolConfiguration placement = page.addTool(tool.getId());
            siteService.save(site);
            EventTrackingService.post(
                EventTrackingService.newEvent(PAGE_ADD, "/site/" + site.getId() +
                    "/page/" + page.getId() +
                    "/tool/" + selectedTools[i] +
                    "/placement/" + placement.getId(), false));
        }
        catch(Exception e) {
            throw UniversalRuntimeException.accumulate(e, "Error adding tool " + selectedTools[i]);
            }
    }
  
    return "success";
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
/**
 * Checks if users can see a page or not
 * 
 * @param page The SitePage whose visibility is in question
 * @return true if users can see the page
 */
public boolean isVisible(SitePage page) {
    List<ToolConfiguration> tools = page.getTools();
    Iterator<ToolConfiguration> iPt = tools.iterator();

    boolean visible = false;
    while( !visible && iPt.hasNext() ) 
    {
        ToolConfiguration placement = iPt.next();
        Properties roleConfig = placement.getConfig();
        String visibility = roleConfig.getProperty(PORTAL_VISIBLE);

        if ( ! "false".equals(visibility) ) visible = true;
    }
    
    return visible;
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
/**
 * JavaDoc can be found org.sakaiproject.calendar.api.CalendarService.
 * @param siteId
 * @return
 */
public List<String> getCalendarReferences(String siteId) {
	// get merged calendars channel refs
	String initMergeList = null;
	try {
		ToolConfiguration tc = m_siteService.getSite(siteId).getToolForCommonId("sakai.schedule");
		if (tc != null) {
			initMergeList = tc.getPlacementConfig().getProperty("mergedCalendarReferences");
		}
	} catch (IdUnusedException e){
		initMergeList = null;
	}
	
	// load all calendar channels (either primary or merged calendars)
	String primaryCalendarReference = calendarReference(siteId, SiteService.MAIN_CONTAINER);
	MergedList mergedCalendarList = loadChannels(siteId, primaryCalendarReference, initMergeList, null);
	
	// add external calendar subscriptions
	List referenceList = mergedCalendarList.getReferenceList();
	Set subscriptionRefList = externalCalendarSubscriptionService.getCalendarSubscriptionChannelsForChannels(primaryCalendarReference,referenceList);
	referenceList.addAll(subscriptionRefList);
	
	return referenceList;
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
/**
 * Adds a new single tool page to the current site
 * @param toolId
 * @param title
 * @return the newly added SitePage
 */
public SitePage addPage (String toolId, String title) {
    SitePage page;
    try {
        page = site.addPage();
        page.setTitle(title);
        ToolConfiguration placement = page.addTool(toolId);        
        siteService.save(site);
        EventTrackingService.post(
            EventTrackingService.newEvent(PAGE_ADD, "/site/" + site.getId() +
                "/page/" + page.getId() +
                "/tool/" + toolId +
                "/placement/" + placement.getId(), false));
    }
    catch (Exception e) {
        throw UniversalRuntimeException.accumulate(e, "Error adding page " + title);
    }
    init();
    
    return page;
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
/**
 * Resets page title to the default and resets titleCustom flag
 * 
 * @param pageId The Id of the Page
 * @return reset page title
 * @throws IdUnusedException, PermissionException
 */
public String resetTitle(String pageId) throws IdUnusedException, PermissionException {
    SitePage page = site.getPage(pageId);
    String oldTitle = page.getTitle();
    page.setTitleCustom(false);
    String newTitle = page.getTitle();
    page.setTitle(newTitle);

    // TODO: Find a way to call each tool to ask what fields they need configured
    // and what methods to use to validate the input..
    if (page.getTools().size() == 1) {
        ToolConfiguration tool = page.getTools().get(0);
        tool.setTitle(newTitle);
    }

    saveSite(site);
    
    EventTrackingService.post(
        EventTrackingService.newEvent(PAGE_RENAME, "/site/" + site.getId() +
                                    "/page/" + page.getId() +
                                    "/old_title/" + oldTitle +
                                    "/new_title/" + page.getTitle(), false));
    
    
    return newTitle;
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
private void checkTool(Site site) {
	if(site != null)		
	{
		//check user can access the tool, it might be hidden
		Collection col = site.getTools(TOOL_COMMON_ID);			
		if(col == null || col.isEmpty())
			throw new EntityNotFoundException("No tool "+TOOL_COMMON_ID+" in site: " + site.getId(), site.getId());
			
		for(Object o : col)
		{
			ToolConfiguration toolConfig = (ToolConfiguration)o;
			if(!toolManager.isVisible(site, toolConfig))
				throw new EntityNotFoundException("No access to tool in site: " + site.getId(), site.getId());
		}
	}
	else
		throw new EntityNotFoundException("Invalid site", "-null-");
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
/**
 * @inheritDoc
 */
@Override
public String channelReference(String context, String id)
{
    /* SAK-19516: for MOTD and Admin Workspace Announcements, the channel reference 
     * is not calculated based on the context and id, but pulled from SAKAI_TOOL_PROPERTY 'channel'.
     */
	String channelRef = null;
	try {
		ToolConfiguration tool = m_siteService.getSite(context).getToolForCommonId(SAKAI_ANNOUNCEMENT_TOOL_ID);
		if (tool != null) {
			channelRef = tool.getConfig().getProperty(ANNOUNCEMENT_CHANNEL_PROPERTY, null);
		}
	} catch (IdUnusedException e) {
	    // ignore the error, continue with the default method
	    log.debug("Could not find channelRef in channel property, falling back to default method...");
	}
	
	if (channelRef == null || channelRef.trim().length() == 0) {
		channelRef = super.channelReference(context, id);
	}
	return channelRef;

}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
public static boolean sakaiInfo(Properties props, String context, String placementId, ResourceLoader rb)
{

	Site site = null;
	try {
		site = SiteService.getSite(context);
	} catch (Exception e) {
		log.error("No site/page associated with Launch context={}", context);
		return false;
	}

	// Add the generic information
	addGlobalData(site, props, null, rb);
	ToolConfiguration placement = SiteService.findTool(placementId);
	Properties config = placement.getConfig();
	String roleMapProp = toNull(getCorrectProperty(config, "rolemap", placement));
	addRoleInfo(props, null, context, roleMapProp);
	addSiteInfo(props, null, site);

	// Add Placement Information
	addPlacementInfo(props, placementId);
	return true;
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
public static String[] postLaunchHTML(String placementId, ResourceLoader rb)
{
	if ( placementId == null ) return postError("<p>" + getRB(rb, "error.missing" ,"Error, missing placementId")+"</p>" );
	ToolConfiguration placement = SiteService.findTool(placementId);
	if ( placement == null ) return postError("<p>" + getRB(rb, "error.load" ,"Error, cannot load placement=")+placementId+".</p>");

	// Add user, course, etc to the launch parameters
	Properties ltiProps = new Properties();
	if ( ! sakaiInfo(ltiProps, placement, rb) ) {
		return postError("<p>" + getRB(rb, "error.missing",
					"Error, cannot load Sakai information for placement=")+placementId+".</p>");
	}

	// Retrieve the launch detail
	Properties toolProps = new Properties();
	if ( ! loadFromPlacement(toolProps, ltiProps, placement) ) {
		return postError("<p>" + getRB(rb, "error.nolaunch" ,"Not Configured.")+"</p>");
	}
	return postLaunchHTML(toolProps, ltiProps, rb);
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
@Override
protected void completeAddResourceEventValidations(Event event, Map<String, Object> validationContext)
        throws IllegalArgumentException, IllegalStateException {
    final String resourceName = (String)validationContext.get(ADD_RESOURCE_VALIDATION_KEY_RESOURCE_NAME);
    final EntityContentProducer ecp = (EntityContentProducer)validationContext.get(ADD_RESOURCE_VALIDATION_KEY_CONTENT_PRODUCER);

    String siteId = ecp.getSiteId(resourceName);

    if (onlyIndexSearchToolSites) {
        try {
            Site s = siteService.getSite(siteId);
            ToolConfiguration t = s.getToolForCommonId(SEARCH_TOOL_ID);
            if (t == null) {
                throw new IllegalArgumentException("Resource name [" + resourceName + "] for event [" + event
                        + "] not indexable because it is not associated with a site that has the search tool");
            }
        } catch (Exception ex) {
            throw new IllegalArgumentException("Event [" + event
                    + "] not indexable because it is not associated with a site");
        }
    }
    validationContext.put(ADD_RESOURCE_VALIDATION_KEY_SITE_ID, siteId);
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
public Site getSiteIfCurrentUserCanAccessTool(String siteId) {

        Site site;
        try {
            site = siteService.getSiteVisit(siteId);
        } catch (Exception e) {
            return null;
        }

        //check user can access the tool, it might be hidden
        ToolConfiguration toolConfig = site.getToolForCommonId("sakai.commons");
        if(!toolManager.isVisible(site, toolConfig)) {
            return null;
        }

        return site;
    }
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
private void setToolProperties(ToolConfiguration tool, String propList) {
    if(propList != null) {
        for(String prop : propList.split(",")) {
            if(StringUtils.isNotEmpty(prop)) {
                int index = prop.indexOf(":");
                if(index >= 0) {
                    try {
                        String propName = prop.substring(0, index);
                        String propValue = prop.substring(index+1);
                        
                        if(StringUtils.isNotEmpty(propValue)) {
                            Properties propsedit = tool.getPlacementConfig();
                            propsedit.setProperty(propName, propValue);
                        }
                    } catch(Exception e){
                        log.error("SakaiScript: setToolProperties(): " + e.getClass().getName() + " : " + e.getMessage());
                    }
                }
            }
        }
    }
}
 

import org.sakaiproject.site.api.ToolConfiguration; //导入依赖的package包/类
public String getTimezoneToolUrlForUser() {
    User thisUser = UserDirectoryService.getCurrentUser();
    String userid = thisUser.getId();

    // If there is no user (e.g. on the gateway site!) there's no timezone
    if(StringUtils.isEmpty(userid)) {
        return null;
    }

    try {
        Site userSite = SiteService.getSite("~" + userid);
        ToolConfiguration preferences = userSite.getToolForCommonId("sakai.preferences");
        return String.format("/portal/site/~%s/tool/%s/timezone", userid, preferences.getId());
    } catch (Exception e) {
        log.warn("Couldn't find a timezone tool for user {}", userid, e);
        return null;
    }
}