More work on data component

data/src/main/java/org/mercury_im/messenger/data/di/MappingModule.java

@@ -27,6 +27,6 @@ public class MappingModule {
     @Provides
     @Singleton
     public static DirectChatMapping directChatMapping() {
-        return new DirectChatMapping(accountMapping(), peerMapping());
+        return new DirectChatMapping(peerMapping());
     }
 }

data/src/main/java/org/mercury_im/messenger/data/mapping/AccountMapping.java

@@ -2,6 +2,7 @@ package org.mercury_im.messenger.data.mapping;
 
 import org.mercury_im.messenger.data.model.AccountModel;
 import org.mercury_im.messenger.entity.Account;
+import org.mercury_im.messenger.entity.IAccount;
 import org.mercury_im.messenger.entity.PasswordAuthentication;
 
 import javax.inject.Inject;
@@ -33,7 +34,9 @@ public class AccountMapping implements Mapping<Account, AccountModel> {
         if (model == null) {
             return null;
         }
-
+        if (entity == null) {
+            entity = new IAccount();
+        }
         entity.setId(model.getId());
         entity.setAddress(model.getAddress());
         entity.setEnabled(model.isEnabled());

data/src/main/java/org/mercury_im/messenger/data/mapping/ContactMapping.java

@@ -0,0 +1,24 @@
+package org.mercury_im.messenger.data.mapping;
+
+import org.mercury_im.messenger.data.model.ContactModel;
+import org.mercury_im.messenger.entity.contact.Contact;
+
+public class ContactMapping implements Mapping<Contact, ContactModel> {
+
+    @Override
+    public ContactModel entityToModel(Contact entity, ContactModel model) {
+        if (entity == null) {
+            return null;
+        }
+        if (model == null) {
+            model = new ContactModel();
+        }
+
+        return null;
+    }
+
+    @Override
+    public Contact modelToEntity(ContactModel model, Contact entity) {
+        return null;
+    }
+}

data/src/main/java/org/mercury_im/messenger/data/mapping/DirectChatMapping.java

@@ -2,19 +2,17 @@ package org.mercury_im.messenger.data.mapping;
 
 import org.mercury_im.messenger.data.model.DirectChatModel;
 import org.mercury_im.messenger.entity.chat.DirectChat;
+import org.mercury_im.messenger.entity.chat.IDirectChat;
 import org.mercury_im.messenger.entity.contact.Peer;
 
 import javax.inject.Inject;
 
 public class DirectChatMapping implements Mapping<DirectChat, DirectChatModel> {
 
-    private final AccountMapping accountMapping;
-
     private final PeerMapping peerMapping;
 
     @Inject
-    public DirectChatMapping(AccountMapping accountMapping, PeerMapping peerMapping) {
-        this.accountMapping = accountMapping;
+    public DirectChatMapping(PeerMapping peerMapping) {
         this.peerMapping = peerMapping;
     }
 
@@ -23,6 +21,9 @@ public class DirectChatMapping implements Mapping<DirectChat, DirectChatModel> {
         if (entity == null) {
             return null;
         }
+        if (model == null) {
+            model = new DirectChatModel();
+        }
         model.setPeer(peerMapping.entityToModel(entity.getPeer(), model.getPeer()));
         return model;
     }
@@ -32,6 +33,9 @@ public class DirectChatMapping implements Mapping<DirectChat, DirectChatModel> {
         if (model == null) {
             return null;
         }
+        if (entity == null) {
+            entity = new IDirectChat();
+        }
         entity.setId(model.getId());
         Peer peer = peerMapping.modelToEntity(model.getPeer(), entity.getPeer());
         entity.setPeer(peer);

data/src/main/java/org/mercury_im/messenger/data/mapping/GroupChatMapping.java

@@ -0,0 +1,46 @@
+package org.mercury_im.messenger.data.mapping;
+
+import org.mercury_im.messenger.data.model.GroupChatModel;
+import org.mercury_im.messenger.entity.chat.GroupChat;
+import org.mercury_im.messenger.entity.chat.IGroupChat;
+
+import javax.inject.Inject;
+
+public class GroupChatMapping implements Mapping<GroupChat, GroupChatModel> {
+
+    private final AccountMapping accountMapping;
+
+    @Inject
+    public GroupChatMapping(AccountMapping accountMapping) {
+        this.accountMapping = accountMapping;
+    }
+
+    @Override
+    public GroupChatModel entityToModel(GroupChat entity, GroupChatModel model) {
+        if (entity == null) {
+            return null;
+        }
+        if (model == null) {
+            model = new GroupChatModel();
+        }
+        model.setAccount(accountMapping.entityToModel(entity.getAccount(), model.getAccount()));
+        model.setAddress(entity.getRoomAddress());
+        model.setName(entity.getRoomName());
+        return model;
+    }
+
+    @Override
+    public GroupChat modelToEntity(GroupChatModel model, GroupChat entity) {
+        if (model == null) {
+            return null;
+        }
+        if (entity == null) {
+            entity = new IGroupChat();
+        }
+        entity.setId(model.getId());
+        entity.setAccount(accountMapping.modelToEntity(model.getAccount(), entity.getAccount()));
+        entity.setRoomAddress(model.getAddress());
+        entity.setRoomName(model.getName());
+        return entity;
+    }
+}

data/src/main/java/org/mercury_im/messenger/data/mapping/PeerMapping.java

@@ -33,6 +33,9 @@ public class PeerMapping implements Mapping<Peer, PeerModel> {
         if (model == null) {
             return null;
         }
+        if (entity == null) {
+            entity = new IPeer();
+        }
         entity.setAccount(accountMapping.modelToEntity(model.getAccount(), entity.getAccount()));
         entity.setAddress(model.getAddress());
         entity.setId(model.getId());

data/src/main/java/org/mercury_im/messenger/data/model/AbstractAccountModel.java

@@ -6,8 +6,6 @@ import io.requery.Generated;
 import io.requery.Key;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Getter;
-import lombok.Setter;
 
 @Table(name = "accounts")
 @Entity

data/src/main/java/org/mercury_im/messenger/data/model/AbstractContactModel.java

@@ -11,7 +11,6 @@ import io.requery.Key;
 import io.requery.OneToOne;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "contacts")

data/src/main/java/org/mercury_im/messenger/data/model/AbstractDirectChatModel.java

@@ -7,7 +7,6 @@ import io.requery.Key;
 import io.requery.OneToOne;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "chats")

data/src/main/java/org/mercury_im/messenger/data/model/AbstractDirectMessagesRelation.java

@@ -7,7 +7,6 @@ import io.requery.Key;
 import io.requery.ManyToOne;
 import io.requery.OneToOne;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "direct_messages")

data/src/main/java/org/mercury_im/messenger/data/model/AbstractEntityCapsModel.java

@@ -2,11 +2,9 @@ package org.mercury_im.messenger.data.model;
 
 import io.requery.Column;
 import io.requery.Entity;
-import io.requery.Generated;
 import io.requery.Key;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Setter;
 
 @Table(name = "entity_caps")
 @Entity

data/src/main/java/org/mercury_im/messenger/data/model/AbstractGroupChatModel.java

@@ -4,9 +4,9 @@ import io.requery.Column;
 import io.requery.Entity;
 import io.requery.Generated;
 import io.requery.Key;
+import io.requery.ManyToOne;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "groupchats")
@@ -15,7 +15,9 @@ public abstract class AbstractGroupChatModel implements Persistable {
     @Key @Generated
     long id;
 
-    // TODO: Add Account?
+    @Column(nullable = false)
+    @ManyToOne
+    AccountModel account;
 
     @Column(nullable = false)
     String address;

data/src/main/java/org/mercury_im/messenger/data/model/AbstractGroupMessagesRelation.java

@@ -7,7 +7,6 @@ import io.requery.Key;
 import io.requery.ManyToOne;
 import io.requery.OneToOne;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "group_messages")

data/src/main/java/org/mercury_im/messenger/data/model/AbstractMessageModel.java

@@ -4,13 +4,10 @@ import java.util.Date;
 
 import io.requery.Column;
 import io.requery.Entity;
-import io.requery.ForeignKey;
 import io.requery.Generated;
 import io.requery.Key;
-import io.requery.ManyToOne;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "messages")

data/src/main/java/org/mercury_im/messenger/data/model/AbstractPeerModel.java

@@ -8,7 +8,6 @@ import io.requery.Key;
 import io.requery.ManyToOne;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "peers")

data/src/main/java/org/mercury_im/messenger/data/model/AbstractSaslAuthenticationResultModel.java

@@ -7,7 +7,6 @@ import io.requery.Key;
 import io.requery.ManyToOne;
 import io.requery.Persistable;
 import io.requery.Table;
-import lombok.Setter;
 
 @Entity
 @Table(name = "sasl_auth")

data/src/main/java/org/mercury_im/messenger/data/repository/XmppAccountRepository.java

@@ -110,10 +110,8 @@ public class XmppAccountRepository
                 .where(AccountModel.ID.eq(account.getId()))
                 .get().maybe().toSingle() // to single
                 .map(model -> {
-                    // update it
-                    model.setEnabled(account.isEnabled());
-                    model.setPassword(account.getAuthentication().getPassword());
-                    model.setAddress(account.getAddress());
+                    // copy changes from the entity to the model
+                    model = accountMapping.entityToModel(account, model);
                     // write the updated model back
                     model = data().update(model).blockingGet();
                     return accountMapping.modelToEntity(model, account);
@@ -133,9 +131,7 @@ public class XmppAccountRepository
                 // finally
                 .map(model -> {
                     // update the model
-                    model.setEnabled(account.isEnabled());
-                    model.setPassword(account.getAuthentication().getPassword());
-                    model.setAddress(account.getAddress());
+                    model = accountMapping.entityToModel(account, model);
                     // write the updated model back
                     model = data().update(model).blockingGet();
                     return accountMapping.modelToEntity(model, account);

data/src/main/java/org/mercury_im/messenger/data/repository/XmppDirectChatRepository.java

@@ -11,6 +11,7 @@ import org.mercury_im.messenger.entity.contact.Peer;
 import org.mercury_im.messenger.entity.message.Message;
 import org.mercury_im.messenger.util.ThreadUtils;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import javax.inject.Inject;
@@ -22,6 +23,7 @@ import io.reactivex.Observable;
 import io.reactivex.Scheduler;
 import io.reactivex.Single;
 import io.requery.Persistable;
+import io.requery.query.ResultDelegate;
 import io.requery.reactivex.ReactiveEntityStore;
 
 public class XmppDirectChatRepository
@@ -77,7 +79,7 @@ public class XmppDirectChatRepository
     }
 
     @Override
-    public Observable<Optional<DirectChat>> observeDirectChatByInterlocutor(Peer peer) {
+    public Observable<Optional<DirectChat>> observeDirectChatByPeer(Peer peer) {
         return data().select(DirectChatModel.class)
                 .where(DirectChatModel.PEER_ID.eq(peer.getId()))
                 .get().observableResult()
@@ -88,28 +90,67 @@ public class XmppDirectChatRepository
     }
 
     @Override
-    public Maybe<DirectChat> getDirectChatByInterlocutor(Peer peer) {
-        return null;
+    public Maybe<DirectChat> getDirectChatByPeer(Peer peer) {
+        return data().select(DirectChatModel.class)
+                .where(DirectChatModel.PEER_ID.eq(peer.getId()))
+                .get().maybe()
+                .map(model -> directChatMapping.modelToEntity(model, new IDirectChat()))
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
     }
 
     @Override
     public Observable<List<DirectChat>> observeAllDirectChats() {
-        return null;
+        return data().select(DirectChatModel.class)
+                .get().observableResult()
+                .map(ResultDelegate::toList)
+                .map(list -> {
+                    List<DirectChat> entities = new ArrayList<>(list.size());
+                    for (DirectChatModel model : list) {
+                        entities.add(directChatMapping.modelToEntity(model, new IDirectChat()));
+                    }
+                    return entities;
+                })
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
     }
 
     @Override
     public Single<DirectChat> updateDirectChat(DirectChat chat) {
-        return null;
+        return data().select(DirectChatModel.class)
+                .where(DirectChatModel.ID.eq(chat.getId()))
+                .get().maybe().toSingle()
+                .map(model -> {
+                    model = directChatMapping.entityToModel(chat, model);
+                    model = data().update(model).blockingGet();
+                    return directChatMapping.modelToEntity(model, chat);
+                })
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
     }
 
     @Override
     public Single<DirectChat> upsertDirectChat(DirectChat chat) {
-        return null;
+        return data().select(DirectChatModel.class)
+                .where(DirectChatModel.ID.eq(chat.getId()))
+                .get().maybe()
+                .switchIfEmpty(data().insert(directChatMapping.entityToModel(chat, new DirectChatModel())))
+                .map(model -> {
+                    model = directChatMapping.entityToModel(chat, model);
+                    model = data().update(model).blockingGet();
+                    return directChatMapping.modelToEntity(model, chat);
+                })
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
     }
 
     @Override
     public Completable deleteDirectChat(DirectChat chat) {
-        return null;
+        return data().delete(DirectChatModel.class)
+                .where(DirectChatModel.ID.eq(chat.getId()))
+                .get().single().ignoreElement()
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
     }
 
     @Override

data/src/main/java/org/mercury_im/messenger/data/repository/XmppGroupChatRepository.java

@@ -0,0 +1,176 @@
+package org.mercury_im.messenger.data.repository;
+
+import org.mercury_im.messenger.data.mapping.GroupChatMapping;
+import org.mercury_im.messenger.data.model.GroupChatModel;
+import org.mercury_im.messenger.data.util.Optional;
+import org.mercury_im.messenger.entity.chat.GroupChat;
+import org.mercury_im.messenger.entity.chat.IGroupChat;
+import org.mercury_im.messenger.entity.message.Message;
+import org.mercury_im.messenger.util.ThreadUtils;
+
+import java.util.ArrayList;
+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;
+import io.requery.query.ResultDelegate;
+import io.requery.reactivex.ReactiveEntityStore;
+
+public class XmppGroupChatRepository
+        extends RequeryRepository
+        implements GroupChatRepository {
+
+    @Inject
+    GroupChatMapping groupChatMapping;
+
+    @Inject
+    public XmppGroupChatRepository(
+            ReactiveEntityStore<Persistable> data,
+            @Named(value = ThreadUtils.SCHEDULER_IO) Scheduler subscriberScheduler,
+            @Named(value = ThreadUtils.SCHEDULER_UI) Scheduler observerScheduler) {
+        super(data, subscriberScheduler, observerScheduler);
+    }
+
+    @Override
+    public Single<GroupChat> insertGroupChat(GroupChat chat) {
+        return data().insert(groupChatMapping.entityToModel(chat, new GroupChatModel()))
+                .map(model -> groupChatMapping.modelToEntity(model, chat))
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Observable<Optional<GroupChat>> observeGroupChat(long chatId) {
+        return data().select(GroupChatModel.class)
+                .where(GroupChatModel.ID.eq(chatId))
+                .get().observableResult()
+                .map(result -> new Optional<>(
+                        groupChatMapping.modelToEntity(result.firstOrNull(), new IGroupChat())))
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Maybe<GroupChat> getGroupChat(long chatId) {
+        return data().select(GroupChatModel.class)
+                .where(GroupChatModel.ID.eq(chatId))
+                .get().maybe()
+                .map(model -> groupChatMapping.modelToEntity(model, new IGroupChat()))
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Observable<Optional<GroupChat>> observeGroupChatByRoomAddress(String roomAddress) {
+        return data().select(GroupChatModel.class)
+                .where(GroupChatModel.ADDRESS.eq(roomAddress))
+                .get().observableResult()
+                .map(result -> new Optional<>(
+                        groupChatMapping.modelToEntity(result.firstOrNull(), new IGroupChat())))
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Maybe<GroupChat> getGroupChatByRoomAddress(String roomAddress) {
+        return data().select(GroupChatModel.class)
+                .where(GroupChatModel.ADDRESS.eq(roomAddress))
+                .get().maybe()
+                .map(model -> groupChatMapping.modelToEntity(model, new IGroupChat()))
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Observable<List<GroupChat>> observeAllGroupChats() {
+        return data().select(GroupChatModel.class)
+                .get().observableResult()
+                .map(ResultDelegate::toList)
+                .map(list -> {
+                    List<GroupChat> entities = new ArrayList<>(list.size());
+                    for (GroupChatModel model : list) {
+                        entities.add(groupChatMapping.modelToEntity(model, new IGroupChat()));
+                    }
+                    return entities;
+                })
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Single<GroupChat> updateGroupChat(GroupChat chat) {
+        return data().select(GroupChatModel.class)
+                .where(GroupChatModel.ID.eq(chat.getId()))
+                .get().maybe().toSingle() // to single
+                .map(model -> {
+                    // copy changes from entity to the model
+                    model = groupChatMapping.entityToModel(chat, model);
+                    // write the updated model back
+                    model = data().update(model).blockingGet();
+                    return groupChatMapping.modelToEntity(model, chat);
+                })
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Single<GroupChat> upsertGroupChat(GroupChat chat) {
+        // Try to fetch model
+        return data().select(GroupChatModel.class)
+                .where(GroupChatModel.ID.eq(chat.getId()))
+                .get().maybe()
+                // If it does not exist, create a new model from the entity
+                .switchIfEmpty(data().insert(groupChatMapping.entityToModel(chat, new GroupChatModel())))
+                // finally
+                .map(model -> {
+                    // update the model
+                    model = groupChatMapping.entityToModel(chat, model);
+                    // write the updated model back
+                    model = data().update(model).blockingGet();
+                    return groupChatMapping.modelToEntity(model, chat);
+                })
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Completable deleteGroupChat(GroupChat chat) {
+        return data().delete(GroupChatModel.class)
+                .where(GroupChatModel.ID.eq(chat.getId()))
+                .get().single().ignoreElement()
+                .subscribeOn(subscriberScheduler())
+                .observeOn(observerScheduler());
+    }
+
+    @Override
+    public Single<Message> insertMessage(GroupChat chat, Message message) {
+        return null;
+    }
+
+    @Override
+    public Observable<List<Message>> observeMessages(GroupChat chat) {
+        return null;
+    }
+
+    @Override
+    public Single<Message> updateMessage(Message message) {
+        return null;
+    }
+
+    @Override
+    public Single<Message> upsertMessage(GroupChat chat, Message message) {
+        return null;
+    }
+
+    @Override
+    public Completable deleteMessage(Message message) {
+        return null;
+    }
+}

domain/src/main/java/org/mercury_im/messenger/data/repository/DirectChatRepository.java

@@ -20,9 +20,9 @@ public interface DirectChatRepository {
 
     Maybe<DirectChat> getDirectChat(long chatId);
 
-    Observable<Optional<DirectChat>> observeDirectChatByInterlocutor(Peer peer);
+    Observable<Optional<DirectChat>> observeDirectChatByPeer(Peer peer);
 
-    Maybe<DirectChat> getDirectChatByInterlocutor(Peer peer);
+    Maybe<DirectChat> getDirectChatByPeer(Peer peer);
 
     Observable<List<DirectChat>> observeAllDirectChats();