app/src/main/java/net/ktnx/mobileledger/model/LedgerAccount.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.model;
  19
  20 import androidx.annotation.NonNull;
  21 import androidx.annotation.Nullable;
  22
  23 import net.ktnx.mobileledger.db.Account;
  24 import net.ktnx.mobileledger.db.AccountValue;
  25 import net.ktnx.mobileledger.db.AccountWithAmounts;
  26
  27 import java.util.ArrayList;
  28 import java.util.List;
  29 import java.util.regex.Pattern;
  30
  31 public class LedgerAccount {
  32     static Pattern reHigherAccount = Pattern.compile("^[^:]+:");
  33     private final LedgerAccount parent;
  34     private long dbId;
  35     private long profileId;
  36     private String name;
  37     private String shortName;
  38     private int level;
  39     private boolean expanded;
  40     private List<LedgerAmount> amounts;
  41     private boolean hasSubAccounts;
  42     private boolean amountsExpanded;
  43
  44     public LedgerAccount(String name, @Nullable LedgerAccount parent) {
  45         this.parent = parent;
  46         if (parent != null && !name.startsWith(parent.getName() + ":"))
  47             throw new IllegalStateException(
  48                     String.format("Account name '%s' doesn't match parent account '%s'", name,
  49                             parent.getName()));
  50         this.setName(name);
  51     }
  52     @Nullable
  53     public static String extractParentName(@NonNull String accName) {
  54         int colonPos = accName.lastIndexOf(':');
  55         if (colonPos < 0)
  56             return null;    // no parent account -- this is a top-level account
  57         else
  58             return accName.substring(0, colonPos);
  59     }
  60     @NonNull
  61     static public LedgerAccount fromDBO(AccountWithAmounts in, LedgerAccount parent) {
  62         LedgerAccount res = new LedgerAccount(in.account.getName(), parent);
  63         res.dbId = in.account.getId();
  64         res.profileId = in.account.getProfileId();
  65         res.setName(in.account.getName());
  66         res.setExpanded(in.account.isExpanded());
  67         res.setAmountsExpanded(in.account.isAmountsExpanded());
  68
  69         res.amounts = new ArrayList<>();
  70         for (AccountValue val : in.amounts) {
  71             res.amounts.add(new LedgerAmount(val.getValue(), val.getCurrency()));
  72         }
  73
  74         return res;
  75     }
  76     @Override
  77     public int hashCode() {
  78         return name.hashCode();
  79     }
  80     @Override
  81     public boolean equals(@Nullable Object obj) {
  82         if (obj == null)
  83             return false;
  84
  85         if (!(obj instanceof LedgerAccount))
  86             return false;
  87
  88         LedgerAccount acc = (LedgerAccount) obj;
  89         if (!name.equals(acc.name))
  90             return false;
  91
  92         if (!getAmountsString().equals(acc.getAmountsString()))
  93             return false;
  94
  95         return expanded == acc.expanded && amountsExpanded == acc.amountsExpanded;
  96     }
  97     // an account is visible if:
  98     //  - it has an expanded visible parent or is a top account
  99     public boolean isVisible() {
 100         if (parent == null)
 101             return true;
 102
 103         return (parent.isExpanded() && parent.isVisible());
 104     }
 105     public boolean isParentOf(LedgerAccount potentialChild) {
 106         return potentialChild.getName()
 107                              .startsWith(name + ":");
 108     }
 109     private void stripName() {
 110         String[] split = name.split(":");
 111         shortName = split[split.length - 1];
 112         level = split.length - 1;
 113     }
 114     public String getName() {
 115         return name;
 116     }
 117     public void setName(String name) {
 118         this.name = name;
 119         stripName();
 120     }
 121     public void addAmount(float amount, @NonNull String currency) {
 122         if (amounts == null)
 123             amounts = new ArrayList<>();
 124         amounts.add(new LedgerAmount(amount, currency));
 125     }
 126     public void addAmount(float amount) {
 127         this.addAmount(amount, "");
 128     }
 129     public int getAmountCount() { return (amounts != null) ? amounts.size() : 0; }
 130     public String getAmountsString() {
 131         if ((amounts == null) || amounts.isEmpty())
 132             return "";
 133
 134         StringBuilder builder = new StringBuilder();
 135         for (LedgerAmount amount : amounts) {
 136             String amt = amount.toString();
 137             if (builder.length() > 0)
 138                 builder.append('\n');
 139             builder.append(amt);
 140         }
 141
 142         return builder.toString();
 143     }
 144     public String getAmountsString(int limit) {
 145         if ((amounts == null) || amounts.isEmpty())
 146             return "";
 147
 148         int included = 0;
 149         StringBuilder builder = new StringBuilder();
 150         for (LedgerAmount amount : amounts) {
 151             String amt = amount.toString();
 152             if (builder.length() > 0)
 153                 builder.append('\n');
 154             builder.append(amt);
 155             included++;
 156             if (included == limit)
 157                 break;
 158         }
 159
 160         return builder.toString();
 161     }
 162     public int getLevel() {
 163         return level;
 164     }
 165     @NonNull
 166     public String getShortName() {
 167         return shortName;
 168     }
 169     public String getParentName() {
 170         return (parent == null) ? null : parent.getName();
 171     }
 172     public boolean hasSubAccounts() {
 173         return hasSubAccounts;
 174     }
 175     public void setHasSubAccounts(boolean hasSubAccounts) {
 176         this.hasSubAccounts = hasSubAccounts;
 177     }
 178     public boolean isExpanded() {
 179         return expanded;
 180     }
 181     public void setExpanded(boolean expanded) {
 182         this.expanded = expanded;
 183     }
 184     public void toggleExpanded() {
 185         expanded = !expanded;
 186     }
 187     public void removeAmounts() {
 188         if (amounts != null)
 189             amounts.clear();
 190     }
 191     public boolean amountsExpanded() { return amountsExpanded; }
 192     public void setAmountsExpanded(boolean flag) { amountsExpanded = flag; }
 193     public void toggleAmountsExpanded() { amountsExpanded = !amountsExpanded; }
 194     public void propagateAmountsTo(LedgerAccount acc) {
 195         for (LedgerAmount a : amounts)
 196             a.propagateToAccount(acc);
 197     }
 198     public List<LedgerAmount> getAmounts() {
 199         return amounts;
 200     }
 201     @NonNull
 202     public Account toDBO() {
 203         Account dbo = new Account();
 204         dbo.setName(name);
 205         dbo.setNameUpper(name.toUpperCase());
 206         dbo.setParentName(extractParentName(name));
 207         dbo.setLevel(level);
 208         dbo.setId(dbId);
 209         dbo.setProfileId(profileId);
 210         dbo.setExpanded(expanded);
 211         dbo.setAmountsExpanded(amountsExpanded);
 212
 213         return dbo;
 214     }
 215     @NonNull
 216     public AccountWithAmounts toDBOWithAmounts() {
 217         AccountWithAmounts dbo = new AccountWithAmounts();
 218         dbo.account = toDBO();
 219
 220         dbo.amounts = new ArrayList<>();
 221         for (LedgerAmount amt : getAmounts()) {
 222             AccountValue val = new AccountValue();
 223             val.setCurrency(amt.getCurrency());
 224             val.setValue(amt.getAmount());
 225             dbo.amounts.add(val);
 226         }
 227
 228         return dbo;
 229     }
 230     public long getId() {
 231         return dbId;
 232     }
 233 }