app/src/main/java/net/ktnx/mobileledger/ui/patterns/PatternDetailsViewModel.java

   1 /*
   2  * Copyright © 2021 Damyan Ivanov.
   3  * This file is part of MoLe.
   4  * MoLe is free software: you can distribute it and/or modify it
   5  * under the term of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your opinion), any later version.
   8  *
   9  * MoLe is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License terms for details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with MoLe. If not, see <https://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.ktnx.mobileledger.ui.patterns;
  19
  20 import android.os.AsyncTask;
  21
  22 import androidx.lifecycle.LiveData;
  23 import androidx.lifecycle.MutableLiveData;
  24 import androidx.lifecycle.Observer;
  25 import androidx.lifecycle.ViewModel;
  26
  27 import net.ktnx.mobileledger.dao.PatternAccountDAO;
  28 import net.ktnx.mobileledger.dao.PatternHeaderDAO;
  29 import net.ktnx.mobileledger.db.DB;
  30 import net.ktnx.mobileledger.db.PatternAccount;
  31 import net.ktnx.mobileledger.db.PatternHeader;
  32 import net.ktnx.mobileledger.db.PatternWithAccounts;
  33 import net.ktnx.mobileledger.model.PatternDetailsItem;
  34 import net.ktnx.mobileledger.utils.Logger;
  35
  36 import java.util.ArrayList;
  37 import java.util.Collections;
  38 import java.util.List;
  39 import java.util.Locale;
  40 import java.util.Objects;
  41
  42 public class PatternDetailsViewModel extends ViewModel {
  43     private final MutableLiveData<List<PatternDetailsItem>> items =
  44             new MutableLiveData<>(Collections.emptyList());
  45     private Long mPatternId;
  46     private String mDefaultPatternName;
  47     public String getDefaultPatternName() {
  48         return mDefaultPatternName;
  49     }
  50     public void setDefaultPatternName(String name) {
  51         mDefaultPatternName = name;
  52     }
  53
  54     public void resetItems() {
  55         ArrayList<PatternDetailsItem> newList = new ArrayList<>();
  56         final PatternDetailsItem.Header header = PatternDetailsItem.createHeader();
  57         header.setName(mDefaultPatternName);
  58         header.setId(0);
  59         newList.add(header);
  60
  61         while (newList.size() < 3) {
  62             final PatternDetailsItem.AccountRow aRow = PatternDetailsItem.createAccountRow();
  63             aRow.setId(newList.size() + 1);
  64             newList.add(aRow);
  65         }
  66
  67         items.setValue(newList);
  68     }
  69     private void checkItemConsistency() {
  70         ArrayList<PatternDetailsItem> newList = new ArrayList<>(items.getValue());
  71         boolean changes = false;
  72         if (newList.size() < 1) {
  73             final PatternDetailsItem.Header header = PatternDetailsItem.createHeader();
  74             header.setName(mDefaultPatternName);
  75             newList.add(header);
  76             changes = true;
  77         }
  78
  79         while (newList.size() < 3) {
  80             newList.add(PatternDetailsItem.createAccountRow());
  81             changes = true;
  82         }
  83
  84         if (changes)
  85             items.setValue(newList);
  86     }
  87     public LiveData<List<PatternDetailsItem>> getItems(Long patternId) {
  88         if (patternId != null && patternId <= 0)
  89             throw new IllegalArgumentException("Pattern ID " + patternId + " is invalid");
  90
  91         mPatternId = patternId;
  92
  93         if (mPatternId == null) {
  94             resetItems();
  95             return items;
  96         }
  97
  98         DB db = DB.get();
  99         LiveData<PatternWithAccounts> dbList = db.getPatternDAO()
 100                                                  .getPatternWithAccounts(mPatternId);
 101         Observer<PatternWithAccounts> observer = new Observer<PatternWithAccounts>() {
 102             @Override
 103             public void onChanged(PatternWithAccounts src) {
 104                 ArrayList<PatternDetailsItem> l = new ArrayList<>();
 105
 106                 PatternDetailsItem header = PatternDetailsItem.fromRoomObject(src.header);
 107                 l.add(header);
 108                 for (PatternAccount acc : src.accounts) {
 109                     l.add(PatternDetailsItem.fromRoomObject(acc));
 110                 }
 111
 112                 for (PatternDetailsItem i : l) {
 113                     Logger.debug("patterns-db", "Loaded pattern item " + i);
 114                 }
 115                 items.postValue(l);
 116
 117                 dbList.removeObserver(this);
 118             }
 119         };
 120         dbList.observeForever(observer);
 121
 122         return items;
 123     }
 124     public void setTestText(String text) {
 125         List<PatternDetailsItem> list = new ArrayList<>(items.getValue());
 126         PatternDetailsItem.Header header = new PatternDetailsItem.Header(list.get(0)
 127                                                                              .asHeaderItem());
 128         header.setTestText(text);
 129         list.set(0, header);
 130
 131         items.setValue(list);
 132     }
 133     public void onSavePattern() {
 134         Logger.debug("flow", "PatternDetailsViewModel.onSavePattern(); model=" + this);
 135         final List<PatternDetailsItem> list = Objects.requireNonNull(items.getValue());
 136
 137         AsyncTask.execute(() -> {
 138             boolean newPattern = mPatternId == null || mPatternId <= 0;
 139
 140             PatternDetailsItem.Header modelHeader = list.get(0)
 141                                                         .asHeaderItem();
 142             PatternHeaderDAO headerDAO = DB.get()
 143                                            .getPatternDAO();
 144             PatternHeader dbHeader = modelHeader.toDBO();
 145             if (newPattern) {
 146                 dbHeader.setId(null);
 147                 dbHeader.setId(mPatternId = headerDAO.insert(dbHeader));
 148             }
 149             else
 150                 headerDAO.update(dbHeader);
 151
 152             Logger.debug("pattern-db",
 153                     String.format(Locale.US, "Stored pattern header %d, item=%s", dbHeader.getId(),
 154                             modelHeader));
 155
 156
 157             PatternAccountDAO paDAO = DB.get()
 158                                         .getPatternAccountDAO();
 159             for (int i = 1; i < list.size(); i++) {
 160                 final PatternDetailsItem.AccountRow accRowItem = list.get(i)
 161                                                                      .asAccountRowItem();
 162                 PatternAccount dbAccount = accRowItem.toDBO(dbHeader.getId());
 163                 dbAccount.setPatternId(mPatternId);
 164                 dbAccount.setPosition(i);
 165                 if (newPattern) {
 166                     dbAccount.setId(null);
 167                     dbAccount.setId(paDAO.insert(dbAccount));
 168                 }
 169                 else
 170                     paDAO.update(dbAccount);
 171
 172                 Logger.debug("pattern-db", String.format(Locale.US,
 173                         "Stored pattern account %d, account=%s, comment=%s, item=%s",
 174                         dbAccount.getId(), dbAccount.getAccountName(),
 175                         dbAccount.getAccountComment(), accRowItem));
 176             }
 177         });
 178     }
 179 }