*

* Part of the InfoGlue Content Management Platform (www.infoglue.org)

*

* ===============================================================================

*

*  Copyright (C)

*

* This program is free software; you can redistribute it and/or modify it under

* the terms of the GNU General Public License version 2, as published by the

* Free Software Foundation. See the file LICENSE.html for more information.

*

* This program is distributed in the hope that it will be useful, but WITHOUT

* ANY WARRANTY, including the implied warranty of MERCHANTABILITY or FITNESS

* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License along with

* this program; if not, write to the Free Software Foundation, Inc. / 59 Temple

* Place, Suite 330 / Boston, MA 02111-1307 / USA.

*

* ===============================================================================

*/

* This class is a helper class for the use case handle InterceptionPoint

*

* @author Mattias Bogeblad

*/

    private final static Logger logger = Logger.getLogger(InterceptionPointController.class.getName());

  public final static Map systemInterceptionPoints = new HashMap();

   

  static

  {

    systemInterceptionPoints.put("ContentTool.Read", new InterceptionPointVO("ContentTool", "ContentTool.Read", "Gives a user access to the content tool", false));

      systemInterceptionPoints.put("ContentTool.ImportExport", new InterceptionPointVO("ContentTool", "ContentTool.ImportExport", "Intercepts exporting and importing of contents", false));

      systemInterceptionPoints.put("ContentTool.ShowMetaInfoFolders", new InterceptionPointVO("ContentTool", "ContentTool.ShowMetaInfoFolders", "Allows the user to see the meta info folders in the content tree", false));

      systemInterceptionPoints.put("ManagementTool.Read", new InterceptionPointVO("ManagementTool", "ManagementTool.Read", "Gives a user access to the management tool", false));

      systemInterceptionPoints.put("MyDesktopTool.Read", new InterceptionPointVO("MyDesktopTool", "MyDesktopTool.Read", "Gives the user access to the mydesktop tool", false));

      systemInterceptionPoints.put("PublishingTool.Read", new InterceptionPointVO("PublishingTool", "PublishingTool.Read", "Gives the user access to the publishing tool", false));

      systemInterceptionPoints.put("StructureTool.Read", new InterceptionPointVO("StructureTool", "StructureTool.Read", "Gives a user access to the structure tool", false));

      systemInterceptionPoints.put("FormsTool.Read", new InterceptionPointVO("FormsTool", "FormsTool.Read", "Gives a user access to the form tool", false));

      systemInterceptionPoints.put("CalendarTool.Read", new InterceptionPointVO("CalendarTool", "CalendarTool.Read", "Gives a user access to the calendar system", false));

      systemInterceptionPoints.put("SearchTool.Read", new InterceptionPointVO("SearchTool", "SearchTool.Read", "Gives a user access to the search tool", false));

     

      systemInterceptionPoints.put("Category.Read", new InterceptionPointVO("Category", "Category.Read", "This intercepts any read towards a category", true));

     

      systemInterceptionPoints.put("Content.Read", new InterceptionPointVO("Content", "Content.Read", "Intercepts the read of a content", true));

      systemInterceptionPoints.put("Content.Write", new InterceptionPointVO("Content", "Content.Write", "Intercepts the write of a content", true));

      systemInterceptionPoints.put("Content.Create", new InterceptionPointVO("Content", "Content.Create", "Intercepts the creation of a new content or folder", true));

      systemInterceptionPoints.put("Content.Delete", new InterceptionPointVO("Content", "Content.Delete", "Intercepts the deletion of a content", true));

      systemInterceptionPoints.put("Content.Move", new InterceptionPointVO("Content", "Content.Move", "Intercepts the movement of a content", true));

      systemInterceptionPoints.put("Content.SubmitToPublish", new InterceptionPointVO("Content", "Content.SubmitToPublish", "Intercepts the submittance to publish of all content versions", true));

      systemInterceptionPoints.put("Content.ChangeAccessRights", new InterceptionPointVO("Content", "Content.ChangeAccessRights", "Intercepts the attempt to change access rights", true));

      systemInterceptionPoints.put("Content.CreateVersion", new InterceptionPointVO("Content", "Content.CreateVersion", "Intercepts the creation of a new contentversion", true));

      systemInterceptionPoints.put("Content.ExpireDateComingUp", new InterceptionPointVO("Content", "Content.ExpireDateComingUp", "Intercepts the event of a content coming close to it's expire date", true));

    systemInterceptionPoints.put("Component.Select", new InterceptionPointVO("Component", "Component.Select", "Intercepts the read of a content when user want to list components to add in a slot", true));

    systemInterceptionPoints.put("Component.EditProperties", new InterceptionPointVO("Component", "Component.EditProperties", "This interception point limits who can see the properties menu in edit on sight", true));

      systemInterceptionPoints.put("ContentTypeDefinition.Read", new InterceptionPointVO("ContentTypeDefinition", "ContentTypeDefinition.Read", "This point checks access to read/use a content type definition", true));

      systemInterceptionPoints.put("ContentVersion.Delete", new InterceptionPointVO("ContentVersion", "ContentVersion.Delete", "Intercepts the deletion of a contentversion", true));

      systemInterceptionPoints.put("ContentVersion.Write", new InterceptionPointVO("ContentVersion", "ContentVersion.Write", "Intercepts the editing of a contentversion", true));

      systemInterceptionPoints.put("ContentVersion.Read", new InterceptionPointVO("ContentVersion", "ContentVersion.Read", "Intercepts the read of a contentversion", true));

      systemInterceptionPoints.put("ContentVersion.Publish", new InterceptionPointVO("ContentVersion", "ContentVersion.Publish", "Intercepts the direct publishing of a content version", true));

      systemInterceptionPoints.put("ContentVersionEditor.Categories", new InterceptionPointVO("ContentVersionEditor", "ContentVersionEditor.Categories", "Intercepts the tab categories", false));

      systemInterceptionPoints.put("ContentVersionEditor.Attachments", new InterceptionPointVO("ContentVersionEditor", "ContentVersionEditor.Attachments", "Intercepts the tab attachments", false));

      systemInterceptionPoints.put("ContentVersionEditor.History", new InterceptionPointVO("ContentVersionEditor", "ContentVersionEditor.History", "Intercepts the tab history", false));

      systemInterceptionPoints.put("ContentVersionEditor.References", new InterceptionPointVO("ContentVersionEditor", "ContentVersionEditor.References", "Intercepts the tab references", false));

      systemInterceptionPoints.put("ContentVersionEditor.AccessRights", new InterceptionPointVO("ContentVersionEditor", "ContentVersionEditor.AccessRights", "Intercepts the tabs for access rights", false));

     

      systemInterceptionPoints.put("Repository.Read", new InterceptionPointVO("Repository", "Repository.Read", "Gives a user access to look at a repository", true));

      systemInterceptionPoints.put("Repository.Write", new InterceptionPointVO("Repository", "Repository.Write", "Gives a user possible access to write in the repository", true));

      systemInterceptionPoints.put("Repository.ReadForBinding", new InterceptionPointVO("Repository", "Repository.ReadForBinding", "This point intercepts when a user tries to read the repository in a binding dialog", true));

      //systemInterceptionPoints.put("Repository.PublishButton", new InterceptionPointVO("Repository", "Repository.PublishButton", "This point controls which groups can publish on this repo", true));

      //systemInterceptionPoints.put("Repository.SubmitToPublishButton", new InterceptionPointVO("Repository", "Repository.SubmitToPublishButton", "This point controls which groups can submit to publish on this repo", true));

     

      systemInterceptionPoints.put("SiteNodeVersion.Read", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.Read", "Intercepts the read of a SiteNodeVersion", true));

      systemInterceptionPoints.put("SiteNodeVersion.Write", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.Write", "Intercepts the write of a SiteNodeVersion", true));

      systemInterceptionPoints.put("SiteNodeVersion.CreateSiteNode", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.CreateSiteNode", "Intercepts the creation of a new sitenode", true));

      systemInterceptionPoints.put("SiteNodeVersion.DeleteSiteNode", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.DeleteSiteNode", "Intercepts the deletion of a sitenode", true));

      systemInterceptionPoints.put("SiteNodeVersion.MoveSiteNode", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.MoveSiteNode", "Intercepts the movement of a sitenode", true));

      systemInterceptionPoints.put("SiteNodeVersion.SubmitToPublish", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.SubmitToPublish", "Intercepts the submittance to publish of all content versions", true));

      systemInterceptionPoints.put("SiteNodeVersion.ChangeAccessRights", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.ChangeAccessRights", "Intercepts the attempt to change access rights", true));

      systemInterceptionPoints.put("SiteNodeVersion.Publish", new InterceptionPointVO("SiteNodeVersion", "SiteNodeVersion.Publish", "Intercepts the direct publishing of a siteNode version", true));

      systemInterceptionPoints.put("SiteNode.ExpireDateComingUp", new InterceptionPointVO("SiteNode", "SiteNode.ExpireDateComingUp", "Intercepts the event of a site node coming close to it's expire date", true));

    systemInterceptionPoints.put("SiteNodeVersionEditor.Categories", new InterceptionPointVO("SiteNodeVersionEditor", "SiteNodeVersionEditor.Categories", "Intercepts the the categories on SiteNodes", false));

    systemInterceptionPoints.put("SiteNodeVersionEditor.Attachments", new InterceptionPointVO("SiteNodeVersionEditor", "SiteNodeVersionEditor.Attachments", "Intercepts the the attachments on SiteNodes", false));

      systemInterceptionPoints.put("StructureTool.PageTemplateIsOptional", new InterceptionPointVO("StructureTool", "StructureTool.PageTemplateIsOptional", "This interception point limits who has to supply a page template when creating a page", false));

      systemInterceptionPoints.put("StructureTool.Palette", new InterceptionPointVO("StructureTool", "StructureTool.Palette", "This interception point limits who sees the toolbar", false));

     

      systemInterceptionPoints.put("ComponentEditor.ChangeSlotAccess", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ChangeSlotAccess", "This interception point limits who can set access rights to a slot", false));

      systemInterceptionPoints.put("ComponentEditor.AddComponent", new InterceptionPointVO("ComponentEditor", "ComponentEditor.AddComponent", "This interception point limits who can add a component to a specific slot", true));

      systemInterceptionPoints.put("ComponentEditor.DeleteComponent", new InterceptionPointVO("ComponentEditor", "ComponentEditor.DeleteComponent", "This interception point limits who can delete a component in a specific slot", true));

      systemInterceptionPoints.put("ComponentEditor.hasMoveComponentUpAccess", new InterceptionPointVO("ComponentEditor", "ComponentEditor.hasMoveComponentUpAccess", "This interception point limits who can move a component up in a specific slot", true));

      systemInterceptionPoints.put("ComponentEditor.hasMoveComponentDownAccess", new InterceptionPointVO("ComponentEditor", "ComponentEditor.hasMoveComponentDownAccess", "This interception point limits who can move a component down in a specific slot", true));

      systemInterceptionPoints.put("ComponentEditor.ChangeComponent", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ChangeComponent", "This interception point limits who can change a component to another in a specific slot", true));

    systemInterceptionPoints.put("ComponentEditor.ChangeComponentRecursively", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ChangeComponentRecursively", "This interception point limits who can make component changes apply recursively", false));

      systemInterceptionPoints.put("ComponentEditor.SubmitToPublish", new InterceptionPointVO("ComponentEditor", "ComponentEditor.SubmitToPublish", "This interception point limits who have access to the Submit to publish choice in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.PageStructure", new InterceptionPointVO("ComponentEditor", "ComponentEditor.PageStructure", "This interception point limits who can see the page structure menu option in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.OpenInNewWindow", new InterceptionPointVO("ComponentEditor", "ComponentEditor.OpenInNewWindow", "This interception point limits who can see the Open in new window in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.ViewSource", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ViewSource", "This interception point limits who can see the view source menu in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.CreateSubpage", new InterceptionPointVO("ComponentEditor", "ComponentEditor.CreateSubpage", "This interception point limits who can see the create subpage menu in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.EditPageMetadata", new InterceptionPointVO("ComponentEditor", "ComponentEditor.EditPageMetadata", "This interception point limits who can see the edit page meta info menu in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.SavePageTemplate", new InterceptionPointVO("ComponentEditor", "ComponentEditor.SavePageTemplate", "This interception point limits who can see the save page template menu in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.MySettings", new InterceptionPointVO("ComponentEditor", "ComponentEditor.MySettings", "This interception point limits who can see the properties menu in edit on sight", false));

   

    systemInterceptionPoints.put("ComponentEditor.NotifyUserOfPage", new InterceptionPointVO("ComponentEditor", "ComponentEditor.NotifyUserOfPage", "This interception point limits who can see the notify user menu in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.ContentNotifications", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ContentNotifications", "This interception point limits who can see the content notification info menu in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.PageNotifications", new InterceptionPointVO("ComponentEditor", "ComponentEditor.PageNotifications", "This interception point limits who can see the page notification menu in edit on sight", false));

       

      systemInterceptionPoints.put("ComponentPropertyEditor.EditProperty", new InterceptionPointVO("ComponentPropertyEditor", "ComponentPropertyEditor.EditProperty", "This interception point limits who can edit a specific component property", true));

      systemInterceptionPoints.put("ComponentPropertyEditor.EditAdvancedProperties", new InterceptionPointVO("ComponentPropertyEditor", "ComponentPropertyEditor.EditAdvancedProperties", "This interception point limits who can edit advanced properties on a component", false));

    systemInterceptionPoints.put("ComponentEditor.ShowLanguageMenu", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ShowLanguageMenu", "This interception point limits who are allowed to approve / deny publishing requests", false));

    systemInterceptionPoints.put("ComponentEditor.ShowHomeButton", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ShowHomeButton", "This interception point limits who can see the home-button in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.ShowMySettingsButton", new InterceptionPointVO("ComponentEditor", "ComponentEditor.ShowMySettingsButton", "This interception point limits who can see the my settings button in edit on sight", false));

    systemInterceptionPoints.put("ComponentEditor.W3CValidator", new InterceptionPointVO("ComponentEditor", "ComponentEditor.W3CValidator", "This interception point limits who can see the W3C Validator button in edit on sight", false));

      systemInterceptionPoints.put("Publication.Write", new InterceptionPointVO("Publication", "Publication.Write", "This interception point intercepts publications", true));

      systemInterceptionPoints.put("Publication.Written", new InterceptionPointVO("Publication", "Publication.Written", "This interception point intercepts when an publication is completed", true));

      systemInterceptionPoints.put("Common.SubmitToPublishButton", new InterceptionPointVO("Common", "Common.SubmitToPublishButton", "Intercepts the submit to publish button", false));

      systemInterceptionPoints.put("Common.PublishButton", new InterceptionPointVO("Common", "Common.PublishButton", "Intercepts the publish button", false));

      systemInterceptionPoints.put("Common.ManageAccessRights", new InterceptionPointVO("Common", "Common.ManageAccessRights", "Intercepts any management of access rights", false));

    systemInterceptionPoints.put("Common.CreatePage", new InterceptionPointVO("Common", "Common.CreatePage", "This interception point limits who can create pages (at all)", false));

    systemInterceptionPoints.put("Common.DeletePage", new InterceptionPointVO("Common", "Common.DeletePage", "This interception point limits who can delete pages (at all)", false));

    systemInterceptionPoints.put("Common.ApproveDenyPublications", new InterceptionPointVO("Common", "Common.ApproveDenyPublications", "This interception point limits who are allowed to approve / deny publishing requests", false));

    systemInterceptionPoints.put("Common.ShowHidePage", new InterceptionPointVO("Common", "Common.ShowHidePage", "This interception point limits who are allowed to toggle show/hide of pages", false));

    systemInterceptionPoints.put("Common.LightContentEditor", new InterceptionPointVO("Common", "Common.LightContentEditor", "Gives a user access to some special content screens", false));

      systemInterceptionPoints.put("ManagementToolMenu.Repositories", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Repositories", "Intercepts access to the menu item 'Repositories' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.SystemUsers", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.SystemUsers", "Intercepts access to the menu item 'SystemUsers' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Roles", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Roles", "Intercepts access to the menu item 'Roles' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Groups", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Groups", "Intercepts access to the menu item 'Groups' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Languages", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Languages", "Intercepts access to the menu item 'Languages' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.InterceptionPoints", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.InterceptionPoints", "Intercepts access to the menu item 'InterceptionPoints' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Interceptors", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Interceptors", "Intercepts access to the menu item 'Interceptors' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.ServiceDefinitions", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.ServiceDefinitions", "Intercepts access to the menu item 'ServiceDefinitions' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.AvailableServiceBindings", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.AvailableServiceBindings", "Intercepts access to the menu item 'AvailableServiceBindings' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.SiteNodeTypeDefinitions", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.SiteNodeTypeDefinitions", "Intercepts access to the menu item 'SiteNodeTypeDefinitions' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Categories", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Categories", "Intercepts access to the menu item 'Categories' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.ContentTypeDefinitions", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.ContentTypeDefinitions", "Intercepts access to the menu item 'ContentTypeDefinitions' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Up2Date", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Up2Date", "Intercepts access to the menu item 'Up2Date' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Workflows", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Workflows", "Intercepts access to the menu item 'Workflows' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Portlets", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Portlets", "Intercepts access to the menu item 'Portlets' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Redirects", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Redirects", "Intercepts access to the menu item 'Redirects' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.ApplicationSettings", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.ApplicationSettings", "Intercepts access to the menu item 'Application settings' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.MessageCenter", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.MessageCenter", "Intercepts access to the menu item 'Message center' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.Diagnostics", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.Diagnostics", "Intercepts access to the menu item 'Diagnostics' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.SystemTools", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.SystemTools", "Intercepts access to the menu item 'SystemTools' in management tool", false));

      systemInterceptionPoints.put("ManagementToolMenu.TransactionHistory", new InterceptionPointVO("ManagementToolMenu", "ManagementToolMenu.TransactionHistory", "Intercepts access to the menu item 'TransactionHistory' in management tool", false));

      systemInterceptionPoints.put("SystemUser.changeUsername", new InterceptionPointVO("SystemUser", "SystemUser.changeUsername", "Intercepts the possibility to rename users", false));

      systemInterceptionPoints.put("Role.Read", new InterceptionPointVO("Role", "Role.Read", "Intercepts the read of a role", true));

      systemInterceptionPoints.put("Role.ReadForAssignment", new InterceptionPointVO("Role", "Role.ReadForAssignment", "Intercepts the read of a role when assigning them to a user", true));

      systemInterceptionPoints.put("Role.Write", new InterceptionPointVO("Role", "Role.Write", "Intercepts the write of a role", true));

      systemInterceptionPoints.put("Role.Create", new InterceptionPointVO("Role", "Role.Create", "Intercepts the creation of a new role", true));

      systemInterceptionPoints.put("Role.Delete", new InterceptionPointVO("Role", "Role.Delete", "Intercepts the deletion of a role", true));

      systemInterceptionPoints.put("Role.ManageUsers", new InterceptionPointVO("Role", "Role.ManageUsers", "Intercepts the management of users", true));

      systemInterceptionPoints.put("Role.ManageAccessRights", new InterceptionPointVO("Role", "Role.ManageAccessRights", "Intercepts the management of access rights", true));

      systemInterceptionPoints.put("Role.ManageAllAccessRights", new InterceptionPointVO("Role", "Role.ManageAllAccessRights", "Intercepts the management of access rights", false));

      systemInterceptionPoints.put("Group.Read", new InterceptionPointVO("Group", "Group.Read", "Intercepts the read of a group", true));

      systemInterceptionPoints.put("Group.ReadForAssignment", new InterceptionPointVO("Group", "Group.ReadForAssignment", "Intercepts the read of a group when assigning them to a user", true));

      systemInterceptionPoints.put("Group.Write", new InterceptionPointVO("Group", "Group.Write", "Intercepts the write of a group", true));

      systemInterceptionPoints.put("Group.Create", new InterceptionPointVO("Group", "Group.Create", "Intercepts the creation of a new group", true));

      systemInterceptionPoints.put("Group.Delete", new InterceptionPointVO("Group", "Group.Delete", "Intercepts the deletion of a group", true));

      systemInterceptionPoints.put("Group.ManageUsers", new InterceptionPointVO("Group", "Group.ManageUsers", "Intercepts the management of users", true));

      systemInterceptionPoints.put("Group.ManageAccessRights", new InterceptionPointVO("Group", "Group.ManageAccessRights", "Intercepts the management of access rights", true));

      systemInterceptionPoints.put("Group.ManageAllAccessRights", new InterceptionPointVO("Group", "Group.ManageAllAccessRights", "Intercepts the management of access rights", false));

      systemInterceptionPoints.put("WebDAV.Read", new InterceptionPointVO("WebDav", "WebDAV.Read", "Intercepts the WebDAV feature", false));

      systemInterceptionPoints.put("ViewApplicationState.Read", new InterceptionPointVO("ViewApplicationState", "ViewApplicationState.Read", "Intercepts access to the View application state screens", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.MySettingsExtendedGUIFields", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.MySettingsExtendedGUIFields", "Intercepts the GUI-version, GUI-theme and Toolbar style fields on my settings", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.MySettingsSubcriptionsTab", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.MySettingsSubcriptionsTab", "Intercepts the Subscriptions-tab on my settings", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.MySettingsChangePasswordTab", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.MySettingsChangePasswordTab", "Intercepts the Change password-tab on my settings", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.CreatePageAdvancedTab", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.CreatePageAdvancedTab", "Intercepts the Advanced-tab on create page", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.PageDetailsAdvancedTab", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.PageDetailsAdvancedTab", "Intercepts the Advanced-tab on page details", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.PageLanguagesTab", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.PageLanguagesTab", "Intercepts the Languages-tab page details", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.PageSimpleModeButton", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.PageSimpleModeButton", "Intercepts the simple mode structure tool", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.convertToFromFolderPart", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.convertToFromFolderPart", "Intercepts the link to convert a folder to a normal content or vice versa", false));

     

      systemInterceptionPoints.put("ToolTabsAndButtons.ContentToolbarAdvancedButtons", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.ContentToolbarAdvancedButtons", "Intercepts advanced buttons", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.ContentToolbarChangeContentTypeAndLanguageButtons", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.ContentToolbarChangeContentTypeAndLanguageButtons", "Intercepts some of the advanced buttons", false));

      systemInterceptionPoints.put("ToolTabsAndButtons.ContentToolbarContentPropertiesButton", new InterceptionPointVO("ToolTabsAndButtons", "ToolTabsAndButtons.ContentToolbarContentPropertiesButton", "Intercepts the content properties button", false));

      systemInterceptionPoints.put("TrashcanTool.Read", new InterceptionPointVO("TrashcanTool", "TrashcanTool.Read", "Intercepts the trashcan option", false));

      systemInterceptionPoints.put("ChatTool.Write", new InterceptionPointVO("ChatTool", "ChatTool.Write", "Intercepts the send form in chat form", false));

  }

   

  /**

   * Factory method

   */

  public static InterceptionPointController getController()

  {

    return new InterceptionPointController();

  }

 

  public InterceptionPoint getInterceptionPointWithId(Integer interceptionPointId, Database db) throws SystemException, Bug

  {

    return (InterceptionPoint) getObjectWithId(InterceptionPointImpl.class, interceptionPointId, db);

  }

  public InterceptionPoint getReadOnlyInterceptionPointWithId(Integer interceptionPointId, Database db) throws SystemException, Bug

  {

    return (InterceptionPoint) getObjectWithIdAsReadOnly(InterceptionPointImpl.class, interceptionPointId, db);

  }

  public InterceptionPointVO getInterceptionPointVOWithId(Integer interceptionPointId) throws SystemException, Bug

  {

    return (InterceptionPointVO) getVOWithId(InterceptionPointImpl.class, interceptionPointId);

  }

 

  public List getInterceptionPointVOList() throws SystemException, Bug

  {

    return getAllVOObjects(InterceptionPointImpl.class, "interceptionPointId");

  }

  /**

   * This method returns Interception points which do stuff in the system but which are not yet activated.

   * @return List of InterceptionPointVO:s

   * @throws SystemException

   * @throws Bug

   */

  public List<InterceptionPointVO> getInactiveInterceptionPointVOList() throws SystemException, Bug

  {

    List<InterceptionPointVO> inactiveInterceptionPointVOList = new ArrayList();

   

    List interceptionPointVOList = getInterceptionPointVOList();

    Collection allInterceptionPoints = systemInterceptionPoints.values();

    Iterator allInterceptionPointsIterator = allInterceptionPoints.iterator();

    while(allInterceptionPointsIterator.hasNext())

    {

      InterceptionPointVO possibleInterceptionPoint = (InterceptionPointVO)allInterceptionPointsIterator.next();

     

      boolean exists = false;

      Iterator interceptionPointVOListIterator = interceptionPointVOList.iterator();

      while(interceptionPointVOListIterator.hasNext())

      {

        InterceptionPointVO existingInterceptionPointVO = (InterceptionPointVO)interceptionPointVOListIterator.next();

        if(existingInterceptionPointVO.getName().equals(possibleInterceptionPoint.getName()))

          exists = true;

      }

     

      //if(exists)

      //  allInterceptionPointsIterator.remove();

      if(!exists)

        inactiveInterceptionPointVOList.add(possibleInterceptionPoint);

    }

   

    return inactiveInterceptionPointVOList;

  }

  public List getSortedInterceptionPointVOList() throws SystemException, Bug

  {

    return getAllVOObjects(InterceptionPointImpl.class, "category", "asc");

  } 

  public List getInterceptorsVOList(Integer interceptionPointId) throws SystemException, Bug

  {

    List interceptorVOList = null;

   

    Database db = CastorDatabaseService.getDatabase();

    try

    {

      beginTransaction(db);

      interceptorVOList = getInterceptorsVOList(interceptionPointId, db);

      commitTransaction(db);

    }

    catch (Exception e)

    {

      logger.info("An error occurred so we should not complete the transaction:" + e);

      rollbackTransaction(db);

      throw new SystemException(e.getMessage());

    }

   

    return interceptorVOList; 

  }

 

  /**

   * Gets the interceptors for this interceptionPoint withing a transaction

   *

   * @param interceptionPointId

   * @param db

   * @return

   * @throws SystemException

   * @throws Bug

   */

 

  public List getInterceptorsVOList(Integer interceptionPointId, Database db)  throws SystemException, Bug

  {

    String key = "" + interceptionPointId;

    logger.info("key:" + key);

    List cachedInterceptorVOList = (List)CacheController.getCachedObject("interceptorsCache", key);

    if(cachedInterceptorVOList != null)

    {

      logger.info("There was an cached InterceptorVOList:" + cachedInterceptorVOList.size());

      return cachedInterceptorVOList;

    }

   

    List interceptorsVOList = null;

   

    InterceptionPoint interceptionPoint = this.getInterceptionPointWithId(interceptionPointId, db);

   

    Collection interceptors = interceptionPoint.getInterceptors();

   

    interceptorsVOList = toVOList(interceptors);

   

    CacheController.cacheObject("interceptorsCache", key, interceptorsVOList);

    return interceptorsVOList;   

  }

 

  public InterceptionPointVO getInterceptionPointVOWithName(String interceptorPointName)  throws SystemException, Bug

  {

    InterceptionPointVO interceptionPointVO = null;

   

    Database db = CastorDatabaseService.getDatabase();

    try

    {

      beginTransaction(db);

      interceptionPointVO = getInterceptionPointVOWithName(interceptorPointName, db);

     

      commitTransaction(db);

    }

    catch (Exception e)

    {

      logger.info("An error occurred so we should not complete the transaction:" + e);

      rollbackTransaction(db);

      throw new SystemException(e.getMessage());

    }

   

    return interceptionPointVO;   

  } 

  public InterceptionPointVO getInterceptionPointVOWithName(String interceptorPointName, Database db)  throws SystemException, Bug

  {

    String cacheName = "interceptionPointCache";

      String key = "" + interceptorPointName;

    //logger.info("key:" + key);

   

    InterceptionPointVO interceptionPointVO = null;

   

      Object object = CacheController.getCachedObject(cacheName, key);

   

      if(object instanceof NullObject)

    {

      return null;

    }

    else if(object != null)

    {

        interceptionPointVO = (InterceptionPointVO)object;

    }

    else

    {

      InterceptionPoint interceptorPoint = null;

     

      try

      {

        OQLQuery oql = db.getOQLQuery("SELECT f FROM org.infoglue.cms.entities.management.impl.simple.InterceptionPointImpl f WHERE f.name = $1");

        oql.bind(interceptorPointName);

       

        QueryResults results = oql.execute(Database.READONLY);

        if(results.hasMore())

        {

          interceptorPoint = (InterceptionPoint)results.next();

          interceptionPointVO = interceptorPoint.getValueObject();

          CacheController.cacheObject(cacheName, key, interceptionPointVO);       

        }

        else

        { 

            CacheController.cacheObject(cacheName, key, new NullObject());

        }

       

        results.close();

        oql.close();

      }

      catch(Exception e)

      {

        throw new SystemException("An error occurred when we tried to fetch an InterceptionPointVO. Reason:" + e.getMessage(), e);   

      }

    }

   

    return interceptionPointVO;   

  } 

  public InterceptionPoint getInterceptionPointWithName(String interceptorPointName, Database db)  throws SystemException, Bug

  {

    InterceptionPoint interceptorPoint = null;

   

    try

    {

      OQLQuery oql = db.getOQLQuery("SELECT f FROM org.infoglue.cms.entities.management.impl.simple.InterceptionPointImpl f WHERE f.name = $1");

      oql.bind(interceptorPointName);

     

      QueryResults results = oql.execute();

      this.logger.info("Fetching entity in read/write mode:" + interceptorPointName);

      if(results.hasMore())

      {

        interceptorPoint = (InterceptionPoint)results.next();

      }

     

      results.close();

      oql.close();

    }

    catch(Exception e)

    {

      throw new SystemException("An error occurred when we tried to fetch an InterceptionPointVO. Reason:" + e.getMessage(), e);   

    }

   

    return interceptorPoint;   

  }

 

 

  public List getInterceptionPointVOList(String category) throws SystemException, Bug

  {

    List interceptionPointVOList = null;

   

    Database db = CastorDatabaseService.getDatabase();

    try

    {

      beginTransaction(db);

      interceptionPointVOList = toVOList(getInterceptionPointList(category, db));

      commitTransaction(db);

    }

    catch (Exception e)

    {

      logger.info("An error occurred so we should not complete the transaction:" + e);

      rollbackTransaction(db);

      throw new SystemException(e.getMessage());

    }

   

    return interceptionPointVOList; 

  }

 

 

  public List getInterceptionPointList(String category, Database db)  throws SystemException, Bug

  {

    List interceptionPoints = new ArrayList();

   

    try

    {

      OQLQuery oql = db.getOQLQuery("SELECT f FROM org.infoglue.cms.entities.management.impl.simple.InterceptionPointImpl f WHERE f.category = $1");

      oql.bind(category);

     

      QueryResults results = oql.execute();

      this.logger.info("Fetching entity in read/write mode:" + category);

      while(results.hasMore())

      {

        InterceptionPoint interceptionPoint = (InterceptionPoint)results.next();

        interceptionPoints.add(interceptionPoint);

      }

     

      results.close();

      oql.close();

    }

    catch(Exception e)

    {

      throw new SystemException("An error occurred when we tried to fetch an InterceptionPointVO. Reason:" + e.getMessage(), e);   

    }

   

    return interceptionPoints;   

  }

  /**

   * Creates a new Interception point

   *

   * @param interceptionPointVO

   * @return

   * @throws ConstraintException

   * @throws SystemException

   */

 

  public InterceptionPointVO create(InterceptionPointVO interceptionPointVO) throws ConstraintException, SystemException

  {

    InterceptionPointVO newInterceptionPointVO = null;

   

    Database db = CastorDatabaseService.getDatabase();

    try

    {

      beginTransaction(db);

      newInterceptionPointVO = create(interceptionPointVO, db);

       

      commitTransaction(db);

    }

    catch (Exception e)

    {

      logger.info("An error occurred so we should not complete the transaction:" + e);

      rollbackTransaction(db);

      throw new SystemException(e.getMessage());

    }

   

    return newInterceptionPointVO;

  }   

 

  /**

   * Creates a new Interception point within a transaction

   *

   * @param interceptionPointVO

   * @return

   * @throws ConstraintException

   * @throws SystemException

   */

 

  public InterceptionPointVO create(InterceptionPointVO interceptionPointVO, Database db) throws SystemException, Exception

  {

    InterceptionPoint interceptionPoint = new InterceptionPointImpl();

    interceptionPoint.setValueObject(interceptionPointVO);

   

    db.create(interceptionPoint);

         

    return interceptionPoint.getValueObject();

  }    

 

  public InterceptionPointVO update(InterceptionPointVO interceptionPointVO) throws ConstraintException, SystemException

  {

    return (InterceptionPointVO) updateEntity(InterceptionPointImpl.class, interceptionPointVO);

  }       

 

  public void update(InterceptionPointVO interceptionPointVO, String[] values) throws ConstraintException, SystemException

  {

    Database db = CastorDatabaseService.getDatabase();

    try

    {

      beginTransaction(db);

     

      ConstraintExceptionBuffer ceb = interceptionPointVO.validate();

      ceb.throwIfNotEmpty();

     

      InterceptionPoint interceptionPoint = this.getInterceptionPointWithId(interceptionPointVO.getInterceptionPointId(), db);

      interceptionPoint.setValueObject(interceptionPointVO);

     

      Collection interceptors = interceptionPoint.getInterceptors();

      Iterator interceptorsIterator = interceptors.iterator();

      while(interceptorsIterator.hasNext())

      {

        Interceptor interceptor = (Interceptor)interceptorsIterator.next();

        interceptor.getInterceptionPoints().remove(interceptionPoint);

      }

     

      interceptionPoint.getInterceptors().clear();

       

        if(values != null)

        {

        for(int i=0; i<values.length; i++)

        {

          String interceptorId = values[i];

          Interceptor interceptor = InterceptorController.getController().getInterceptorWithId(new Integer(interceptorId), db);

          interceptionPoint.getInterceptors().add(interceptor);

          interceptor.getInterceptionPoints().add(interceptionPoint);

        }

      }

     

        logger.info("Interceptors:" + interceptionPoint.getInterceptors().size());

     

      commitTransaction(db);

    }

    catch (Exception e)

    {

      logger.info("An error occurred so we should not complete the transaction:" + e);

      rollbackTransaction(db);

      throw new SystemException(e.getMessage());

    }

  }     

 

 

  public void delete(InterceptionPointVO interceptionPointVO) throws ConstraintException, SystemException

  {

    Database db = CastorDatabaseService.getDatabase();

   

    beginTransaction(db);

    try

    {

      InterceptionPoint interceptionPoint = this.getInterceptionPointWithId(interceptionPointVO.getInterceptionPointId(), db);

     

      List accessRights = AccessRightController.getController().getAccessRightList(interceptionPoint.getInterceptionPointId(), db);

      Iterator accessRightsIterator = accessRights.iterator();

      while(accessRightsIterator.hasNext())

      {

        AccessRight accessRight = (AccessRight)accessRightsIterator.next();

       

        Iterator groupIterator = accessRight.getGroups().iterator();

        while(groupIterator.hasNext())

        {

          AccessRightGroup group = (AccessRightGroup)groupIterator.next();

          groupIterator.remove();

          db.remove(group);

        }

       

        Iterator roleIterator = accessRight.getRoles().iterator();

        while(roleIterator.hasNext())

        {

          AccessRightRole role = (AccessRightRole)roleIterator.next();

          roleIterator.remove();

          db.remove(role);

        }

        Iterator userIterator = accessRight.getUsers().iterator();

        while(userIterator.hasNext())

        {

          AccessRightUser user = (AccessRightUser)userIterator.next();

          userIterator.remove();

          db.remove(user);

        }

        db.remove(accessRight);

        accessRightsIterator.remove();

      }

     

      db.remove(interceptionPoint);

 

      commitTransaction(db);

    }

    catch(Exception e)

    {

      logger.error("An error occurred so we should not complete the transaction:" + e, e);

      rollbackTransaction(db);

      throw new SystemException(e.getMessage());

    }

 

  }       

  /*

  public void delete(String name, String value, Database db) throws SystemException, Exception

  {

    List AccessList = getAccessList(name, value, db);

    Iterator i = AccessList.iterator();

    while(i.hasNext())

    {

      Access Access = (Access)i.next();

      db.remove(Access);

    }

   

  }       

  */

  /**

   * This is a method that gives the user back an newly initialized ValueObject for this entity that the controller

   * is handling.

   */

  public BaseEntityVO getNewVO()

  {

    return new InterceptionPointVO();

  }

}