2019-12-02 00:37:35 +01:00
|
|
|
package org.mercury_im.messenger.data.repository;
|
|
|
|
|
2019-12-02 02:27:32 +01:00
|
|
|
import org.mercury_im.messenger.data.mapping.PeerMapping;
|
|
|
|
import org.mercury_im.messenger.data.model.PeerModel;
|
2019-12-09 13:50:26 +01:00
|
|
|
import org.mercury_im.messenger.util.Optional;
|
2019-12-02 02:27:32 +01:00
|
|
|
import org.mercury_im.messenger.entity.Account;
|
|
|
|
import org.mercury_im.messenger.entity.contact.IPeer;
|
2019-12-02 00:37:35 +01:00
|
|
|
import org.mercury_im.messenger.entity.contact.Peer;
|
|
|
|
import org.mercury_im.messenger.util.ThreadUtils;
|
|
|
|
|
2019-12-02 02:27:32 +01:00
|
|
|
import java.util.ArrayList;
|
2019-12-02 00:37:35 +01:00
|
|
|
import java.util.List;
|
|
|
|
|
|
|
|
import javax.inject.Inject;
|
|
|
|
import javax.inject.Named;
|
|
|
|
|
|
|
|
import io.reactivex.Completable;
|
|
|
|
import io.reactivex.Maybe;
|
|
|
|
import io.reactivex.Observable;
|
|
|
|
import io.reactivex.Scheduler;
|
|
|
|
import io.reactivex.Single;
|
|
|
|
import io.requery.Persistable;
|
2019-12-07 02:04:31 +01:00
|
|
|
import io.requery.query.ResultDelegate;
|
2019-12-02 00:37:35 +01:00
|
|
|
import io.requery.reactivex.ReactiveEntityStore;
|
|
|
|
|
|
|
|
public class XmppPeerRepository
|
|
|
|
extends RequeryRepository
|
|
|
|
implements PeerRepository {
|
|
|
|
|
2019-12-06 15:52:50 +01:00
|
|
|
@Inject
|
|
|
|
AccountRepository accountRepository;
|
|
|
|
|
2019-12-06 20:25:33 +01:00
|
|
|
private final PeerMapping peerMapping;
|
2019-12-02 02:27:32 +01:00
|
|
|
|
2019-12-02 00:37:35 +01:00
|
|
|
@Inject
|
|
|
|
public XmppPeerRepository(ReactiveEntityStore<Persistable> data,
|
|
|
|
@Named(value = ThreadUtils.SCHEDULER_IO) Scheduler subscriberScheduler,
|
2019-12-06 20:25:33 +01:00
|
|
|
@Named(value = ThreadUtils.SCHEDULER_UI) Scheduler observerScheduler,
|
|
|
|
PeerMapping peerMapping) {
|
2019-12-02 00:37:35 +01:00
|
|
|
super(data, subscriberScheduler, observerScheduler);
|
2019-12-06 20:25:33 +01:00
|
|
|
this.peerMapping = peerMapping;
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-12-02 02:27:32 +01:00
|
|
|
public Single<Peer> insertPeer(Peer peer) {
|
2019-12-07 02:04:31 +01:00
|
|
|
return data().insert(peerMapping.toModel(peer, new PeerModel()))
|
|
|
|
.map(model -> peerMapping.toEntity(model, peer))
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Observable<Optional<Peer>> observePeer(long peerId) {
|
|
|
|
return data().select(PeerModel.class)
|
|
|
|
.where(PeerModel.ID.eq(peerId))
|
|
|
|
.get().observableResult()
|
2019-12-07 02:04:31 +01:00
|
|
|
.map(result -> new Optional<>(peerMapping.toEntity(result.firstOrNull(), new IPeer())))
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-12-02 02:27:32 +01:00
|
|
|
public Maybe<Peer> getPeer(long peerId) {
|
|
|
|
return data().select(PeerModel.class)
|
|
|
|
.where(PeerModel.ID.eq(peerId))
|
|
|
|
.get().maybe()
|
2019-12-07 02:04:31 +01:00
|
|
|
.map(model -> peerMapping.toEntity(model, new IPeer()))
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-12-02 02:27:32 +01:00
|
|
|
public Observable<Optional<Peer>> observePeerByAddress(long accountId, String address) {
|
|
|
|
return data().select(PeerModel.class)
|
|
|
|
.where(PeerModel.ACCOUNT_ID.eq(accountId))
|
|
|
|
.and(PeerModel.ADDRESS.eq(address))
|
|
|
|
.get().observableResult()
|
2019-12-07 02:04:31 +01:00
|
|
|
.map(ResultDelegate::firstOrNull)
|
|
|
|
.map(peerMapping::toEntity)
|
|
|
|
.map(Optional::new)
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
2019-12-06 15:52:50 +01:00
|
|
|
@Override
|
|
|
|
public Single<Peer> getOrCreatePeer(long accountId, String address) {
|
|
|
|
return accountRepository.getAccount(accountId).toSingle()
|
|
|
|
.flatMap(account -> getOrCreatePeer(account, address));
|
|
|
|
}
|
|
|
|
|
2019-12-02 00:37:35 +01:00
|
|
|
@Override
|
2019-12-02 02:27:32 +01:00
|
|
|
public Maybe<Peer> getPeerByAddress(long accountId, String address) {
|
|
|
|
return data().select(PeerModel.class)
|
|
|
|
.where(PeerModel.ACCOUNT_ID.eq(accountId))
|
|
|
|
.and(PeerModel.ADDRESS.eq(address))
|
|
|
|
.get().maybe()
|
2019-12-07 02:04:31 +01:00
|
|
|
.map(peerMapping::toEntity)
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-12-07 02:04:31 +01:00
|
|
|
public Single<Peer> getOrCreatePeer(Account account, String address) {
|
|
|
|
return getPeerByAddress(account, address)
|
|
|
|
.switchIfEmpty(Single
|
|
|
|
.just(new IPeer(){
|
|
|
|
{
|
|
|
|
setAccount(account);
|
|
|
|
setAddress(address);
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.flatMap(this::insertPeer))
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Observable<List<Peer>> observeAllPeers() {
|
2019-12-02 02:27:32 +01:00
|
|
|
return data().select(PeerModel.class)
|
|
|
|
.get().observableResult()
|
2019-12-07 02:04:31 +01:00
|
|
|
.map(ResultDelegate::toList)
|
|
|
|
.map(peerModels -> {
|
2019-12-02 02:27:32 +01:00
|
|
|
List<Peer> peerEntities = new ArrayList<>(peerModels.size());
|
|
|
|
for (PeerModel model : peerModels) {
|
2019-12-07 02:04:31 +01:00
|
|
|
peerEntities.add(peerMapping.toEntity(model));
|
2019-12-02 02:27:32 +01:00
|
|
|
}
|
|
|
|
return peerEntities;
|
|
|
|
})
|
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-12-02 02:27:32 +01:00
|
|
|
public Single<Peer> updatePeer(Peer peer) {
|
|
|
|
// In order to update, we fetch the model, update it and write it back.
|
|
|
|
return data().select(PeerModel.class)
|
|
|
|
.where(PeerModel.ID.eq(peer.getId()))
|
|
|
|
.get().maybe().toSingle()
|
2019-12-07 02:04:31 +01:00
|
|
|
// write changes into model
|
|
|
|
.map(model -> peerMapping.toModel(peer, model))
|
|
|
|
.flatMap(data()::update)
|
|
|
|
.map(model -> peerMapping.toEntity(model, peer))
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-12-02 02:27:32 +01:00
|
|
|
public Single<Peer> upsertPeer(Peer peer) {
|
|
|
|
return data().select(PeerModel.class)
|
|
|
|
.where(PeerModel.ID.eq(peer.getId()))
|
|
|
|
.get().maybe()
|
|
|
|
// if not exists, create
|
2019-12-07 02:04:31 +01:00
|
|
|
.switchIfEmpty(Single.just(peer)
|
|
|
|
.map(peerMapping::toModel)
|
|
|
|
.flatMap(data()::insert))
|
|
|
|
// write changes into fetched model
|
|
|
|
.map(model -> peerMapping.toModel(peer, model))
|
|
|
|
// write changed model back to db
|
|
|
|
.flatMap(data()::update)
|
|
|
|
.map(model -> peerMapping.toEntity(model, peer))
|
2019-12-02 02:27:32 +01:00
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-12-02 02:27:32 +01:00
|
|
|
public Completable deletePeer(Peer peer) {
|
|
|
|
return data().delete(PeerModel.class)
|
|
|
|
.where(PeerModel.ID.eq(peer.getId()))
|
|
|
|
.get().single().ignoreElement()
|
|
|
|
.subscribeOn(subscriberScheduler())
|
|
|
|
.observeOn(observerScheduler());
|
2019-12-02 00:37:35 +01:00
|
|
|
}
|
|
|
|
}
|