Java Code Examples for org.alfresco.service.cmr.site.SiteInfo#setVisibility()

@Test
public void testUpdateSite()
{
    SiteInfo siteInfo = new SiteInfoImpl(TEST_SITE_PRESET, "testUpdateSite", "changedTitle", "changedDescription", SiteVisibility.PRIVATE, null);
    
    // update a site that isn't there
    try
    {
        this.siteService.updateSite(siteInfo);
        fail("Shouldn't be able to update a site that does not exist");
    }
    catch (AlfrescoRuntimeException exception)
    {
        // Expected
    }
    
    // Create a test site
    this.siteService.createSite(TEST_SITE_PRESET, "testUpdateSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.PUBLIC);
    
    // Update the details of the site
    this.siteService.updateSite(siteInfo);
    siteInfo = this.siteService.getSite("testUpdateSite");
    checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testUpdateSite", "changedTitle", "changedDescription", SiteVisibility.PRIVATE); 
    
    // Update the permission again
    siteInfo.setVisibility(SiteVisibility.PUBLIC);
    this.siteService.updateSite(siteInfo);
    checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testUpdateSite", "changedTitle", "changedDescription", SiteVisibility.PUBLIC);         
}
 

/**
 *  From MNT-14452, insure that GROUP_EVERYONE have read access to public sites' containers.
 */
@Test
public void testChangeSiteVisibility()
{
    String siteName = GUID.generate();
    
    //Check Private->public
    SiteInfo siteInfo = createSite(siteName, "doclib", SiteVisibility.PRIVATE);

    NodeRef container = this.siteService.getContainer(siteInfo.getShortName(), "doclib");

    siteInfo.setVisibility(SiteVisibility.PUBLIC);
    siteService.updateSite(siteInfo);

    assertTrue(getAllowedPermissionsMap(container).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));

    //Check public->moderated
    siteInfo.setVisibility(SiteVisibility.MODERATED);
    siteService.updateSite(siteInfo);

    assertNull("GROUP_EVERYONE shouldn't have any permissions on a moderated site's containers", getAllowedPermissionsMap(container).get(PermissionService.ALL_AUTHORITIES));

    //Check moderated->public
    siteInfo.setVisibility(SiteVisibility.PUBLIC);
    siteService.updateSite(siteInfo);

    assertTrue(getAllowedPermissionsMap(container).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
    
    //Check public->private
    siteInfo.setVisibility(SiteVisibility.PRIVATE);
    siteService.updateSite(siteInfo);

    assertNull("GROUP_EVERYONE shouldn't have any permissions on a moderated site's containers", getAllowedPermissionsMap(container).get(PermissionService.ALL_AUTHORITIES));        

}
 

@Override
public Site updateSite(String siteId, SiteUpdate update, Parameters parameters)
{
    if (logger.isDebugEnabled())
    {
        logger.debug("Updating site, ID: "+siteId+", site data: "+update+", parameters: "+parameters);
    }

    // Get the site by ID (aka short name)
    SiteInfo siteInfo = validateSite(siteId);
    if (siteInfo == null)
    {
        // site does not exist
        throw new EntityNotFoundException(siteId);
    }

    // Bind any provided values to the site info, allowing for "partial" updates.
    if (update.wasSet(Site.TITLE))
    {
        siteInfo.setTitle(update.getTitle());
    }
    if (update.wasSet(Site.DESCRIPTION))
    {
        siteInfo.setDescription(update.getDescription());
    }
    if (update.wasSet(Site.VISIBILITY))
    {
        siteInfo.setVisibility(update.getVisibility());
    }

    // Validate the new details
    validateSite(new Site(siteInfo, null));

    // Perform the actual update.
    siteService.updateSite(siteInfo);

    return getSite(siteId);
}
 

/**
 * Tests the visibility of a site
 * 
 * See https://issues.alfresco.com/jira/browse/JAWS-291
 */
@Test
public void testSiteVisibility()
{
    RetryingTransactionCallback<Object> work = new RetryingTransactionCallback<Object>()
    {

        @Override
        public Object execute() throws Throwable
        {
            // Create a public site
            SiteInfo siteInfo = createTestSiteWithContent("testSiteVisibilityPublicSite", "testComp", SiteVisibility.PUBLIC);
            // - is the value on the site nodeRef correct?
            assertEquals(SiteVisibility.PUBLIC.toString(), nodeService.getProperty(siteInfo.getNodeRef(), SiteModel.PROP_SITE_VISIBILITY));
            // - is the site info correct?
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityPublicSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.PUBLIC);
            siteInfo = siteService.getSite("testSiteVisibilityPublicSite");
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityPublicSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.PUBLIC);
            // - are the permissions correct for non-members?
            testVisibilityPermissions("Testing visibility of public site", USER_TWO, siteInfo, true, true);

            // Create a moderated site
            siteInfo = createTestSiteWithContent("testSiteVisibilityModeratedSite", "testComp", SiteVisibility.MODERATED);
            // - is the value on the site nodeRef correct?
            assertEquals(SiteVisibility.MODERATED.toString(), nodeService.getProperty(siteInfo.getNodeRef(), SiteModel.PROP_SITE_VISIBILITY));
            // - is the site info correct?
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityModeratedSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.MODERATED);
            siteInfo = siteService.getSite("testSiteVisibilityModeratedSite");
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityModeratedSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.MODERATED);
            // - are the permissions correct for non-members?
            testVisibilityPermissions("Testing visibility of moderated site", USER_TWO, siteInfo, true, false);

            // Create a private site
            siteInfo = createTestSiteWithContent("testSiteVisibilityPrivateSite", "testComp", SiteVisibility.PRIVATE);
            // - is the value on the site nodeRef correct?
            assertEquals(SiteVisibility.PRIVATE.toString(), nodeService.getProperty(siteInfo.getNodeRef(), SiteModel.PROP_SITE_VISIBILITY));
            // - is the site info correct?
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityPrivateSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.PRIVATE);
            siteInfo = siteService.getSite("testSiteVisibilityPrivateSite");
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityPrivateSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.PRIVATE);
            // - are the permissions correct for non-members?
            testVisibilityPermissions("Testing visibility of private site", USER_TWO, siteInfo, false, false);

            SiteInfo changeSite = createTestSiteWithContent("testSiteVisibilityChangeSite", "testComp", SiteVisibility.PUBLIC);
            // Switch from public -> moderated
            changeSite.setVisibility(SiteVisibility.MODERATED);
            siteService.updateSite(changeSite);
            // - check the updated sites visibility
            siteInfo = siteService.getSite("testSiteVisibilityChangeSite");
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityChangeSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.MODERATED);
            testVisibilityPermissions("Testing visibility of moderated site", USER_TWO, siteInfo, true, false);

            // Switch from moderated -> private
            changeSite.setVisibility(SiteVisibility.PRIVATE);
            siteService.updateSite(changeSite);
            // - check the updated sites visibility
            siteInfo = siteService.getSite("testSiteVisibilityChangeSite");
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityChangeSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.PRIVATE);
            testVisibilityPermissions("Testing visibility of moderated site", USER_TWO, siteInfo, false, false);

            // Switch from private -> public
            changeSite.setVisibility(SiteVisibility.PUBLIC);
            siteService.updateSite(changeSite);
            // - check the updated sites visibility
            siteInfo = siteService.getSite("testSiteVisibilityChangeSite");
            checkSiteInfo(siteInfo, TEST_SITE_PRESET, "testSiteVisibilityChangeSite", TEST_TITLE, TEST_DESCRIPTION, SiteVisibility.PUBLIC);
            testVisibilityPermissions("Testing visibility of moderated site", USER_TWO, siteInfo, true, true);

            authenticationComponent.setSystemUserAsCurrentUser();
            siteService.deleteSite("testSiteVisibilityPublicSite");
            siteService.deleteSite("testSiteVisibilityModeratedSite");
            siteService.deleteSite("testSiteVisibilityPrivateSite");
            siteService.deleteSite("testSiteVisibilityChangeSite");
            
            return null;
        }
    };
    transactionService.getRetryingTransactionHelper().doInTransaction(work);
}
 

/**
 * ALF-10343 - When the default public group for sites isn't EVERYBODY,
 * check that creating and altering sites results in the correct permissions 
 */
@Test
public void testNonDefaultPublicGroupPermissions() throws Exception
{
   // Sanity check the current permissions
   assertEquals(PermissionService.ALL_AUTHORITIES, sysAdminParams.getSitePublicGroup());
   
   // Change the public site group
   SysAdminParamsImpl sp = new SysAdminParamsImpl();
   sp.setSitePublicGroup(groupFour);
   siteServiceImpl.setSysAdminParams(sp);

   
   // Create sites of the three types
   SiteInfo s1 = this.siteService.createSite(TEST_SITE_PRESET, "SiteTest_priv", "priv", "priv", SiteVisibility.PRIVATE);
   SiteInfo s2 = this.siteService.createSite(TEST_SITE_PRESET, "SiteTest_mod", "mod", "mod", SiteVisibility.MODERATED);
   SiteInfo s3 = this.siteService.createSite(TEST_SITE_PRESET, "SiteTest_pub", "pub", "pub", SiteVisibility.PUBLIC);
   
   
   // Check the permissions on them
   // Everyone has read permissions only, not Consumer
   assertTrue(getAllowedPermissionsMap(s1).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   assertTrue(getAllowedPermissionsMap(s2).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   assertTrue(getAllowedPermissionsMap(s3).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   
   // On the public + moderated sites, the special group will be a Consumer
   assertEquals(null,                    getAllowedPermissionsMap(s1).get(groupFour));
   assertTrue(getAllowedPermissionsMap(s2).get(groupFour).contains(SiteModel.SITE_CONSUMER));
   assertTrue(getAllowedPermissionsMap(s3).get(groupFour).contains(SiteModel.SITE_CONSUMER));
   
   // Our current user will be Manager
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s1.getShortName(), USER_ONE));
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s2.getShortName(), USER_ONE));
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s3.getShortName(), USER_ONE));
   
   
   // Swap the visibilites around, private+moderated -> public, public -> private
   s1.setVisibility(SiteVisibility.PUBLIC);
   s2.setVisibility(SiteVisibility.PUBLIC);
   s3.setVisibility(SiteVisibility.PRIVATE);
   siteService.updateSite(s1);
   siteService.updateSite(s2);
   siteService.updateSite(s3);
   
   // Check the permissions now

   // Everyone still has read permissions everywhere, but nothing more
   assertTrue(getAllowedPermissionsMap(s1).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   assertTrue(getAllowedPermissionsMap(s2).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   assertTrue(getAllowedPermissionsMap(s3).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   
   // The site public group has consumer permissions on mod+public
   assertTrue(getAllowedPermissionsMap(s1).get(groupFour).contains(SiteModel.SITE_CONSUMER));
   assertTrue(getAllowedPermissionsMap(s2).get(groupFour).contains(SiteModel.SITE_CONSUMER));
   assertEquals(null,                    getAllowedPermissionsMap(s3).get(groupFour));
   
   // Our user is still the manager
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s1.getShortName(), USER_ONE));
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s2.getShortName(), USER_ONE));
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s3.getShortName(), USER_ONE));
   
   
   // Swap them back again
   s1.setVisibility(SiteVisibility.PRIVATE);
   s2.setVisibility(SiteVisibility.MODERATED);
   s3.setVisibility(SiteVisibility.PUBLIC);
   siteService.updateSite(s1);
   siteService.updateSite(s2);
   siteService.updateSite(s3);
   
   // Check the permissions have restored

   // Everyone only has read permissions
   assertTrue(getAllowedPermissionsMap(s1).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   assertTrue(getAllowedPermissionsMap(s2).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   assertTrue(getAllowedPermissionsMap(s3).get(PermissionService.ALL_AUTHORITIES).contains("ReadPermissions"));
   
   // The site public group has consumer permissions on mod+public
   assertEquals(null,                    getAllowedPermissionsMap(s1).get(groupFour));
   assertTrue(getAllowedPermissionsMap(s2).get(groupFour).contains(SiteModel.SITE_CONSUMER));
   assertTrue(getAllowedPermissionsMap(s3).get(groupFour).contains(SiteModel.SITE_CONSUMER));
   
   // Our user is still the manager
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s1.getShortName(), USER_ONE));
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s2.getShortName(), USER_ONE));
   assertEquals(SiteModel.SITE_MANAGER, siteService.getMembersRole(s3.getShortName(), USER_ONE));
}
 

/**
 * Tests that the permissions details included with topics and
 *  posts are correct
 */
public void testPermissions() throws Exception
{
   // Create a post, and check the details on it
   JSONObject item = createSitePost("test", "test", Status.STATUS_OK);
   String name = item.getString("name");
   
   JSONObject perms = item.getJSONObject("permissions");
   assertEquals(true, perms.getBoolean("edit"));
   assertEquals(true, perms.getBoolean("reply"));
   assertEquals(true, perms.getBoolean("delete"));
   
   // Check on a fetch too
   item = getPost(name, Status.STATUS_OK);
   perms = item.getJSONObject("permissions");
   assertEquals(true, perms.getBoolean("edit"));
   assertEquals(true, perms.getBoolean("reply"));
   assertEquals(true, perms.getBoolean("delete"));
   
   
   // Switch to another user, see what they see
   this.authenticationComponent.setCurrentUser(USER_TWO);
   
   item = getPost(name, Status.STATUS_OK);
   perms = item.getJSONObject("permissions");
   assertEquals(false, perms.getBoolean("edit"));
   assertEquals(true, perms.getBoolean("reply"));
   assertEquals(false, perms.getBoolean("delete"));
   
   
   // Remove the user from the site, see the change
   this.siteService.removeMembership(SITE_SHORT_NAME_DISCUSSION, USER_TWO);
   
   item = getPost(name, Status.STATUS_OK);
   perms = item.getJSONObject("permissions");
   assertEquals(false, perms.getBoolean("edit"));
   assertEquals(false, perms.getBoolean("reply"));
   assertEquals(false, perms.getBoolean("delete"));
   
   
   // Make the site private, will vanish
   SiteInfo siteInfo = siteService.getSite(SITE_SHORT_NAME_DISCUSSION);
   siteInfo.setVisibility(SiteVisibility.PRIVATE);
   this.authenticationComponent.setCurrentUser(AuthenticationUtil.getAdminUserName());
   this.siteService.updateSite(siteInfo);
   this.authenticationComponent.setCurrentUser(USER_TWO);
   
   // On a private site we're not a member of, shouldn't be visable at all
   getPost(name, Status.STATUS_NOT_FOUND);
}