@Test
public void saveMapPolicy() {
// create a map
final PortfolioStructureMap map =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Policies", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(map, "Page policies", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// policies are empty
final List<EPMapPolicy> policies = epFrontendManager.getMapPolicies(map);
assertEquals(0, policies.size()); // owner policy
// save a user policy
final EPMapPolicy userPolicy = new EPMapPolicy();
userPolicy.setType(Type.user);
userPolicy.getIdentities().add(ident2);
epFrontendManager.updateMapPolicies(map, Collections.singletonList(userPolicy));
dbInstance.commitAndCloseSession();
// one policy
final List<EPMapPolicy> policies1 = epFrontendManager.getMapPolicies(map);
assertEquals(1, policies1.size());
// check visiblity (is owner)
assertTrue(epFrontendManager.isMapVisible(ident1, map.getOlatResource()));
// check visibility (is in policy)
assertTrue(epFrontendManager.isMapVisible(ident2, map.getOlatResource()));
// check not visible (not in policy)
assertFalse(epFrontendManager.isMapVisible(ident3, map.getOlatResource()));
}
/** Same workflow as the repository. This workflow is pretty critical. */
@Test
public void isStructuredMapOwner() {
final OLATResource resource = epStructureManager.createPortfolioMapTemplateResource();
// create a repository entry
final RepositoryEntry addedEntry =
repositoryManager.createRepositoryEntryInstance(ident1.getName());
addedEntry.setCanDownload(false);
addedEntry.setCanLaunch(true);
addedEntry.setDisplayname("test repo");
addedEntry.setResourcename("-");
addedEntry.setAccess(RepositoryEntry.ACC_OWNERS);
// Set the resource on the repository entry and save the entry.
final OLATResource ores = resourceManager.findOrPersistResourceable(resource);
addedEntry.setOlatResource(ores);
// create security group
final SecurityGroup newGroup = securityManager.createAndPersistSecurityGroup();
securityManager.createAndPersistPolicy(newGroup, Constants.PERMISSION_ACCESS, newGroup);
securityManager.createAndPersistPolicy(
newGroup, Constants.PERMISSION_HASROLE, EPStructureManager.ORES_MAPOWNER);
securityManager.addIdentityToSecurityGroup(ident1, newGroup);
addedEntry.setOwnerGroup(newGroup);
repositoryManager.saveRepositoryEntry(addedEntry);
dbInstance.commitAndCloseSession();
// create the template owned by ident1
final PortfolioStructureMap template =
epStructureManager.createAndPersistPortfolioMapTemplateFromEntry(ident1, addedEntry);
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(template, "Page title", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// assign the template to ident2
final PortfolioStructureMap map =
epFrontendManager.assignStructuredMapToUser(ident2, template, null, null, null, null);
assertNotNull(map);
dbInstance.commitAndCloseSession();
// check if ident2 is owner of the map
assertTrue(epFrontendManager.isMapOwner(ident2, map.getOlatResource()));
// check if ident1 is not the owner of the map
assertFalse(epFrontendManager.isMapOwner(ident1, map.getOlatResource()));
// check if ident1 is owner of the template
assertTrue(epFrontendManager.isMapOwner(ident1, template.getOlatResource()));
}
@Test
public void isMapOwner() {
// create a map
final PortfolioStructureMap originalMap =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Title", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(
originalMap, "Page title", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// check if ident1 is owner
assertTrue(epFrontendManager.isMapOwner(ident1, originalMap.getOlatResource()));
// check if ident2 is not owner
assertFalse(epFrontendManager.isMapOwner(ident2, originalMap.getOlatResource()));
}
@Test
public void testCopyMap() {
// create two artefacts
final AbstractArtefact artefact1 = epFrontendManager.createAndPersistArtefact(ident1, "text");
assertNotNull(artefact1);
final AbstractArtefact artefact2 = epFrontendManager.createAndPersistArtefact(ident1, "bc");
assertNotNull(artefact2);
dbInstance.commitAndCloseSession();
// create a map with a page and the page has two artefacts
final PortfolioStructureMap originalMap =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Title", "Description");
final PortfolioStructure newPage =
epFrontendManager.createAndPersistPortfolioPage(
originalMap, "Page title", "Page description");
final boolean successfullLink1 =
epFrontendManager.addArtefactToStructure(ident1, artefact1, newPage);
assertTrue(successfullLink1);
final boolean successfullLink2 =
epFrontendManager.addArtefactToStructure(ident1, artefact2, newPage);
assertTrue(successfullLink2);
dbInstance.commitAndCloseSession();
// 1 test: copy the map one shoot
final PortfolioStructureMap copyMap =
epFrontendManager.createAndPersistPortfolioDefaultMap(
ident1, "Title copy", "Description copy");
epFrontendManager.copyStructureRecursively(originalMap, copyMap, true);
assertNotNull(copyMap.getKey());
dbInstance.commitAndCloseSession();
// 2 test: copy the map two shoota
final PortfolioStructureMap copyMap2 =
epFrontendManager.createAndPersistPortfolioDefaultMap(
ident1, "Title copy 2", "Description copy 2");
dbInstance.commitAndCloseSession();
assertNotNull(copyMap2.getKey());
epFrontendManager.copyStructureRecursively(originalMap, copyMap2, true);
dbInstance.commitAndCloseSession();
}
@Test
public void allMapPolicies() {
// create a map
final PortfolioStructureMap map =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Policies", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(map, "Page policies", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// save a list of policies
final List<EPMapPolicy> policies = new ArrayList<EPMapPolicy>();
// user policy
final EPMapPolicy userPolicy = new EPMapPolicy();
userPolicy.setType(Type.user);
userPolicy.getIdentities().add(ident2);
userPolicy.getIdentities().add(ident3);
policies.add(userPolicy);
// invitation
final Invitation invitation = securityManager.createAndPersistInvitation();
invitation.setFirstName("John");
invitation.setLastName("Doe");
invitation.setMail("*****@*****.**");
final EPMapPolicy invitationPolicy = new EPMapPolicy();
invitationPolicy.setType(Type.invitation);
invitationPolicy.setInvitation(invitation);
policies.add(invitationPolicy);
epFrontendManager.updateMapPolicies(map, policies);
dbInstance.commitAndCloseSession();
// check visiblity (is owner)
assertTrue(epFrontendManager.isMapVisible(ident1, map.getOlatResource()));
// check visibility (is in policy)
assertTrue(epFrontendManager.isMapVisible(ident2, map.getOlatResource()));
// check visible (is in policy)
assertTrue(epFrontendManager.isMapVisible(ident3, map.getOlatResource()));
// retrieved policies
final List<EPMapPolicy> savedPolicies = epFrontendManager.getMapPolicies(map);
assertTrue(!savedPolicies.isEmpty());
}
@Test
public void testSyncMapTemplateToUserMap() {
// //////////////////////
// start create a template
final PortfolioStructure templateEl =
epStructureManager.createPortfolioMapTemplate(
ident1, "sync-template-1", "symc-map-template-1");
epStructureManager.savePortfolioStructure(templateEl);
// create five pages
final List<PortfolioStructure> pageRefs = new ArrayList<PortfolioStructure>();
final List<PortfolioStructure> elementRefs = new ArrayList<PortfolioStructure>();
for (int i = 0; i < 5; i++) {
final PortfolioStructure page =
epFrontendManager.createAndPersistPortfolioPage(
templateEl, "sync-template-page-" + i, "sync-template-page-" + i);
pageRefs.add(page);
for (int j = 0; j < 5; j++) {
final PortfolioStructure struct =
epFrontendManager.createAndPersistPortfolioStructureElement(
page, "template-structure-" + i + "." + j, "template-structure-" + i + "." + j);
epStructureManager.addCollectRestriction(struct, "Forum", "minimum", 2);
epStructureManager.savePortfolioStructure(struct);
elementRefs.add(struct);
}
}
// save the template
dbInstance.commitAndCloseSession();
// end create template
// ////////////////////
// make the copy
final PortfolioStructureMap map =
epFrontendManager.assignStructuredMapToUser(
ident2, (EPStructuredMapTemplate) templateEl, null, null, null, null);
dbInstance.commitAndCloseSession();
assertNotNull(map);
// ////////////////////////////////
// shuffle the pages and delete one
final PortfolioStructure retrievedTemplateEl =
epFrontendManager.loadPortfolioStructureByKey(templateEl.getKey());
final List<PortfolioStructure> pages =
epFrontendManager.loadStructureChildren(retrievedTemplateEl);
epStructureManager.moveUp(retrievedTemplateEl, pages.get(1));
epStructureManager.moveDown(retrievedTemplateEl, pages.get(2));
epStructureManager.removeStructure(retrievedTemplateEl, pages.get(3));
epStructureManager.savePortfolioStructure(retrievedTemplateEl);
// shuffle a page
final List<PortfolioStructure> page1Children =
epFrontendManager.loadStructureChildren(pages.get(1));
epStructureManager.moveUp(pages.get(1), page1Children.get(3));
epStructureManager.moveUp(pages.get(1), page1Children.get(2));
epStructureManager.moveUp(pages.get(1), page1Children.get(4));
// and add an element and sub-elements
final PortfolioStructure newStruct =
epFrontendManager.createAndPersistPortfolioStructureElement(
pages.get(1), "new-template-structure-1.6", "template-structure-1.6");
epStructureManager.addCollectRestriction(pages.get(1), "Forum", "minimum", 2);
epStructureManager.savePortfolioStructure(newStruct);
epStructureManager.savePortfolioStructure(pages.get(1));
for (int k = 0; k < 5; k++) {
final PortfolioStructure struct =
epFrontendManager.createAndPersistPortfolioStructureElement(
newStruct, "new-template-structure-2." + k, "template-structure-2." + k);
epStructureManager.addCollectRestriction(struct, "bc", "minimum", 2);
epStructureManager.savePortfolioStructure(struct);
elementRefs.add(struct);
}
dbInstance.commitAndCloseSession();
// end shuffle the pages
// ////////////////////////////////
// //////////////////
// check the template
final PortfolioStructure retrievedTemplate2El =
epFrontendManager.loadPortfolioStructureByKey(templateEl.getKey());
assertNotNull(retrievedTemplate2El);
assertTrue(retrievedTemplate2El instanceof EPStructuredMapTemplate);
final List<PortfolioStructure> retrievedPages2 =
epFrontendManager.loadStructureChildren(retrievedTemplate2El);
assertEquals(4, retrievedPages2.size());
assertEquals(4, ((EPStructuredMapTemplate) retrievedTemplate2El).getInternalChildren().size());
// check the shuffled pages
assertEquals(pageRefs.get(1).getKey(), retrievedPages2.get(0).getKey());
assertEquals(pageRefs.get(0).getKey(), retrievedPages2.get(1).getKey());
assertEquals(pageRefs.get(2).getKey(), retrievedPages2.get(2).getKey());
assertEquals(pageRefs.get(4).getKey(), retrievedPages2.get(3).getKey());
// check added element
final List<PortfolioStructure> retrievedChildren2 =
epFrontendManager.loadStructureChildren(retrievedPages2.get(0));
assertEquals(6, retrievedChildren2.size());
dbInstance.commitAndCloseSession();
// check the template
// //////////////////
// sync the map
epFrontendManager.synchronizeStructuredMapToUserCopy(map);
dbInstance.commitAndCloseSession();
// ///////////////
// check the sync
final PortfolioStructure synchedMap =
epFrontendManager.loadPortfolioStructureByKey(map.getKey());
assertNotNull(synchedMap);
assertTrue(synchedMap instanceof EPStructuredMap);
final List<PortfolioStructure> synchedPages =
epFrontendManager.loadStructureChildren(synchedMap);
assertNotNull(synchedPages);
assertEquals(4, synchedPages.size());
assertEquals(
((EPStructureElement) pageRefs.get(1)).getTitle(),
((EPStructureElement) synchedPages.get(0)).getTitle());
assertEquals(
((EPStructureElement) pageRefs.get(0)).getTitle(),
((EPStructureElement) synchedPages.get(1)).getTitle());
assertEquals(
((EPStructureElement) pageRefs.get(2)).getTitle(),
((EPStructureElement) synchedPages.get(2)).getTitle());
assertEquals(
((EPStructureElement) pageRefs.get(4)).getTitle(),
((EPStructureElement) synchedPages.get(3)).getTitle());
// check synched key
assertEquals(
((EPStructureElement) pageRefs.get(1)).getKey(),
((EPStructureElement) synchedPages.get(0)).getStructureElSource());
assertEquals(
((EPStructureElement) pageRefs.get(0)).getKey(),
((EPStructureElement) synchedPages.get(1)).getStructureElSource());
assertEquals(
((EPStructureElement) pageRefs.get(2)).getKey(),
((EPStructureElement) synchedPages.get(2)).getStructureElSource());
assertEquals(
((EPStructureElement) pageRefs.get(4)).getKey(),
((EPStructureElement) synchedPages.get(3)).getStructureElSource());
// check the new elements
final List<PortfolioStructure> retrievedPage1Children =
epFrontendManager.loadStructureChildren(synchedPages.get(0));
assertEquals(6, retrievedPage1Children.size());
final PortfolioStructure retrievedNewStruct = retrievedPage1Children.get(5);
assertEquals(
"new-template-structure-1.6", ((EPStructureElement) retrievedNewStruct).getTitle());
final List<PortfolioStructure> retrievedNewStructChildren =
epFrontendManager.loadStructureChildren(retrievedNewStruct);
assertNotNull(retrievedNewStructChildren);
assertEquals(5, retrievedNewStructChildren.size());
for (int k = 0; k < 5; k++) {
assertEquals(
"new-template-structure-2." + k,
((EPStructureElement) retrievedNewStructChildren.get(k)).getTitle());
}
// end check the sync
// //////////////////
}
@Test
public void testAssignMapTemplateToUser() {
// create a template
// test save parent and child
final PortfolioStructure templateEl =
epStructureManager.createPortfolioMapTemplate(ident1, "template-1", "map-template-1");
epStructureManager.savePortfolioStructure(templateEl);
// first page
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(
templateEl, "template-page-1", "template-page-1");
// structure element 1 from page 1
final PortfolioStructure struct11 =
epFrontendManager.createAndPersistPortfolioStructureElement(
page1, "template-structure-1.1", "template-structure-1.1");
epStructureManager.addCollectRestriction(struct11, "Forum", "minimum", 2);
epStructureManager.savePortfolioStructure(struct11);
// structure element 2 from page 1
final PortfolioStructure struct12 =
epFrontendManager.createAndPersistPortfolioStructureElement(
page1, "template-structure-1.2", "template-structure-1.2");
// first page
final PortfolioStructure page2 =
epFrontendManager.createAndPersistPortfolioPage(
templateEl, "template-page-2", "template-page-2");
// structure element 1 from page 2
final PortfolioStructure struct21 =
epFrontendManager.createAndPersistPortfolioStructureElement(
page2, "template-structure-2.1", "template-structure-2.1");
epStructureManager.addCollectRestriction(struct21, "bc", "maximum", 4);
epStructureManager.savePortfolioStructure(struct21);
// save the template
dbInstance.commitAndCloseSession();
// make the copy
final PortfolioStructureMap map =
epFrontendManager.assignStructuredMapToUser(
ident2, (EPStructuredMapTemplate) templateEl, null, null, null, null);
dbInstance.commitAndCloseSession();
assertNotNull(map);
// check the copy
final PortfolioStructure retrievedMap =
epFrontendManager.loadPortfolioStructureByKey(map.getKey());
assertNotNull(retrievedMap);
assertTrue(retrievedMap instanceof EPStructuredMap);
assertNotNull(((EPStructuredMap) retrievedMap).getStructuredMapSource());
assertEquals(
templateEl.getKey(), ((EPStructuredMap) retrievedMap).getStructuredMapSource().getKey());
// check pages of the copied map
final List<PortfolioStructure> pages = epFrontendManager.loadStructureChildren(retrievedMap);
assertNotNull(pages);
assertEquals(2, pages.size());
assertTrue(pages.get(0) instanceof EPPage);
assertTrue(pages.get(1) instanceof EPPage);
assertEquals("template-page-1", ((EPStructureElement) pages.get(0)).getTitle());
assertEquals("template-page-2", ((EPStructureElement) pages.get(1)).getTitle());
// check root
assertNotNull(((EPStructureElement) pages.get(0)).getRoot());
assertEquals(retrievedMap.getKey(), ((EPStructureElement) pages.get(0)).getRoot().getKey());
// check children of the pages
final List<PortfolioStructure> structs1 = epFrontendManager.loadStructureChildren(pages.get(0));
assertNotNull(structs1);
assertEquals(2, structs1.size());
assertTrue(structs1.get(0) instanceof EPStructureElement);
assertTrue(structs1.get(1) instanceof EPStructureElement);
final EPStructureElement struct11El = (EPStructureElement) structs1.get(0);
assertEquals("template-structure-1.1", struct11El.getTitle());
assertEquals("template-structure-1.2", ((EPStructureElement) structs1.get(1)).getTitle());
// check root
assertNotNull(((EPStructureElement) structs1.get(0)).getRoot());
assertEquals(retrievedMap.getKey(), ((EPStructureElement) structs1.get(0)).getRoot().getKey());
assertNotNull(((EPStructureElement) structs1.get(1)).getRoot());
assertEquals(retrievedMap.getKey(), ((EPStructureElement) structs1.get(1)).getRoot().getKey());
// check collect restriction
assertNotNull(struct11El.getCollectRestrictions());
assertEquals("Forum", struct11El.getCollectRestrictions().get(0).getArtefactType());
assertEquals("minimum", struct11El.getCollectRestrictions().get(0).getRestriction());
assertEquals(2, struct11El.getCollectRestrictions().get(0).getAmount());
final List<PortfolioStructure> structs2 = epFrontendManager.loadStructureChildren(pages.get(1));
assertNotNull(structs2);
assertEquals(1, structs2.size());
assertTrue(structs2.get(0) instanceof EPStructureElement);
final EPStructureElement struct21El = (EPStructureElement) structs2.get(0);
assertEquals("template-structure-2.1", struct21El.getTitle());
// check root
assertNotNull(struct21El.getRoot());
assertEquals(retrievedMap.getKey(), struct21El.getRoot().getKey());
// check collect restriction
assertNotNull(struct21El.getCollectRestrictions());
assertEquals("bc", struct21El.getCollectRestrictions().get(0).getArtefactType());
assertEquals("maximum", struct21El.getCollectRestrictions().get(0).getRestriction());
assertEquals(4, struct21El.getCollectRestrictions().get(0).getAmount());
}