/** * @return {@code true} if this user was created with {@link #getCurrentUser()} when no current * user previously existed and {@link #enableAutomaticUser()} is set, false if was created by any * other means or if a previously "lazy" user was saved remotely. */ /* package */ boolean isLazy() { synchronized (mutex) { return getObjectId() == null && ParseAnonymousUtils.isLinked(this); } }
/* package for tests */ void resolveUser(ParseUser user) { if (!isUnresolvedUser(user)) { return; } if (permissionsById.containsKey(UNRESOLVED_KEY)) { permissionsById.put(user.getObjectId(), permissionsById.get(UNRESOLVED_KEY)); permissionsById.remove(UNRESOLVED_KEY); } unresolvedUser = null; }
/** * Set whether the given user is allowed to read this object. */ public void setReadAccess(ParseUser user, boolean allowed) { if (user.getObjectId() == null) { if (user.isLazy()) { setUnresolvedReadAccess(user, allowed); return; } throw new IllegalArgumentException("cannot setReadAccess for a user with null id"); } setReadAccess(user.getObjectId(), allowed); }
/** * Set whether the given user is allowed to write this object. */ public void setWriteAccess(ParseUser user, boolean allowed) { if (user.getObjectId() == null) { if (user.isLazy()) { setUnresolvedWriteAccess(user, allowed); return; } throw new IllegalArgumentException("cannot setWriteAccess for a user with null id"); } setWriteAccess(user.getObjectId(), allowed); }
private boolean isUnresolvedUser(ParseUser other) { // This might be a different instance, but if they have the same local id, assume it's correct. if (other == null || unresolvedUser == null) return false; return other == unresolvedUser || (other.getObjectId() == null && other.getOrCreateLocalId().equals(unresolvedUser.getOrCreateLocalId())); }
/** * Whether the ParseUser has been authenticated on this device. This will be true if the ParseUser * was obtained via a logIn or signUp method. Only an authenticated ParseUser can be saved (with * altered attributes) and deleted. */ public boolean isAuthenticated() { synchronized (mutex) { ParseUser current = ParseUser.getCurrentUser(); return isLazy() || (getState().sessionToken() != null && current != null && getObjectId().equals(current.getObjectId())); } }
@Override /* package */ void validateSave() { synchronized (mutex) { if (getObjectId() == null) { throw new IllegalArgumentException( "Cannot save a ParseUser until it has been signed up. Call signUp first."); } if (isAuthenticated() || !isDirty() || isCurrentUser()) { return; } } if (!Parse.isLocalDatastoreEnabled()) { // This might be a different of instance of the currentUser, so we need to check objectIds ParseUser current = ParseUser.getCurrentUser(); //TODO (grantland): possible blocking disk i/o if (current != null && getObjectId().equals(current.getObjectId())) { return; } } throw new IllegalArgumentException("Cannot save a ParseUser that is not authenticated."); }
/** * Get whether the given user id is *explicitly* allowed to write this object. Even if this * returns {@code false}, the user may still be able to write it if getPublicWriteAccess returns * {@code true} or a role that the user belongs to has write access. */ public boolean getWriteAccess(ParseUser user) { if (isUnresolvedUser(user)) { return getWriteAccess(UNRESOLVED_KEY); } if (user.isLazy()) { return false; } if (user.getObjectId() == null) { throw new IllegalArgumentException("cannot getWriteAccess for a user with null id"); } return getWriteAccess(user.getObjectId()); }
/** * Get whether the given user id is *explicitly* allowed to read this object. Even if this returns * {@code false}, the user may still be able to access it if getPublicReadAccess returns * {@code true} or a role that the user belongs to has read access. */ public boolean getReadAccess(ParseUser user) { if (isUnresolvedUser(user)) { return getReadAccess(UNRESOLVED_KEY); } if (user.isLazy()) { return false; } if (user.getObjectId() == null) { throw new IllegalArgumentException("cannot getReadAccess for a user with null id"); } return getReadAccess(user.getObjectId()); }
private void stripAnonymity() { synchronized (mutex) { if (ParseAnonymousUtils.isLinked(this)) { if (getObjectId() != null) { putAuthData(ParseAnonymousUtils.AUTH_TYPE, null); } else { removeAuthData(ParseAnonymousUtils.AUTH_TYPE); } } } }
@Test public void testHasReadAccessWithReadAccess() { ParseUser user = mock(ParseUser.class); when(user.getObjectId()).thenReturn("test"); ParseACL acl = mock(ParseACL.class); when(acl.getReadAccess(user)).thenReturn(true); ParseObject object = mock(ParseObject.class); when(object.getACL()).thenReturn(acl); assertTrue(OfflineQueryLogic.hasReadAccess(user, object)); }
@Test public void testMatcherWithNoReadAccess() throws ParseException { OfflineQueryLogic logic = new OfflineQueryLogic(null); ParseQuery.State<ParseObject> query = new ParseQuery.State.Builder<>("TestObject") .build(); ParseACL acl = new ParseACL(); acl.setPublicReadAccess(false); ParseObject object = new ParseObject("TestObject"); object.setACL(acl); ParseUser user = mock(ParseUser.class); when(user.getObjectId()).thenReturn("test"); assertFalse(matches(logic, query, object, user)); }
when(unresolvedUser.getObjectId()).thenReturn("userId"); when(unresolvedUser.isLazy()).thenReturn(false); callback.done(unresolvedUser, null);
if (getObjectId() != null) {
@Test public void testSetCurrentUserStateWithoutAuthData() { // Set user initial state String authType = "facebook"; Map<String, String> authData = new HashMap<>(); authData.put("facebookToken", "facebookTest"); ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .put("oldKey", "oldValue") .put("key", "value") .putAuthData(authType, authData) .build(); ParseUser user = ParseObject.from(userState); user.setIsCurrentUser(true); // Build new state ParseUser.State newUserState = new ParseUser.State.Builder() .objectId("testAgain") .put("key", "valueAgain") .build(); user.setState(newUserState); // Make sure we keep the authData assertEquals(1, user.getAuthData().size()); assertEquals(authData, user.getAuthData().get(authType)); // Make sure old state is replaced assertFalse(user.has("oldKey")); // Make sure new state is set assertEquals("testAgain", user.getObjectId()); assertEquals("valueAgain", user.get("key")); }
@Test public void testSetStateDoesNotAddNonExistentAuthData() { // Set user initial state ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .put("oldKey", "oldValue") .put("key", "value") .build(); ParseUser user = ParseObject.from(userState); user.setIsCurrentUser(true); // Build new state ParseUser.State newUserState = new ParseUser.State.Builder() .objectId("testAgain") .put("key", "valueAgain") .build(); user.setState(newUserState); // Make sure we do not add authData when it did not exist before assertFalse(user.keySet().contains("authData")); assertEquals(1, user.keySet().size()); assertEquals(0, user.getAuthData().size()); // Make sure old state is replaced assertFalse(user.has("oldKey")); // Make sure new state is set assertEquals("testAgain", user.getObjectId()); assertEquals("valueAgain", user.get("key")); }
@Override public void onBind(int position, ParseUser item) { android.util.Log.d("RxParse", "onBind"); String email = item.getEmail() != null ? item.getEmail() : ""; if (!android.text.TextUtils.isEmpty(email)) { icon.setImageURI(Uri.parse("http://gravatar.com/avatar/" + MD5Util.md5Hex(email))); } text1.setText(email + ", " + item.getObjectId()); } }
private void sendMessage() { String messageBody = etMessage.getText().toString(); if (TextUtils.isEmpty(messageBody)) { return; } // Post Message setupMessagePosting(messageBody, currentUser.getObjectId()); // Clear current message etMessage.setText(""); etMessage.clearFocus(); btnSend.clearFocus(); // Hide keyboard InputMethodManager imm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } }
@Override public void done(List<Notification> list, ParseException e) { if (e == null && list.size() > 0) { for (Notification n : list) { UserNotification un = new UserNotification(); un.setUserId(currentUser.getObjectId()); un.setEnabled(true); un.setNotification(n); un.saveInBackground(); } } } });
@Test public void testParseObservableAllNextAfterCompleted() { List<ParseUser> users = mocker(ParseUser.class).when(user -> user.getObjectId()).thenReturn(user -> String.valueOf(user.hashCode())).asList(3); rx.parse2.ParseObservable.all(mocker(ParseQuery.class) .when(query -> query.countInBackground()).thenReturn(query -> Task.forResult(users.size())) .when(query -> query.findInBackground()).thenReturn(query -> Task.forResult(users)) .when(query -> query.setSkip(any(int.class))).thenReturn(query -> null) .when(query -> query.setLimit(any(int.class))).thenReturn(query -> null).mock()) //.doOnNext(user -> System.out.println("" + ((ParseUser) user).getObjectId()))) .test() .assertNoErrors() //.assertValue(check(l -> assertThat(l).isEqualTo(users))) .assertComplete(); }