app/src/main/java/net/ktnx/mobileledger/ui/templates/TemplateDetailsViewModel.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.templates;
  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.TemplateAccountDAO;
  28 import net.ktnx.mobileledger.dao.TemplateHeaderDAO;
  29 import net.ktnx.mobileledger.db.DB;
  30 import net.ktnx.mobileledger.db.TemplateAccount;
  31 import net.ktnx.mobileledger.db.TemplateHeader;
  32 import net.ktnx.mobileledger.db.TemplateWithAccounts;
  33 import net.ktnx.mobileledger.model.TemplateDetailsItem;
  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 TemplateDetailsViewModel extends ViewModel {
  43     private final MutableLiveData<List<TemplateDetailsItem>> items =
  44             new MutableLiveData<>(Collections.emptyList());
  45     private Long mPatternId;
  46     private String mDefaultPatternName;
  47
  48     public String getDefaultPatternName() {
  49         return mDefaultPatternName;
  50     }
  51     public void setDefaultPatternName(String name) {
  52         mDefaultPatternName = name;
  53     }
  54
  55     public void resetItems() {
  56         ArrayList<TemplateDetailsItem> newList = new ArrayList<>();
  57         final TemplateDetailsItem.Header header = TemplateDetailsItem.createHeader();
  58         header.setName(mDefaultPatternName);
  59         header.setId(0);
  60         newList.add(header);
  61
  62         while (newList.size() < 3) {
  63             final TemplateDetailsItem.AccountRow aRow = TemplateDetailsItem.createAccountRow();
  64             aRow.setId(newList.size() + 1);
  65             newList.add(aRow);
  66         }
  67
  68         items.setValue(newList);
  69     }
  70     private void checkItemConsistency() {
  71         ArrayList<TemplateDetailsItem> newList = new ArrayList<>(items.getValue());
  72         boolean changes = false;
  73         if (newList.size() < 1) {
  74             final TemplateDetailsItem.Header header = TemplateDetailsItem.createHeader();
  75             header.setName(mDefaultPatternName);
  76             newList.add(header);
  77             changes = true;
  78         }
  79
  80         while (newList.size() < 3) {
  81             newList.add(TemplateDetailsItem.createAccountRow());
  82             changes = true;
  83         }
  84
  85         if (changes)
  86             items.setValue(newList);
  87     }
  88     public LiveData<List<TemplateDetailsItem>> getItems(Long patternId) {
  89         if (patternId != null && patternId <= 0)
  90             throw new IllegalArgumentException("Pattern ID " + patternId + " is invalid");
  91
  92         mPatternId = patternId;
  93
  94         if (mPatternId == null) {
  95             resetItems();
  96             return items;
  97         }
  98
  99         DB db = DB.get();
 100         LiveData<TemplateWithAccounts> dbList = db.getTemplateDAO()
 101                                                   .getTemplateWithAccounts(mPatternId);
 102         Observer<TemplateWithAccounts> observer = new Observer<TemplateWithAccounts>() {
 103             @Override
 104             public void onChanged(TemplateWithAccounts src) {
 105                 ArrayList<TemplateDetailsItem> l = new ArrayList<>();
 106
 107                 TemplateDetailsItem header = TemplateDetailsItem.fromRoomObject(src.header);
 108                 l.add(header);
 109                 for (TemplateAccount acc : src.accounts) {
 110                     l.add(TemplateDetailsItem.fromRoomObject(acc));
 111                 }
 112
 113                 for (TemplateDetailsItem i : l) {
 114                     Logger.debug("patterns-db", "Loaded pattern item " + i);
 115                 }
 116                 items.postValue(l);
 117
 118                 dbList.removeObserver(this);
 119             }
 120         };
 121         dbList.observeForever(observer);
 122
 123         return items;
 124     }
 125     public void setTestText(String text) {
 126         List<TemplateDetailsItem> list = new ArrayList<>(items.getValue());
 127         TemplateDetailsItem.Header header = new TemplateDetailsItem.Header(list.get(0)
 128                                                                                .asHeaderItem());
 129         header.setTestText(text);
 130         list.set(0, header);
 131
 132         items.setValue(list);
 133     }
 134     public void onSaveTemplate() {
 135         Logger.debug("flow", "PatternDetailsViewModel.onSavePattern(); model=" + this);
 136         final List<TemplateDetailsItem> list = Objects.requireNonNull(items.getValue());
 137
 138         AsyncTask.execute(() -> {
 139             boolean newPattern = mPatternId == null || mPatternId <= 0;
 140
 141             TemplateDetailsItem.Header modelHeader = list.get(0)
 142                                                          .asHeaderItem();
 143             TemplateHeaderDAO headerDAO = DB.get()
 144                                             .getTemplateDAO();
 145             TemplateHeader dbHeader = modelHeader.toDBO();
 146             if (newPattern) {
 147                 dbHeader.setId(null);
 148                 dbHeader.setId(mPatternId = headerDAO.insertSync(dbHeader));
 149             }
 150             else
 151                 headerDAO.updateSync(dbHeader);
 152
 153             Logger.debug("pattern-db",
 154                     String.format(Locale.US, "Stored pattern header %d, item=%s", dbHeader.getId(),
 155                             modelHeader));
 156
 157
 158             TemplateAccountDAO taDAO = DB.get()
 159                                          .getTemplateAccountDAO();
 160             for (int i = 1; i < list.size(); i++) {
 161                 final TemplateDetailsItem.AccountRow accRowItem = list.get(i)
 162                                                                       .asAccountRowItem();
 163                 TemplateAccount dbAccount = accRowItem.toDBO(dbHeader.getId());
 164                 dbAccount.setTemplateId(mPatternId);
 165                 dbAccount.setPosition(i);
 166                 if (newPattern) {
 167                     dbAccount.setId(null);
 168                     dbAccount.setId(taDAO.insertSync(dbAccount));
 169                 }
 170                 else
 171                     taDAO.updateSync(dbAccount);
 172
 173                 Logger.debug("pattern-db", String.format(Locale.US,
 174                         "Stored pattern account %d, account=%s, comment=%s, neg=%s, item=%s",
 175                         dbAccount.getId(), dbAccount.getAccountName(),
 176                         dbAccount.getAccountComment(), dbAccount.getNegateAmount(), accRowItem));
 177             }
 178         });
 179     }
 180 }