]> git.ktnx.net Git - mobile-ledger.git/blob - app/src/main/java/net/ktnx/mobileledger/model/LedgerAccount.java
Room-based profile management
[mobile-ledger.git] / 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 }