app/src/main/java/net/ktnx/mobileledger/ui/new_transaction/NewTransactionItemsAdapter.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.new_transaction;
  19
  20 import android.annotation.SuppressLint;
  21 import android.app.Activity;
  22 import android.database.Cursor;
  23 import android.text.TextUtils;
  24 import android.view.LayoutInflater;
  25 import android.view.ViewGroup;
  26
  27 import androidx.annotation.NonNull;
  28 import androidx.annotation.Nullable;
  29 import androidx.recyclerview.widget.ItemTouchHelper;
  30 import androidx.recyclerview.widget.RecyclerView;
  31
  32 import com.google.android.material.snackbar.Snackbar;
  33
  34 import net.ktnx.mobileledger.BuildConfig;
  35 import net.ktnx.mobileledger.R;
  36 import net.ktnx.mobileledger.async.DescriptionSelectedCallback;
  37 import net.ktnx.mobileledger.databinding.NewTransactionRowBinding;
  38 import net.ktnx.mobileledger.model.Currency;
  39 import net.ktnx.mobileledger.model.Data;
  40 import net.ktnx.mobileledger.model.LedgerTransaction;
  41 import net.ktnx.mobileledger.model.LedgerTransactionAccount;
  42 import net.ktnx.mobileledger.model.MobileLedgerProfile;
  43 import net.ktnx.mobileledger.utils.Logger;
  44 import net.ktnx.mobileledger.utils.MLDB;
  45 import net.ktnx.mobileledger.utils.Misc;
  46
  47 import java.util.ArrayList;
  48 import java.util.HashMap;
  49 import java.util.List;
  50 import java.util.Locale;
  51 import java.util.Set;
  52
  53 import static net.ktnx.mobileledger.utils.Logger.debug;
  54
  55 class NewTransactionItemsAdapter extends RecyclerView.Adapter<NewTransactionItemHolder>
  56         implements DescriptionSelectedCallback {
  57     private final NewTransactionModel model;
  58     private final ItemTouchHelper touchHelper;
  59     private MobileLedgerProfile mProfile;
  60     private RecyclerView recyclerView;
  61     private int checkHoldCounter = 0;
  62     NewTransactionItemsAdapter(NewTransactionModel viewModel, MobileLedgerProfile profile) {
  63         super();
  64         model = viewModel;
  65         mProfile = profile;
  66         int size = model.getAccountCount();
  67         while (size < 2) {
  68             Logger.debug("new-transaction",
  69                     String.format(Locale.US, "%d accounts is too little, Calling addRow()", size));
  70             size = addRow();
  71         }
  72
  73         NewTransactionItemsAdapter adapter = this;
  74
  75         touchHelper = new ItemTouchHelper(new ItemTouchHelper.Callback() {
  76             @Override
  77             public boolean isLongPressDragEnabled() {
  78                 return true;
  79             }
  80             @Override
  81             public boolean canDropOver(@NonNull RecyclerView recyclerView,
  82                                        @NonNull RecyclerView.ViewHolder current,
  83                                        @NonNull RecyclerView.ViewHolder target) {
  84                 final int adapterPosition = target.getAdapterPosition();
  85
  86                 // first and last items are immovable
  87                 if (adapterPosition == 0)
  88                     return false;
  89                 if (adapterPosition == adapter.getItemCount() - 1)
  90                     return false;
  91
  92                 return super.canDropOver(recyclerView, current, target);
  93             }
  94             @Override
  95             public int getMovementFlags(@NonNull RecyclerView recyclerView,
  96                                         @NonNull RecyclerView.ViewHolder viewHolder) {
  97                 int flags = makeFlag(ItemTouchHelper.ACTION_STATE_IDLE, ItemTouchHelper.END);
  98                 // the top (date and description) and the bottom (padding) items are always there
  99                 final int adapterPosition = viewHolder.getAdapterPosition();
 100                 if ((adapterPosition > 0) && (adapterPosition < adapter.getItemCount() - 1)) {
 101                     flags |= makeFlag(ItemTouchHelper.ACTION_STATE_DRAG,
 102                             ItemTouchHelper.UP | ItemTouchHelper.DOWN) |
 103                              makeFlag(ItemTouchHelper.ACTION_STATE_SWIPE,
 104                                      ItemTouchHelper.START | ItemTouchHelper.END);
 105                 }
 106
 107                 return flags;
 108             }
 109             @Override
 110             public boolean onMove(@NonNull RecyclerView recyclerView,
 111                                   @NonNull RecyclerView.ViewHolder viewHolder,
 112                                   @NonNull RecyclerView.ViewHolder target) {
 113
 114                 model.swapItems(viewHolder.getAdapterPosition(), target.getAdapterPosition());
 115                 notifyItemMoved(viewHolder.getAdapterPosition(), target.getAdapterPosition());
 116                 return true;
 117             }
 118             @Override
 119             public void onSwiped(@NonNull RecyclerView.ViewHolder viewHolder, int direction) {
 120                 int pos = viewHolder.getAdapterPosition();
 121                 viewModel.removeItem(pos - 1);
 122                 notifyItemRemoved(pos);
 123                 viewModel.sendCountNotifications(); // needed after items re-arrangement
 124                 checkTransactionSubmittable();
 125             }
 126         });
 127     }
 128     public void setProfile(MobileLedgerProfile profile) {
 129         mProfile = profile;
 130     }
 131     private int addRow() {
 132         return addRow(null);
 133     }
 134     private int addRow(String commodity) {
 135         final int newAccountCount = model.addAccount(new LedgerTransactionAccount("", commodity));
 136         Logger.debug("new-transaction",
 137                 String.format(Locale.US, "invoking notifyItemInserted(%d)", newAccountCount));
 138         // the header is at position 0
 139         notifyItemInserted(newAccountCount);
 140         model.sendCountNotifications(); // needed after holders' positions have changed
 141         return newAccountCount;
 142     }
 143     @NonNull
 144     @Override
 145     public NewTransactionItemHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
 146         NewTransactionRowBinding b =
 147                 NewTransactionRowBinding.inflate(LayoutInflater.from(parent.getContext()), parent,
 148                         false);
 149
 150         return new NewTransactionItemHolder(b, this);
 151     }
 152     @Override
 153     public void onBindViewHolder(@NonNull NewTransactionItemHolder holder, int position) {
 154         Logger.debug("bind", String.format(Locale.US, "Binding item at position %d", position));
 155         NewTransactionModel.Item item = model.getItem(position);
 156         holder.setData(item);
 157         Logger.debug("bind", String.format(Locale.US, "Bound %s item at position %d", item.getType()
 158                                                                                           .toString(),
 159                 position));
 160     }
 161     @Override
 162     public int getItemCount() {
 163         return model.getAccountCount() + 2;
 164     }
 165     private boolean accountListIsEmpty() {
 166         for (int i = 0; i < model.getAccountCount(); i++) {
 167             LedgerTransactionAccount acc = model.getAccount(i);
 168             if (!acc.getAccountName()
 169                     .isEmpty())
 170                 return false;
 171             if (acc.isAmountSet())
 172                 return false;
 173         }
 174
 175         return true;
 176     }
 177     @Override
 178     public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) {
 179         super.onAttachedToRecyclerView(recyclerView);
 180         this.recyclerView = recyclerView;
 181         touchHelper.attachToRecyclerView(recyclerView);
 182     }
 183     @Override
 184     public void onDetachedFromRecyclerView(@NonNull RecyclerView recyclerView) {
 185         touchHelper.attachToRecyclerView(null);
 186         super.onDetachedFromRecyclerView(recyclerView);
 187         this.recyclerView = null;
 188     }
 189     public void descriptionSelected(String description) {
 190         debug("description selected", description);
 191         if (!accountListIsEmpty())
 192             return;
 193
 194         String accFilter = mProfile.getPreferredAccountsFilter();
 195
 196         ArrayList<String> params = new ArrayList<>();
 197         StringBuilder sb = new StringBuilder("select t.profile, t.id from transactions t");
 198
 199         if (!TextUtils.isEmpty(accFilter)) {
 200             sb.append(" JOIN transaction_accounts ta")
 201               .append(" ON ta.profile = t.profile")
 202               .append(" AND ta.transaction_id = t.id");
 203         }
 204
 205         sb.append(" WHERE t.description=?");
 206         params.add(description);
 207
 208         if (!TextUtils.isEmpty(accFilter)) {
 209             sb.append(" AND ta.account_name LIKE '%'||?||'%'");
 210             params.add(accFilter);
 211         }
 212
 213         sb.append(" ORDER BY t.year desc, t.month desc, t.day desc LIMIT 1");
 214
 215         final String sql = sb.toString();
 216         debug("description", sql);
 217         debug("description", params.toString());
 218
 219         Activity activity = (Activity) recyclerView.getContext();
 220         // FIXME: handle exceptions?
 221         MLDB.queryInBackground(sql, params.toArray(new String[]{}), new MLDB.CallbackHelper() {
 222             @Override
 223             public void onStart() {
 224                 model.incrementBusyCounter();
 225             }
 226             @Override
 227             public void onDone() {
 228                 model.decrementBusyCounter();
 229             }
 230             @Override
 231             public boolean onRow(@NonNull Cursor cursor) {
 232                 final String profileUUID = cursor.getString(0);
 233                 final int transactionId = cursor.getInt(1);
 234                 activity.runOnUiThread(() -> loadTransactionIntoModel(profileUUID, transactionId));
 235                 return false; // limit 1, by the way
 236             }
 237             @Override
 238             public void onNoRows() {
 239                 if (TextUtils.isEmpty(accFilter))
 240                     return;
 241
 242                 debug("description", "Trying transaction search without preferred account filter");
 243
 244                 final String broaderSql =
 245                         "select t.profile, t.id from transactions t where t.description=?" +
 246                         " ORDER BY year desc, month desc, day desc LIMIT 1";
 247                 params.remove(1);
 248                 debug("description", broaderSql);
 249                 debug("description", description);
 250
 251                 activity.runOnUiThread(
 252                         () -> Snackbar.make(recyclerView, R.string.ignoring_preferred_account,
 253                                 Snackbar.LENGTH_INDEFINITE)
 254                                       .show());
 255
 256                 MLDB.queryInBackground(broaderSql, new String[]{description},
 257                         new MLDB.CallbackHelper() {
 258                             @Override
 259                             public void onStart() {
 260                                 model.incrementBusyCounter();
 261                             }
 262                             @Override
 263                             public boolean onRow(@NonNull Cursor cursor) {
 264                                 final String profileUUID = cursor.getString(0);
 265                                 final int transactionId = cursor.getInt(1);
 266                                 activity.runOnUiThread(
 267                                         () -> loadTransactionIntoModel(profileUUID, transactionId));
 268                                 return false;
 269                             }
 270                             @Override
 271                             public void onDone() {
 272                                 model.decrementBusyCounter();
 273                             }
 274                         });
 275             }
 276         });
 277     }
 278     private void loadTransactionIntoModel(String profileUUID, int transactionId) {
 279         LedgerTransaction tr;
 280         MobileLedgerProfile profile = Data.getProfile(profileUUID);
 281         if (profile == null)
 282             throw new RuntimeException(String.format(
 283                     "Unable to find profile %s, which is supposed to contain transaction %d",
 284                     profileUUID, transactionId));
 285
 286         tr = profile.loadTransaction(transactionId);
 287         List<LedgerTransactionAccount> accounts = tr.getAccounts();
 288         NewTransactionModel.Item firstNegative = null;
 289         NewTransactionModel.Item firstPositive = null;
 290         int singleNegativeIndex = -1;
 291         int singlePositiveIndex = -1;
 292         int negativeCount = 0;
 293         for (int i = 0; i < accounts.size(); i++) {
 294             LedgerTransactionAccount acc = accounts.get(i);
 295             NewTransactionModel.Item item;
 296             if (model.getAccountCount() < i + 1) {
 297                 model.addAccount(acc);
 298                 notifyItemInserted(i + 1);
 299             }
 300             item = model.getItem(i + 1);
 301
 302             item.getAccount()
 303                 .setAccountName(acc.getAccountName());
 304             item.setComment(acc.getComment());
 305             if (acc.isAmountSet()) {
 306                 item.getAccount()
 307                     .setAmount(acc.getAmount());
 308                 if (acc.getAmount() < 0) {
 309                     if (firstNegative == null) {
 310                         firstNegative = item;
 311                         singleNegativeIndex = i;
 312                     }
 313                     else
 314                         singleNegativeIndex = -1;
 315                 }
 316                 else {
 317                     if (firstPositive == null) {
 318                         firstPositive = item;
 319                         singlePositiveIndex = i;
 320                     }
 321                     else
 322                         singlePositiveIndex = -1;
 323                 }
 324             }
 325             else
 326                 item.getAccount()
 327                     .resetAmount();
 328             notifyItemChanged(i + 1);
 329         }
 330
 331         if (singleNegativeIndex != -1) {
 332             firstNegative.getAccount()
 333                          .resetAmount();
 334             model.moveItemLast(singleNegativeIndex);
 335         }
 336         else if (singlePositiveIndex != -1) {
 337             firstPositive.getAccount()
 338                          .resetAmount();
 339             model.moveItemLast(singlePositiveIndex);
 340         }
 341
 342         checkTransactionSubmittable();
 343         model.setFocusedItem(1);
 344     }
 345     public void toggleAllEditing(boolean editable) {
 346         // item 0 is the header
 347         for (int i = 0; i <= model.getAccountCount(); i++) {
 348             model.getItem(i)
 349                  .setEditable(editable);
 350             notifyItemChanged(i);
 351             // TODO perhaps do only one notification about the whole range (notifyDatasetChanged)?
 352         }
 353     }
 354     void reset() {
 355         int presentItemCount = model.getAccountCount();
 356         model.reset();
 357         notifyItemChanged(0);       // header changed
 358         notifyItemRangeChanged(1, 2);    // the two empty rows
 359         if (presentItemCount > 2)
 360             notifyItemRangeRemoved(3, presentItemCount - 2); // all the rest are gone
 361     }
 362     void updateFocusedItem(int position) {
 363         model.updateFocusedItem(position);
 364     }
 365     void noteFocusIsOnAccount(int position) {
 366         model.noteFocusChanged(position, NewTransactionModel.FocusedElement.Account);
 367     }
 368     void noteFocusIsOnAmount(int position) {
 369         model.noteFocusChanged(position, NewTransactionModel.FocusedElement.Amount);
 370     }
 371     void noteFocusIsOnComment(int position) {
 372         model.noteFocusChanged(position, NewTransactionModel.FocusedElement.Comment);
 373     }
 374     void noteFocusIsOnTransactionComment(int position) {
 375         model.noteFocusChanged(position, NewTransactionModel.FocusedElement.TransactionComment);
 376     }
 377     public void noteFocusIsOnDescription(int pos) {
 378         model.noteFocusChanged(pos, NewTransactionModel.FocusedElement.Description);
 379     }
 380     private void holdSubmittableChecks() {
 381         checkHoldCounter++;
 382     }
 383     private void releaseSubmittableChecks() {
 384         if (checkHoldCounter == 0)
 385             throw new RuntimeException("Asymmetrical call to releaseSubmittableChecks");
 386         checkHoldCounter--;
 387     }
 388     void setItemCurrency(NewTransactionModel.Item item, Currency newCurrency) {
 389         Currency oldCurrency = item.getCurrency();
 390         if (!Currency.equal(newCurrency, oldCurrency)) {
 391             holdSubmittableChecks();
 392             try {
 393                 item.setCurrency(newCurrency);
 394 //                for (Item i : items) {
 395 //                    if (Currency.equal(i.getCurrency(), oldCurrency))
 396 //                        i.setCurrency(newCurrency);
 397 //                }
 398             }
 399             finally {
 400                 releaseSubmittableChecks();
 401             }
 402
 403             checkTransactionSubmittable();
 404         }
 405     }
 406     /*
 407          A transaction is submittable if:
 408          0) has description
 409          1) has at least two account names
 410          2) each row with amount has account name
 411          3) for each commodity:
 412          3a) amounts must balance to 0, or
 413          3b) there must be exactly one empty amount (with account)
 414          4) empty accounts with empty amounts are ignored
 415          Side effects:
 416          5) a row with an empty account name or empty amount is guaranteed to exist for each
 417          commodity
 418          6) at least two rows need to be present in the ledger
 419
 420         */
 421     @SuppressLint("DefaultLocale")
 422     void checkTransactionSubmittable() {
 423         if (checkHoldCounter > 0)
 424             return;
 425
 426         int accounts = 0;
 427         final BalanceForCurrency balance = new BalanceForCurrency();
 428         final String descriptionText = model.getDescription();
 429         boolean submittable = true;
 430         final ItemsForCurrency itemsForCurrency = new ItemsForCurrency();
 431         final ItemsForCurrency itemsWithEmptyAmountForCurrency = new ItemsForCurrency();
 432         final ItemsForCurrency itemsWithAccountAndEmptyAmountForCurrency = new ItemsForCurrency();
 433         final ItemsForCurrency itemsWithEmptyAccountForCurrency = new ItemsForCurrency();
 434         final ItemsForCurrency itemsWithAmountForCurrency = new ItemsForCurrency();
 435         final ItemsForCurrency itemsWithAccountForCurrency = new ItemsForCurrency();
 436         final ItemsForCurrency emptyRowsForCurrency = new ItemsForCurrency();
 437         final List<NewTransactionModel.Item> emptyRows = new ArrayList<>();
 438
 439         try {
 440             if ((descriptionText == null) || descriptionText.trim()
 441                                                             .isEmpty())
 442             {
 443                 Logger.debug("submittable", "Transaction not submittable: missing description");
 444                 submittable = false;
 445             }
 446
 447             for (int i = 0; i < model.items.size(); i++) {
 448                 NewTransactionModel.Item item = model.items.get(i);
 449
 450                 LedgerTransactionAccount acc = item.getAccount();
 451                 String acc_name = acc.getAccountName()
 452                                      .trim();
 453                 String currName = acc.getCurrency();
 454
 455                 itemsForCurrency.add(currName, item);
 456
 457                 if (acc_name.isEmpty()) {
 458                     itemsWithEmptyAccountForCurrency.add(currName, item);
 459
 460                     if (acc.isAmountSet()) {
 461                         // 2) each amount has account name
 462                         Logger.debug("submittable", String.format(
 463                                 "Transaction not submittable: row %d has no account name, but" +
 464                                 " has" + " amount %1.2f", i + 1, acc.getAmount()));
 465                         submittable = false;
 466                     }
 467                     else {
 468                         emptyRowsForCurrency.add(currName, item);
 469                     }
 470                 }
 471                 else {
 472                     accounts++;
 473                     itemsWithAccountForCurrency.add(currName, item);
 474                 }
 475
 476                 if (!acc.isAmountValid()) {
 477                     Logger.debug("submittable",
 478                             String.format("Not submittable: row %d has an invalid amount", i + 1));
 479                     submittable = false;
 480                 }
 481                 else if (acc.isAmountSet()) {
 482                     itemsWithAmountForCurrency.add(currName, item);
 483                     balance.add(currName, acc.getAmount());
 484                 }
 485                 else {
 486                     itemsWithEmptyAmountForCurrency.add(currName, item);
 487
 488                     if (!acc_name.isEmpty())
 489                         itemsWithAccountAndEmptyAmountForCurrency.add(currName, item);
 490                 }
 491             }
 492
 493             // 1) has at least two account names
 494             if (accounts < 2) {
 495                 if (accounts == 0)
 496                     Logger.debug("submittable",
 497                             "Transaction not submittable: no account " + "names");
 498                 else if (accounts == 1)
 499                     Logger.debug("submittable",
 500                             "Transaction not submittable: only one account name");
 501                 else
 502                     Logger.debug("submittable",
 503                             String.format("Transaction not submittable: only %d account names",
 504                                     accounts));
 505                 submittable = false;
 506             }
 507
 508             // 3) for each commodity:
 509             // 3a) amount must balance to 0, or
 510             // 3b) there must be exactly one empty amount (with account)
 511             for (String balCurrency : itemsForCurrency.currencies()) {
 512                 float currencyBalance = balance.get(balCurrency);
 513                 if (Misc.isZero(currencyBalance)) {
 514                     // remove hints from all amount inputs in that currency
 515                     for (NewTransactionModel.Item item : model.items) {
 516                         if (Currency.equal(item.getCurrency(), balCurrency))
 517                             item.setAmountHint(null);
 518                     }
 519                 }
 520                 else {
 521                     List<NewTransactionModel.Item> list =
 522                             itemsWithAccountAndEmptyAmountForCurrency.getList(balCurrency);
 523                     int balanceReceiversCount = list.size();
 524                     if (balanceReceiversCount != 1) {
 525                         if (BuildConfig.DEBUG) {
 526                             if (balanceReceiversCount == 0)
 527                                 Logger.debug("submittable", String.format(
 528                                         "Transaction not submittable [%s]: non-zero balance " +
 529                                         "with no empty amounts with accounts", balCurrency));
 530                             else
 531                                 Logger.debug("submittable", String.format(
 532                                         "Transaction not submittable [%s]: non-zero balance " +
 533                                         "with multiple empty amounts with accounts", balCurrency));
 534                         }
 535                         submittable = false;
 536                     }
 537
 538                     List<NewTransactionModel.Item> emptyAmountList =
 539                             itemsWithEmptyAmountForCurrency.getList(balCurrency);
 540
 541                     // suggest off-balance amount to a row and remove hints on other rows
 542                     NewTransactionModel.Item receiver = null;
 543                     if (!list.isEmpty())
 544                         receiver = list.get(0);
 545                     else if (!emptyAmountList.isEmpty())
 546                         receiver = emptyAmountList.get(0);
 547
 548                     for (NewTransactionModel.Item item : model.items) {
 549                         if (!Currency.equal(item.getCurrency(), balCurrency))
 550                             continue;
 551
 552                         if (item.equals(receiver)) {
 553                             if (BuildConfig.DEBUG)
 554                                 Logger.debug("submittable",
 555                                         String.format("Setting amount hint to %1.2f [%s]",
 556                                                 -currencyBalance, balCurrency));
 557                             item.setAmountHint(String.format("%1.2f", -currencyBalance));
 558                         }
 559                         else {
 560                             if (BuildConfig.DEBUG)
 561                                 Logger.debug("submittable",
 562                                         String.format("Resetting hint of '%s' [%s]",
 563                                                 (item.getAccount() == null) ? "" : item.getAccount()
 564                                                                                        .getAccountName(),
 565                                                 balCurrency));
 566                             item.setAmountHint(null);
 567                         }
 568                     }
 569                 }
 570             }
 571
 572             // 5) a row with an empty account name or empty amount is guaranteed to exist for
 573             // each commodity
 574             for (String balCurrency : balance.currencies()) {
 575                 int currEmptyRows = itemsWithEmptyAccountForCurrency.size(balCurrency);
 576                 int currRows = itemsForCurrency.size(balCurrency);
 577                 int currAccounts = itemsWithAccountForCurrency.size(balCurrency);
 578                 int currAmounts = itemsWithAmountForCurrency.size(balCurrency);
 579                 if ((currEmptyRows == 0) &&
 580                     ((currRows == currAccounts) || (currRows == currAmounts)))
 581                 {
 582                     // perhaps there already is an unused empty row for another currency that
 583                     // is not used?
 584 //                        boolean foundIt = false;
 585 //                        for (Item item : emptyRows) {
 586 //                            Currency itemCurrency = item.getCurrency();
 587 //                            String itemCurrencyName =
 588 //                                    (itemCurrency == null) ? "" : itemCurrency.getName();
 589 //                            if (Misc.isZero(balance.get(itemCurrencyName))) {
 590 //                                item.setCurrency(Currency.loadByName(balCurrency));
 591 //                                item.setAmountHint(
 592 //                                        String.format("%1.2f", -balance.get(balCurrency)));
 593 //                                foundIt = true;
 594 //                                break;
 595 //                            }
 596 //                        }
 597 //
 598 //                        if (!foundIt)
 599                     addRow(balCurrency);
 600                 }
 601             }
 602
 603             // drop extra empty rows, not needed
 604             for (String currName : emptyRowsForCurrency.currencies()) {
 605                 List<NewTransactionModel.Item> emptyItems = emptyRowsForCurrency.getList(currName);
 606                 while ((model.items.size() > 2) && (emptyItems.size() > 1)) {
 607                     NewTransactionModel.Item item = emptyItems.get(1);
 608                     emptyItems.remove(1);
 609                     model.removeRow(item, this);
 610                 }
 611
 612                 // unused currency, remove last item (which is also an empty one)
 613                 if ((model.items.size() > 2) && (emptyItems.size() == 1)) {
 614                     List<NewTransactionModel.Item> currItems = itemsForCurrency.getList(currName);
 615
 616                     if (currItems.size() == 1) {
 617                         NewTransactionModel.Item item = emptyItems.get(0);
 618                         model.removeRow(item, this);
 619                     }
 620                 }
 621             }
 622
 623             // 6) at least two rows need to be present in the ledger
 624             while (model.items.size() < 2)
 625                 addRow();
 626
 627
 628             debug("submittable", submittable ? "YES" : "NO");
 629             model.isSubmittable.setValue(submittable);
 630
 631             if (BuildConfig.DEBUG) {
 632                 debug("submittable", "== Dump of all items");
 633                 for (int i = 0; i < model.items.size(); i++) {
 634                     NewTransactionModel.Item item = model.items.get(i);
 635                     LedgerTransactionAccount acc = item.getAccount();
 636                     debug("submittable", String.format("Item %2d: [%4.2f(%s) %s] %s ; %s", i,
 637                             acc.isAmountSet() ? acc.getAmount() : 0,
 638                             item.isAmountHintSet() ? item.getAmountHint() : "ø", acc.getCurrency(),
 639                             acc.getAccountName(), acc.getComment()));
 640                 }
 641             }
 642         }
 643         catch (NumberFormatException e) {
 644             debug("submittable", "NO (because of NumberFormatException)");
 645             model.isSubmittable.setValue(false);
 646         }
 647         catch (Exception e) {
 648             e.printStackTrace();
 649             debug("submittable", "NO (because of an Exception)");
 650             model.isSubmittable.setValue(false);
 651         }
 652     }
 653
 654     private static class BalanceForCurrency {
 655         private final HashMap<String, Float> hashMap = new HashMap<>();
 656         float get(String currencyName) {
 657             Float f = hashMap.get(currencyName);
 658             if (f == null) {
 659                 f = 0f;
 660                 hashMap.put(currencyName, f);
 661             }
 662             return f;
 663         }
 664         void add(String currencyName, float amount) {
 665             hashMap.put(currencyName, get(currencyName) + amount);
 666         }
 667         Set<String> currencies() {
 668             return hashMap.keySet();
 669         }
 670         boolean containsCurrency(String currencyName) {
 671             return hashMap.containsKey(currencyName);
 672         }
 673     }
 674
 675     private static class ItemsForCurrency {
 676         private final HashMap<String, List<NewTransactionModel.Item>> hashMap = new HashMap<>();
 677         @NonNull
 678         List<NewTransactionModel.Item> getList(@Nullable String currencyName) {
 679             List<NewTransactionModel.Item> list = hashMap.get(currencyName);
 680             if (list == null) {
 681                 list = new ArrayList<>();
 682                 hashMap.put(currencyName, list);
 683             }
 684             return list;
 685         }
 686         void add(@Nullable String currencyName, @NonNull NewTransactionModel.Item item) {
 687             getList(currencyName).add(item);
 688         }
 689         int size(@Nullable String currencyName) {
 690             return this.getList(currencyName)
 691                        .size();
 692         }
 693         Set<String> currencies() {
 694             return hashMap.keySet();
 695         }
 696     }
 697 }