From b28bacbdb570e1109fd70d5b3493dae4969949bb Mon Sep 17 00:00:00 2001 From: j2blake Date: Fri, 21 Oct 2011 21:09:19 +0000 Subject: [PATCH] NIHVIVO-2343 Extend UserAccount to include proxiedIndividualUris; extend the DAO. --- .../vitro/webapp/beans/UserAccount.java | 14 ++ .../vitro/webapp/dao/VitroVocabulary.java | 1 + .../vitro/webapp/dao/jena/JenaBaseDaoCon.java | 1 + .../webapp/dao/jena/UserAccountsDaoJena.java | 10 + .../dao/jena/UserAccountsDaoJenaTest.java | 231 +++++++++++------- 5 files changed, 170 insertions(+), 87 deletions(-) diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/beans/UserAccount.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/beans/UserAccount.java index 8c166cf44..b893dcd4d 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/beans/UserAccount.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/beans/UserAccount.java @@ -65,6 +65,9 @@ public class UserAccount { private Set permissionSetUris = Collections.emptySet(); private boolean rootUser = false; + + /** This may be empty, but should never be null. */ + private Set proxiedIndividualUris = Collections.emptySet(); public String getUri() { return uri; @@ -202,6 +205,17 @@ public class UserAccount { this.rootUser = rootUser; } + public Set getProxiedIndividualUris() { + return new HashSet(proxiedIndividualUris); + } + + public void setProxiedIndividualUris(Collection proxiedIndividualUris) { + if (proxiedIndividualUris == null) { + throw new NullPointerException("proxiedIndividualUris may not be null."); + } + this.proxiedIndividualUris = new HashSet(proxiedIndividualUris); + } + private T nonNull(T value, T defaultValue) { return (value == null) ? defaultValue : value; } diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java index 58c05673a..189773686 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java @@ -165,6 +165,7 @@ public class VitroVocabulary { public static final String USERACCOUNT_EXTERNAL_AUTH_ID = VITRO_AUTH + "externalAuthId"; public static final String USERACCOUNT_EXTERNAL_AUTH_ONLY = VITRO_AUTH + "externalAuthOnly"; public static final String USERACCOUNT_HAS_PERMISSION_SET = VITRO_AUTH + "hasPermissionSet"; + public static final String USERACCOUNT_PROXY_EDITOR_FOR = VITRO_AUTH + "proxyEditorFor"; public static final String PERMISSIONSET = VITRO_AUTH + "PermissionSet"; public static final String PERMISSIONSET_HAS_PERMISSION = VITRO_AUTH + "hasPermission"; diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/JenaBaseDaoCon.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/JenaBaseDaoCon.java index 930cd79af..3e8747b51 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/JenaBaseDaoCon.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/JenaBaseDaoCon.java @@ -139,6 +139,7 @@ public class JenaBaseDaoCon { protected DatatypeProperty USERACCOUNT_EXTERNAL_AUTH_ID = _constModel.createDatatypeProperty(VitroVocabulary.USERACCOUNT_EXTERNAL_AUTH_ID); protected DatatypeProperty USERACCOUNT_EXTERNAL_AUTH_ONLY = _constModel.createDatatypeProperty(VitroVocabulary.USERACCOUNT_EXTERNAL_AUTH_ONLY); protected ObjectProperty USERACCOUNT_HAS_PERMISSION_SET = _constModel.createObjectProperty(VitroVocabulary.USERACCOUNT_HAS_PERMISSION_SET); + protected ObjectProperty USERACCOUNT_PROXY_EDITOR_FOR = _constModel.createObjectProperty(VitroVocabulary.USERACCOUNT_PROXY_EDITOR_FOR); protected OntClass PERMISSIONSET = _constModel.createClass(VitroVocabulary.PERMISSIONSET); protected ObjectProperty PERMISSIONSET_HAS_PERMISSION = _constModel.createObjectProperty(VitroVocabulary.PERMISSIONSET_HAS_PERMISSION); diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJena.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJena.java index 9989e5e00..47dbc39ef 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJena.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJena.java @@ -108,6 +108,8 @@ public class UserAccountsDaoJena extends JenaBaseDao implements UserAccountsDao u.setPermissionSetUris(getPropertyResourceURIValues(r, USERACCOUNT_HAS_PERMISSION_SET)); u.setRootUser(isResourceOfType(r, USERACCOUNT_ROOT_USER)); + u.setProxiedIndividualUris(getPropertyResourceURIValues(r, + USERACCOUNT_PROXY_EDITOR_FOR)); return u; } finally { getOntModel().leaveCriticalSection(); @@ -212,6 +214,10 @@ public class UserAccountsDaoJena extends JenaBaseDao implements UserAccountsDao model.add(res, RDF.type, USERACCOUNT_ROOT_USER); } + updatePropertyResourceURIValues(res, + USERACCOUNT_PROXY_EDITOR_FOR, + userAccount.getProxiedIndividualUris(), model); + userAccount.setUri(userUri); return userUri; } catch (InsertException e) { @@ -277,6 +283,10 @@ public class UserAccountsDaoJena extends JenaBaseDao implements UserAccountsDao model.remove(res, RDF.type, USERACCOUNT_ROOT_USER); } + updatePropertyResourceURIValues(res, + USERACCOUNT_PROXY_EDITOR_FOR, + userAccount.getProxiedIndividualUris(), model); + } finally { model.leaveCriticalSection(); } diff --git a/webapp/test/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJenaTest.java b/webapp/test/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJenaTest.java index d01df1f55..616d1dea7 100644 --- a/webapp/test/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJenaTest.java +++ b/webapp/test/edu/cornell/mannlib/vitro/webapp/dao/jena/UserAccountsDaoJenaTest.java @@ -8,6 +8,7 @@ import static org.junit.Assert.fail; import java.io.IOException; import java.io.InputStream; +import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; @@ -36,6 +37,9 @@ import edu.cornell.mannlib.vitro.webapp.beans.UserAccount.Status; * TODO */ public class UserAccountsDaoJenaTest extends AbstractTestClass { + + private static final Set EMPTY = Collections. emptySet(); + /** * Where the model statements are stored for this test. */ @@ -47,8 +51,9 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { private static final String URI_NO_SUCH_USER = NS_MINE + "bogusUser"; private static final String EMAIL_USER1 = "email@able.edu"; - private static final String EMAIL_NO_SUCH_USER = NS_MINE + "bogus@email.com"; - + private static final String EMAIL_NO_SUCH_USER = NS_MINE + + "bogus@email.com"; + private static final String URI_ROLE1 = NS_MINE + "role1"; private static final String URI_ROLE2 = NS_MINE + "role2"; private static final String URI_ROLE3 = NS_MINE + "role3"; @@ -57,6 +62,9 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { private WebappDaoFactoryJena wadf; private UserAccountsDaoJena dao; + private UserAccount user1; + private UserAccount userNew; + @Before public void setup() throws IOException { InputStream stream = UserAccountsDaoJenaTest.class @@ -73,24 +81,24 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { dao = new UserAccountsDaoJena(wadf); } + @Before + public void createUserAccountValues() { + user1 = userAccount(URI_USER1, "email@able.edu", "Zack", "Roberts", + "garbage", "", 0L, false, 5, 12345678L, Status.ACTIVE, "user1", + false, collection(URI_ROLE1), false, EMPTY); + userNew = userAccount("", "email@here", "Joe", "Blow", "XXXX", "YYYY", + 0L, false, 1, 0L, Status.ACTIVE, "jblow", false, EMPTY, false, + EMPTY); + } + + // ---------------------------------------------------------------------- + // Tests for UserAccount methods. + // ---------------------------------------------------------------------- + @Test public void getUserAccountByUriSuccess() { UserAccount u = dao.getUserAccountByUri(URI_USER1); - assertEquals("uri", URI_USER1, u.getUri()); - assertEquals("email", "email@able.edu", u.getEmailAddress()); - assertEquals("firstName", "Zack", u.getFirstName()); - assertEquals("lastName", "Roberts", u.getLastName()); - assertEquals("md5Password", "garbage", u.getMd5Password()); - assertEquals("oldPassword", "", u.getOldPassword()); - assertEquals("linkExpires", 0L, u.getPasswordLinkExpires()); - assertEquals("changeRequired", false, u.isPasswordChangeRequired()); - assertEquals("externalOnly", false, u.isExternalAuthOnly()); - assertEquals("loginCount", 5, u.getLoginCount()); - assertEquals("loginTime", 12345678L, u.getLastLoginTime()); - assertEquals("status", Status.ACTIVE, u.getStatus()); - assertEquals("externalAuthId", "user1", u.getExternalAuthId()); - assertEquals("permissionSetUris", Collections.singleton(URI_ROLE1), - u.getPermissionSetUris()); + assertEqualAccounts(user1, u); } @Test @@ -104,11 +112,11 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { UserAccount u = dao.getUserAccountByUri("bogusUri"); assertNull("null result", u); } - + @Test public void getUserAccountByUriWrongType() { UserAccount u = dao.getUserAccountByUri(URI_ROLE1); - //System.out.println(u); + // System.out.println(u); assertNull("null result", u); } @@ -132,40 +140,10 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { @Test public void insertUserAccountSuccess() { - UserAccount in = new UserAccount(); - in.setUri(""); - in.setEmailAddress("my@email.address"); - in.setFirstName("Joe"); - in.setLastName("Bagadonuts"); - in.setMd5Password("passwordHash"); - in.setOldPassword("oldHash"); - in.setPasswordLinkExpires(999966663333L); - in.setPasswordChangeRequired(true); - in.setExternalAuthOnly(true); - in.setLoginCount(42); - in.setLastLoginTime(8877665544332211L); - in.setStatus(Status.INACTIVE); - in.setExternalAuthId("newUser"); - in.setPermissionSetUris(buildSet(URI_ROLE1, URI_ROLE2)); - - String newUri = dao.insertUserAccount(in); - - UserAccount u = dao.getUserAccountByUri(newUri); - assertEquals("uri", newUri, u.getUri()); - assertEquals("email", "my@email.address", u.getEmailAddress()); - assertEquals("firstName", "Joe", u.getFirstName()); - assertEquals("lastName", "Bagadonuts", u.getLastName()); - assertEquals("md5Password", "passwordHash", u.getMd5Password()); - assertEquals("oldPassword", "oldHash", u.getOldPassword()); - assertEquals("linkExpires", 999966663333L, u.getPasswordLinkExpires()); - assertEquals("changeRequired", true, u.isPasswordChangeRequired()); - assertEquals("externalOnly", true, u.isExternalAuthOnly()); - assertEquals("loginCount", 42, u.getLoginCount()); - assertEquals("lastLoginTime", 8877665544332211L, u.getLastLoginTime()); - assertEquals("status", Status.INACTIVE, u.getStatus()); - assertEquals("externalAuthId", "newUser", u.getExternalAuthId()); - assertEquals("permissionSetUris", buildSet(URI_ROLE1, URI_ROLE2), - u.getPermissionSetUris()); + UserAccount raw = userAccount(userNew); + String uri = dao.insertUserAccount(raw); + UserAccount processed = dao.getUserAccountByUri(uri); + assertEqualAccounts(raw, processed); } @Test(expected = NullPointerException.class) @@ -183,40 +161,15 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { @Test public void updateUserAccountSuccess() { - UserAccount up = new UserAccount(); - up.setUri(URI_USER1); - up.setEmailAddress("updatedEmail@able.edu"); - up.setFirstName("Ezekiel"); - up.setLastName("Roberts"); - up.setMd5Password("differentHash"); - up.setOldPassword("oldHash"); - up.setPasswordLinkExpires(1L); - up.setPasswordChangeRequired(false); - up.setExternalAuthOnly(false); - up.setLoginCount(43); - up.setLastLoginTime(1020304050607080L); - up.setStatus(Status.ACTIVE); - up.setExternalAuthId("updatedUser1"); - up.setPermissionSetUris(buildSet(URI_ROLE1, URI_ROLE3)); + UserAccount orig = userAccount(URI_USER1, "updatedEmail@able.edu", + "Ezekiel", "Roberts", "differentHash", "oldHash", 1L, false, + 43, 1020304050607080L, Status.ACTIVE, "updatedUser1", false, + collection(URI_ROLE1, URI_ROLE3), false, EMPTY); - dao.updateUserAccount(up); + dao.updateUserAccount(orig); - UserAccount u = dao.getUserAccountByUri(URI_USER1); - assertEquals("uri", URI_USER1, u.getUri()); - assertEquals("email", "updatedEmail@able.edu", u.getEmailAddress()); - assertEquals("firstName", "Ezekiel", u.getFirstName()); - assertEquals("lastName", "Roberts", u.getLastName()); - assertEquals("md5Password", "differentHash", u.getMd5Password()); - assertEquals("oldPassword", "oldHash", u.getOldPassword()); - assertEquals("changeExpires", 1L, u.getPasswordLinkExpires()); - assertEquals("changeRequired", false, u.isPasswordChangeRequired()); - assertEquals("externalOnly", false, u.isExternalAuthOnly()); - assertEquals("loginCount", 43, u.getLoginCount()); - assertEquals("lastLoginTime", 1020304050607080L, u.getLastLoginTime()); - assertEquals("status", Status.ACTIVE, u.getStatus()); - assertEquals("externalAuthId", "updatedUser1", u.getExternalAuthId()); - assertEquals("permissionSetUris", buildSet(URI_ROLE1, URI_ROLE3), - u.getPermissionSetUris()); + UserAccount updated = dao.getUserAccountByUri(URI_USER1); + assertEqualAccounts(orig, updated); } @Test(expected = NullPointerException.class) @@ -258,6 +211,31 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { dao.deleteUserAccount(URI_NO_SUCH_USER); } + @Test + public void insertUserAccountWithProxies() { + userNew.setProxiedIndividualUris(collection( + NS_MINE + "userNewProxyOne", NS_MINE + "userNewProxyTwo")); + String userUri = dao.insertUserAccount(userNew); + + UserAccount inserted = dao.getUserAccountByUri(userUri); + assertEqualAccounts(userNew, inserted); + } + + @Test + public void updateUserAccountWithProxies() { + UserAccount beforeAccount = dao.getUserAccountByUri(URI_USER1); + user1.setProxiedIndividualUris(collection(NS_MINE + "newProxyForUser1")); + + dao.updateUserAccount(user1); + + UserAccount updated = dao.getUserAccountByUri(URI_USER1); + assertEqualAccounts(user1, updated); + } + + // ---------------------------------------------------------------------- + // Tests for PermissionSet methods + // ---------------------------------------------------------------------- + @Test public void getPermissionSetByUriSuccess() { PermissionSet ps = dao.getPermissionSetByUri(URI_ROLE1); @@ -285,7 +263,7 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { PermissionSet ps = dao.getPermissionSetByUri(URI_USER1); assertNull("null result", ps); } - + @Test public void getAllPermissionSets() { setLoggerLevel(JenaBaseDao.class, Level.DEBUG); @@ -310,6 +288,85 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { // helper methods // ---------------------------------------------------------------------- + private Collection collection(String... args) { + return Arrays.asList(args); + } + + private UserAccount userAccount(String uri, String emailAddress, + String firstName, String lastName, String md5Password, + String oldPassword, long passwordLinkExpires, + boolean passwordChangeRequired, int loginCount, long lastLoginTime, + Status status, String externalAuthId, boolean externalAuthOnly, + Collection permissionSetUris, boolean rootUser, + Collection proxiedIndividualUris) { + UserAccount ua = new UserAccount(); + ua.setUri(uri); + ua.setEmailAddress(emailAddress); + ua.setFirstName(firstName); + ua.setLastName(lastName); + ua.setMd5Password(md5Password); + ua.setOldPassword(oldPassword); + ua.setPasswordLinkExpires(passwordLinkExpires); + ua.setPasswordChangeRequired(passwordChangeRequired); + ua.setLoginCount(loginCount); + ua.setLastLoginTime(lastLoginTime); + ua.setStatus(status); + ua.setExternalAuthId(externalAuthId); + ua.setExternalAuthOnly(externalAuthOnly); + ua.setPermissionSetUris(permissionSetUris); + ua.setRootUser(rootUser); + ua.setProxiedIndividualUris(proxiedIndividualUris); + return ua; + } + + private UserAccount userAccount(UserAccount in) { + UserAccount out = new UserAccount(); + out.setUri(in.getUri()); + out.setEmailAddress(in.getEmailAddress()); + out.setFirstName(in.getFirstName()); + out.setLastName(in.getLastName()); + out.setMd5Password(in.getMd5Password()); + out.setOldPassword(in.getOldPassword()); + out.setPasswordLinkExpires(in.getPasswordLinkExpires()); + out.setPasswordChangeRequired(in.isPasswordChangeRequired()); + out.setLoginCount(in.getLoginCount()); + out.setLastLoginTime(in.getLastLoginTime()); + out.setStatus(in.getStatus()); + out.setExternalAuthId(in.getExternalAuthId()); + out.setExternalAuthOnly(in.isExternalAuthOnly()); + out.setPermissionSetUris(in.getPermissionSetUris()); + out.setRootUser(in.isRootUser()); + out.setProxiedIndividualUris(in.getProxiedIndividualUris()); + return out; + } + + private void assertEqualAccounts(UserAccount e, UserAccount a) { + if (!e.getUri().equals("")) { + assertEquals("uri", e.getUri(), a.getUri()); + } + assertEquals("email", e.getEmailAddress(), a.getEmailAddress()); + assertEquals("first name", e.getFirstName(), a.getFirstName()); + assertEquals("last name", e.getLastName(), a.getLastName()); + assertEquals("password", e.getMd5Password(), a.getMd5Password()); + assertEquals("old password", e.getOldPassword(), a.getOldPassword()); + assertEquals("link expires", e.getPasswordLinkExpires(), + a.getPasswordLinkExpires()); + assertEquals("password change", e.isPasswordChangeRequired(), + a.isPasswordChangeRequired()); + assertEquals("login count", e.getLoginCount(), a.getLoginCount()); + assertEquals("last login", e.getLastLoginTime(), a.getLastLoginTime()); + assertEquals("status", e.getStatus(), a.getStatus()); + assertEquals("external ID", e.getExternalAuthId(), + a.getExternalAuthId()); + assertEquals("external only", e.isExternalAuthOnly(), + a.isExternalAuthOnly()); + assertEquals("permission sets", e.getPermissionSetUris(), + a.getPermissionSetUris()); + assertEquals("root user", e.isRootUser(), a.isRootUser()); + assertEquals("proxied URIs", e.getProxiedIndividualUris(), + a.getProxiedIndividualUris()); + } + private void assertCorrectPermissionSets(Set expected, Collection actual) { Set> expectedMaps = new HashSet>(); @@ -338,7 +395,7 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass { StmtIterator stmts = ontModel.listStatements(); while (stmts.hasNext()) { Statement stmt = stmts.next(); - //System.out.println(formatStatement(stmt)); + // System.out.println(formatStatement(stmt)); } }