import androidx.lifecycle.ViewModel;
import net.ktnx.mobileledger.BuildConfig;
+import net.ktnx.mobileledger.model.Currency;
import net.ktnx.mobileledger.model.LedgerTransactionAccount;
import net.ktnx.mobileledger.utils.Logger;
import net.ktnx.mobileledger.utils.Misc;
import java.util.ArrayList;
import java.util.Calendar;
+import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
+import java.util.HashMap;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
static final Pattern reYMD = Pattern.compile("^\\s*(\\d+)\\d*/\\s*(\\d+)\\s*/\\s*(\\d+)\\s*$");
static final Pattern reMD = Pattern.compile("^\\s*(\\d+)\\s*/\\s*(\\d+)\\s*$");
static final Pattern reD = Pattern.compile("\\s*(\\d+)\\s*$");
+ final MutableLiveData<Boolean> showCurrency = new MutableLiveData<>(false);
private final Item header = new Item(this, null, "");
private final Item trailer = new Item(this);
private final ArrayList<Item> items = new ArrayList<>();
private final MutableLiveData<Boolean> isSubmittable = new MutableLiveData<>(false);
private final MutableLiveData<Integer> focusedItem = new MutableLiveData<>(0);
private final MutableLiveData<Integer> accountCount = new MutableLiveData<>(0);
+ private final MutableLiveData<Boolean> simulateSave = new MutableLiveData<>(false);
+ public boolean getSimulateSave() {
+ return simulateSave.getValue();
+ }
+ public void setSimulateSave(boolean simulateSave) {
+ this.simulateSave.setValue(simulateSave);
+ }
+ public void toggleSimulateSave() {
+ simulateSave.setValue(!simulateSave.getValue());
+ }
+ public void observeSimulateSave(@NonNull @NotNull androidx.lifecycle.LifecycleOwner owner,
+ @NonNull
+ androidx.lifecycle.Observer<? super Boolean> observer) {
+ this.simulateSave.observe(owner, observer);
+ }
public int getAccountCount() {
return items.size();
}
A transaction is submittable if:
0) has description
1) has at least two account names
- 2) each amount has account name
- 3) amounts must balance to 0, or
- 3a) there must be exactly one empty amount (with account)
+ 2) each row with amount has account name
+ 3) for each commodity:
+ 3a) amounts must balance to 0, or
+ 3b) there must be exactly one empty amount (with account)
4) empty accounts with empty amounts are ignored
- 5) a row with an empty account name or empty amount is guaranteed to exist
+ 5) a row with an empty account name or empty amount is guaranteed to exist for each commodity
+ 6) at least two rows need to be present in the ledger
+
*/
@SuppressLint("DefaultLocale")
public void checkTransactionSubmittable(NewTransactionItemsAdapter adapter) {
int accounts = 0;
int amounts = 0;
int empty_rows = 0;
- float balance = 0f;
+ final Map<String, Float> balance = new HashMap<>();
final String descriptionText = getDescription();
boolean submittable = true;
- List<Item> itemsWithEmptyAmount = new ArrayList<>();
- List<Item> itemsWithAccountAndEmptyAmount = new ArrayList<>();
+ final Map<String, List<Item>> itemsWithEmptyAmountForCurrency = new HashMap<>();
+ final Map<String, List<Item>> itemsWithAccountAndEmptyAmountForCurrency = new HashMap<>();
try {
if ((descriptionText == null) || descriptionText.trim()
LedgerTransactionAccount acc = item.getAccount();
String acc_name = acc.getAccountName()
.trim();
+ String currName = acc.getCurrency();
+
if (acc_name.isEmpty()) {
empty_rows++;
if (acc.isAmountSet()) {
amounts++;
- balance += acc.getAmount();
+ Float bal = balance.get(currName);
+ if (bal == null)
+ bal = 0f;
+ bal += acc.getAmount();
+ balance.put(currName, bal);
}
else {
- itemsWithEmptyAmount.add(item);
+ {
+ List<Item> list = itemsWithEmptyAmountForCurrency.get(currName);
+ if (list == null)
+ list = new ArrayList<>();
+ itemsWithEmptyAmountForCurrency.put(currName, list);
+ list.add(item);
+ }
if (!acc_name.isEmpty()) {
- itemsWithAccountAndEmptyAmount.add(item);
+ List<Item> list =
+ itemsWithAccountAndEmptyAmountForCurrency.get(acc.getCurrency());
+ if (list == null) {
+ list = new ArrayList<>();
+ itemsWithAccountAndEmptyAmountForCurrency.put(acc.getCurrency(), list);
+ }
+ list.add(item);
}
}
}
// 1) has at least two account names
if (accounts < 2) {
- Logger.debug("submittable",
- String.format("Transaction not submittable: only %d account names",
- accounts));
+ if (accounts == 0)
+ Logger.debug("submittable", "Transaction not submittable: no account names");
+ else if (accounts == 1)
+ Logger.debug("submittable",
+ "Transaction not submittable: only one account name");
+ else
+ Logger.debug("submittable",
+ String.format("Transaction not submittable: only %d account names",
+ accounts));
submittable = false;
}
- // 3) amount must balance to 0, or
- // 3a) there must be exactly one empty amount (with account)
- if (Misc.isZero(balance)) {
- for (Item item : items) {
- item.setAmountHint(null);
- }
- }
- else {
- int balanceReceiversCount = itemsWithAccountAndEmptyAmount.size();
- if (balanceReceiversCount != 1) {
- Logger.debug("submittable", (balanceReceiversCount == 0) ?
- "Transaction not submittable: non-zero balance " +
- "with no empty amounts with accounts" :
- "Transaction not submittable: non-zero balance " +
- "with multiple empty amounts with accounts");
- submittable = false;
+ // 3) for each commodity:
+ // 3a) amount must balance to 0, or
+ // 3b) there must be exactly one empty amount (with account)
+ for (String balCurrency : balance.keySet()) {
+ Float bal = balance.get(balCurrency);
+ float currencyBalance = (bal == null) ? 0f : bal;
+ if (Misc.isZero(currencyBalance)) {
+ // remove hints from all amount inputs in that currency
+ for (Item item : items) {
+ final String itemCurrency = item.getCurrency()
+ .getName();
+ if (((balCurrency == null) && (null == itemCurrency)) ||
+ ((balCurrency != null) && balCurrency.equals(itemCurrency)))
+ item.setAmountHint(null);
+ }
}
+ else {
+ List<Item> list = itemsWithAccountAndEmptyAmountForCurrency.get(balCurrency);
+ int balanceReceiversCount = (list == null) ? 0 : list.size();
+ if (balanceReceiversCount != 1) {
+ Logger.debug("submittable", (balanceReceiversCount == 0) ? String.format(
+ "Transaction not submittable [%s]: non-zero balance " +
+ "with no empty amounts with accounts", balCurrency) : String.format(
+ "Transaction not submittable [%s]: non-zero balance " +
+ "with multiple empty amounts with accounts", balCurrency));
+ submittable = false;
+ }
- // suggest off-balance amount to a row and remove hints on other rows
- Item receiver = null;
- if (!itemsWithAccountAndEmptyAmount.isEmpty())
- receiver = itemsWithAccountAndEmptyAmount.get(0);
- else if (!itemsWithEmptyAmount.isEmpty())
- receiver = itemsWithEmptyAmount.get(0);
-
- for (Item item : items) {
- if (item.equals(receiver)) {
- Logger.debug("submittable",
- String.format("Setting amount hint to %1.2f", -balance));
- item.setAmountHint(String.format("%1.2f", -balance));
+ List<Item> emptyAmountList = itemsWithEmptyAmountForCurrency.get(balCurrency);
+
+ // suggest off-balance amount to a row and remove hints on other rows
+ Item receiver = null;
+ if ((list != null) && !list.isEmpty())
+ receiver = list.get(0);
+ else if ((emptyAmountList != null) && !emptyAmountList.isEmpty())
+ receiver = emptyAmountList.get(0);
+
+ for (Item item : items) {
+ if (item.equals(receiver)) {
+ Logger.debug("submittable",
+ String.format("Setting amount hint to %1.2f",
+ -currencyBalance));
+ item.setAmountHint(String.format("%1.2f", -currencyBalance));
+ }
+ else
+ item.setAmountHint(null);
}
- else
- item.setAmountHint(null);
}
}
- // 5) a row with an empty account name or empty amount is guaranteed to exist
- if ((empty_rows == 0) &&
- ((this.items.size() == accounts) || (this.items.size() == amounts)))
- {
- adapter.addRow();
+ // 5) a row with an empty account name or empty amount is guaranteed to exist for
+ // each commodity
+ for (String balCurrency : balance.keySet()) {
+ if ((empty_rows == 0) &&
+ ((this.items.size() == accounts) || (this.items.size() == amounts)))
+ {
+ adapter.addRow(balCurrency);
+ }
}
+ // 6) at least two rows need to be present in the ledger
+ while (this.items.size() < 2)
+ adapter.addRow();
+
debug("submittable", submittable ? "YES" : "NO");
isSubmittable.setValue(submittable);
for (int i = 0; i < items.size(); i++) {
Item item = items.get(i);
LedgerTransactionAccount acc = item.getAccount();
- debug("submittable", String.format("Item %2d: [%4.2f] %s", i,
- acc.isAmountSet() ? acc.getAmount() : 0, acc.getAccountName()));
+ debug("submittable", String.format("Item %2d: [%4.2f %s] %s // %s", i,
+ acc.isAmountSet() ? acc.getAmount() : 0, acc.getCurrency(),
+ acc.getAccountName(), acc.getComment()));
}
}
}
public void updateFocusedItem(int position) {
focusedItem.setValue(position);
}
- public void noteFocusIsOnAccount(int position) {
- getItem(position).setFocusIsOnAmount(false);
+ public void noteFocusChanged(int position, FocusedElement element) {
+ getItem(position).setFocusedElement(element);
}
- public void noteFocusIsOnAmount(int position) {
- getItem(position).setFocusIsOnAmount(true);
+ public void swapItems(int one, int two) {
+ Collections.swap(items, one - 1, two - 1);
+ }
+ public void toggleComment(int position) {
+ final MutableLiveData<Boolean> commentVisible = getItem(position).commentVisible;
+ commentVisible.postValue(!commentVisible.getValue());
+ }
+ public void moveItemLast(int index) {
+ /* 0
+ 1 <-- index
+ 2
+ 3 <-- desired position
+ */
+ int itemCount = items.size();
+
+ if (index < itemCount - 1) {
+ Item acc = items.remove(index);
+ items.add(itemCount - 1, acc);
+ }
+ }
+ public void toggleCurrencyVisible() {
+ showCurrency.setValue(!showCurrency.getValue());
}
enum ItemType {generalData, transactionRow, bottomFiller}
//==========================================================================================
- class Item extends Object {
+ enum FocusedElement {Account, Comment, Amount}
+
+ class Item {
private ItemType type;
private MutableLiveData<Date> date = new MutableLiveData<>();
private MutableLiveData<String> description = new MutableLiveData<>();
private MutableLiveData<String> amountHint = new MutableLiveData<>(null);
private NewTransactionModel model;
private MutableLiveData<Boolean> editable = new MutableLiveData<>(true);
- private boolean focusIsOnAmount = false;
+ private FocusedElement focusedElement = FocusedElement.Account;
+ private MutableLiveData<String> comment = new MutableLiveData<>(null);
+ private MutableLiveData<Boolean> commentVisible = new MutableLiveData<>(false);
+ private MutableLiveData<Currency> currency = new MutableLiveData<>(null);
public Item(NewTransactionModel model) {
this.model = model;
type = ItemType.bottomFiller;
this.account = account;
this.editable.setValue(true);
}
- public boolean focusIsOnAmount() {
- return focusIsOnAmount;
+ public FocusedElement getFocusedElement() {
+ return focusedElement;
+ }
+ public void setFocusedElement(FocusedElement focusedElement) {
+ this.focusedElement = focusedElement;
}
public NewTransactionModel getModel() {
return model;
this.date.setValue(date);
}
public void setDate(String text) {
+ if ((text == null) || text.trim()
+ .isEmpty())
+ {
+ setDate((Date) null);
+ return;
+ }
+
int year, month, day;
final Calendar c = GregorianCalendar.getInstance();
Matcher m = reYMD.matcher(text);
public void stopObservingEditableFlag(Observer<Boolean> observer) {
editable.removeObserver(observer);
}
- public void setFocusIsOnAmount(boolean flag) {
- focusIsOnAmount = flag;
+ public void observeCommentVisible(NewTransactionActivity activity,
+ Observer<Boolean> observer) {
+ commentVisible.observe(activity, observer);
+ }
+ public void stopObservingCommentVisible(Observer<Boolean> observer) {
+ commentVisible.removeObserver(observer);
+ }
+ public void observeComment(NewTransactionActivity activity, Observer<String> observer) {
+ comment.observe(activity, observer);
+ }
+ public void stopObservingComment(Observer<String> observer) {
+ comment.removeObserver(observer);
+ }
+ public void setComment(String comment) {
+ getAccount().setComment(comment);
+ this.comment.postValue(comment);
+ }
+ public Currency getCurrency() {
+ return this.currency.getValue();
+ }
+ public void setCurrency(Currency currency) {
+ getAccount().setCurrency((currency != null && !currency.getName()
+ .isEmpty()) ? currency.getName()
+ : null);
+ this.currency.setValue(currency);
+ }
+ public void observeCurrency(NewTransactionActivity activity, Observer<Currency> observer) {
+ currency.observe(activity, observer);
+ }
+ public void stopObservingCurrency(Observer<Currency> observer) {
+ currency.removeObserver(observer);
}
}
}