NIHVIVO-2343 Extend UserAccount to include proxiedIndividualUris; extend the DAO.

webapp/src/edu/cornell/mannlib/vitro/webapp/beans/UserAccount.java

@@ -65,6 +65,9 @@ public class UserAccount {
 	private Set<String> permissionSetUris = Collections.emptySet();
 
 	private boolean rootUser = false;
+	
+	/** This may be empty, but should never be null. */
+	private Set<String> proxiedIndividualUris = Collections.emptySet();
 
 	public String getUri() {
 		return uri;
@@ -202,6 +205,17 @@ public class UserAccount {
 		this.rootUser = rootUser;
 	}
 
+	public Set<String> getProxiedIndividualUris() {
+		return new HashSet<String>(proxiedIndividualUris);
+	}
+
+	public void setProxiedIndividualUris(Collection<String> proxiedIndividualUris) {
+		if (proxiedIndividualUris == null) {
+			throw new NullPointerException("proxiedIndividualUris may not be null.");
+		}
+		this.proxiedIndividualUris = new HashSet<String>(proxiedIndividualUris);
+	}
+
 	private <T> T nonNull(T value, T defaultValue) {
 		return (value == null) ? defaultValue : value;
 	}

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";

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);

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();
 		}

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<String> EMPTY = Collections.<String> 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());
+		assertEqualAccounts(user1, u);
-		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());
 	}
 
 	@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();
+		UserAccount raw = userAccount(userNew);
-		in.setUri("");
+		String uri = dao.insertUserAccount(raw);
-		in.setEmailAddress("my@email.address");
+		UserAccount processed = dao.getUserAccountByUri(uri);
-		in.setFirstName("Joe");
+		assertEqualAccounts(raw, processed);
-		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());
 	}
 
 	@Test(expected = NullPointerException.class)
@@ -183,40 +161,15 @@ public class UserAccountsDaoJenaTest extends AbstractTestClass {
 
 	@Test
 	public void updateUserAccountSuccess() {
-		UserAccount up = new UserAccount();
+		UserAccount orig = userAccount(URI_USER1, "updatedEmail@able.edu",
-		up.setUri(URI_USER1);
+				"Ezekiel", "Roberts", "differentHash", "oldHash", 1L, false,
-		up.setEmailAddress("updatedEmail@able.edu");
+				43, 1020304050607080L, Status.ACTIVE, "updatedUser1", false,
-		up.setFirstName("Ezekiel");
+				collection(URI_ROLE1, URI_ROLE3), false, EMPTY);
-		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));
 
-		dao.updateUserAccount(up);
+		dao.updateUserAccount(orig);
 
-		UserAccount u = dao.getUserAccountByUri(URI_USER1);
+		UserAccount updated = dao.getUserAccountByUri(URI_USER1);
-		assertEquals("uri", URI_USER1, u.getUri());
+		assertEqualAccounts(orig, updated);
-		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());
 	}
 
 	@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<String> 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<String> permissionSetUris, boolean rootUser,
+			Collection<String> 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<PermissionSet> expected,
 			Collection<PermissionSet> actual) {
 		Set<Map<String, Object>> expectedMaps = new HashSet<Map<String, Object>>();
@@ -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));
 		}
 	}