public Completable updateIndex() { return Completable.create(e -> { final Map<String, String> values = new HashMap<String, String>(); String name = model.getName(); String email = model.getEmail(); String phoneNumber = model.metaStringForKey(Keys.Phone); values.put(Keys.Name, StringUtils.isNotEmpty(name) ? processForQuery(name) : ""); values.put(Keys.Email, StringUtils.isNotEmpty(email) ? processForQuery(email) : ""); values.put(Keys.Phone, StringUtils.isNotEmpty(phoneNumber) ? processForQuery(phoneNumber) : ""); final DatabaseReference ref = FirebasePaths.indexRef().child(model.getEntityID()); ref.setValue(values, (firebaseError, firebase) -> { if (firebaseError == null) { e.onComplete(); } else { e.onError(firebaseError.toException()); } }); }).subscribeOn(Schedulers.single()); }
public static Completable remove (final DatabaseReference ref) { return Completable.create(e -> ref.removeValue((databaseError, databaseReference) -> { if(databaseError != null) { e.onError(new Throwable(databaseError.getMessage())); } else { e.onComplete(); } })).subscribeOn(Schedulers.single()); }
switch (error.getCode()) code = ChatError.Code.USER_CODE_EXCEPTION; String[] stacktrace = error.toException().getMessage().split(": ");
private void warnIfWriteFailed(String writeType, Path path, DatabaseError error) { // DATA_STALE is a normal, expected error during transaction processing. if (error != null && !(error.getCode() == DatabaseError.DATA_STALE || error.getCode() == DatabaseError.WRITE_CANCELED)) { logger.warn(writeType + " at " + path.toString() + " failed: " + error.toString()); } }
@Override public String toString() { return databaseError.toString(); } }
@Test public void testObserveSingleValue_Disconnected() { TestSubscriber<TestData> testSubscriber = new TestSubscriber<>(); RxFirebaseDatabase.observeSingleValueEvent(mockDatabase, TestData.class) .subscribeOn(Schedulers.immediate()) .subscribe(testSubscriber); ArgumentCaptor<ValueEventListener> argument = ArgumentCaptor.forClass(ValueEventListener.class); verify(mockDatabase).addListenerForSingleValueEvent(argument.capture()); argument.getValue().onCancelled(DatabaseError.fromCode(DatabaseError.DISCONNECTED)); testSubscriber.assertError(RxFirebaseDataException.class); testSubscriber.assertNotCompleted(); testSubscriber.unsubscribe(); }
abortTransaction = true; abortReason = transaction.abortReason; if (abortReason.getCode() != DatabaseError.WRITE_CANCELED) { events.addAll( serverSyncTree.ackUserWrite( if (transaction.retryCount >= TRANSACTION_MAX_RETRIES) { abortTransaction = true; abortReason = DatabaseError.fromStatus(TRANSACTION_TOO_MANY_RETRIES); events.addAll( serverSyncTree.ackUserWrite( result = transaction.handler.doTransaction(mutableCurrent); } catch (Throwable e) { error = DatabaseError.fromException(e); result = Transaction.abort();
@Override public int getCode() { return databaseError.getCode(); }
final DatabaseError abortError; if (reason == DatabaseError.OVERRIDDEN_BY_SET) { abortError = DatabaseError.fromStatus(TRANSACTION_OVERRIDE_BY_SET); } else { hardAssert( reason == DatabaseError.WRITE_CANCELED, "Unknown transaction abort reason: " + reason); abortError = DatabaseError.fromCode(DatabaseError.WRITE_CANCELED);
public Completable sendPasswordResetMail(final String email) { return Completable.create( emitter->{ OnCompleteListener<Void> resultHandler = task->{ if (task.isSuccessful()) { emitter.onComplete(); } else { emitter.onError(getFirebaseError(DatabaseError.fromException(task.getException()))); } }; FirebaseAuth.getInstance().sendPasswordResetEmail(email).addOnCompleteListener(resultHandler); }).subscribeOn(Schedulers.single()); }
@Override public void onCancelled(DatabaseError databaseError) { Log.e(TAG, databaseError.toString()); } };
@Test public void testObserveChildEvent_Cancelled() { TestSubscriber<RxFirebaseChildEvent<TestData>> testSubscriber = new TestSubscriber<>(); RxFirebaseDatabase.observeChildEvent(mockDatabase, TestData.class) .subscribeOn(Schedulers.immediate()) .subscribe(testSubscriber); ArgumentCaptor<ChildEventListener> argument = ArgumentCaptor.forClass(ChildEventListener.class); verify(mockDatabase).addChildEventListener(argument.capture()); argument.getValue().onCancelled(DatabaseError.fromCode(DatabaseError.DISCONNECTED)); testSubscriber.assertError(RxFirebaseDataException.class); testSubscriber.assertNotCompleted(); testSubscriber.unsubscribe(); }
@Override public void onCancelled(DatabaseError databaseError) { Toast.makeText(ProfileActivity.this, databaseError.getCode(), Toast.LENGTH_SHORT).show(); } });
@Override public Completable changePassword(String email, String oldPassword, final String newPassword) { return Completable.create( emitter->{ FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); OnCompleteListener<Void> resultHandler = task->{ if (task.isSuccessful()) { emitter.onComplete(); } else { emitter.onError(getFirebaseError(DatabaseError.fromException(task.getException()))); } }; user.updatePassword(newPassword).addOnCompleteListener(resultHandler); }) .subscribeOn(Schedulers.single()); }
@Override public Completable addContact(User user, ConnectionType type) { return Completable.create(emitter -> { DatabaseReference ref = FirebasePaths.userContactsRef(ChatSDK.currentUser().getEntityID()).child(user.getEntityID()); HashMap<String, Integer> data = new HashMap<>(); data.put(Keys.Type, type.ordinal()); ref.setValue(data, (databaseError, databaseReference) -> { if (databaseError == null) { emitter.onComplete(); } else { emitter.onError(databaseError.toException()); } }); }); }
public static Completable set (final DatabaseReference ref, final Object value, final boolean onDisconnectRemoveValue) { return Completable.create(e -> { ref.setValue(value, (databaseError, databaseReference) -> { if(databaseError != null) { e.onError(new Throwable(databaseError.getMessage())); } else { e.onComplete(); } }); if(onDisconnectRemoveValue) { ref.onDisconnect().removeValue(); } }).subscribeOn(Schedulers.single()); } }
@Override public void onCancelled(DatabaseError databaseError) { Log.e(TAG, databaseError.toString()); } });
@Test public void testObserveSingleValueDisconnected() { TestObserver<ChildData> testObserver = RxFirebaseDatabase .observeSingleValueEvent(databaseReference, ChildData.class) .test(); ArgumentCaptor<ValueEventListener> argument = ArgumentCaptor.forClass(ValueEventListener.class); verify(databaseReference).addListenerForSingleValueEvent(argument.capture()); argument.getValue().onCancelled(DatabaseError.fromCode(DatabaseError.DISCONNECTED)); testObserver.assertError(RxFirebaseDataException.class) .assertNotComplete() .dispose(); }
private void ackWriteAndRerunTransactions(long writeId, Path path, DatabaseError error) { if (error != null && error.getCode() == DatabaseError.WRITE_CANCELED) { // This write was already removed, we just need to ignore it... } else { boolean success = error == null; List<? extends Event> clearEvents = serverSyncTree.ackUserWrite(writeId, !success, /*persist=*/ true, serverClock); if (clearEvents.size() > 0) { rerunTransactions(path); } postEvents(clearEvents); } }
error = DatabaseError.fromException(e); result = Transaction.abort();