app/src/main/java/net/ktnx/mobileledger/ui/new_transaction/NewTransactionFragment.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.content.Context;
  21 import android.content.Intent;
  22 import android.content.res.Resources;
  23 import android.database.AbstractCursor;
  24 import android.os.Bundle;
  25 import android.os.ParcelFormatException;
  26 import android.renderscript.RSInvalidStateException;
  27 import android.view.LayoutInflater;
  28 import android.view.Menu;
  29 import android.view.MenuInflater;
  30 import android.view.MenuItem;
  31 import android.view.View;
  32 import android.view.ViewGroup;
  33 import android.widget.ProgressBar;
  34
  35 import androidx.annotation.NonNull;
  36 import androidx.annotation.Nullable;
  37 import androidx.appcompat.app.AlertDialog;
  38 import androidx.fragment.app.Fragment;
  39 import androidx.fragment.app.FragmentActivity;
  40 import androidx.lifecycle.LiveData;
  41 import androidx.lifecycle.ViewModelProvider;
  42 import androidx.recyclerview.widget.LinearLayoutManager;
  43 import androidx.recyclerview.widget.RecyclerView;
  44
  45 import com.google.android.material.dialog.MaterialAlertDialogBuilder;
  46 import com.google.android.material.floatingactionbutton.FloatingActionButton;
  47 import com.google.android.material.snackbar.BaseTransientBottomBar;
  48 import com.google.android.material.snackbar.Snackbar;
  49
  50 import net.ktnx.mobileledger.R;
  51 import net.ktnx.mobileledger.db.DB;
  52 import net.ktnx.mobileledger.db.PatternAccount;
  53 import net.ktnx.mobileledger.db.PatternHeader;
  54 import net.ktnx.mobileledger.json.API;
  55 import net.ktnx.mobileledger.model.Data;
  56 import net.ktnx.mobileledger.model.LedgerTransaction;
  57 import net.ktnx.mobileledger.model.LedgerTransactionAccount;
  58 import net.ktnx.mobileledger.model.MobileLedgerProfile;
  59 import net.ktnx.mobileledger.ui.QRScanCapableFragment;
  60 import net.ktnx.mobileledger.ui.patterns.PatternsActivity;
  61 import net.ktnx.mobileledger.utils.Logger;
  62 import net.ktnx.mobileledger.utils.Misc;
  63 import net.ktnx.mobileledger.utils.SimpleDate;
  64
  65 import org.jetbrains.annotations.NotNull;
  66
  67 import java.util.ArrayList;
  68 import java.util.List;
  69 import java.util.Locale;
  70 import java.util.regex.Matcher;
  71 import java.util.regex.Pattern;
  72
  73 /**
  74  * A simple {@link Fragment} subclass.
  75  * Activities that contain this fragment must implement the
  76  * {@link OnNewTransactionFragmentInteractionListener} interface
  77  * to handle interaction events.
  78  */
  79
  80 // TODO: offer to undo account remove-on-swipe
  81
  82 public class NewTransactionFragment extends QRScanCapableFragment {
  83     private NewTransactionItemsAdapter listAdapter;
  84     private NewTransactionModel viewModel;
  85     private FloatingActionButton fab;
  86     private OnNewTransactionFragmentInteractionListener mListener;
  87     private MobileLedgerProfile mProfile;
  88     public NewTransactionFragment() {
  89         // Required empty public constructor
  90         setHasOptionsMenu(true);
  91     }
  92     private void startNewPatternActivity(String scanned) {
  93         Intent intent = new Intent(requireContext(), PatternsActivity.class);
  94         Bundle args = new Bundle();
  95         args.putString(PatternsActivity.ARG_ADD_PATTERN, scanned);
  96         requireContext().startActivity(intent, args);
  97     }
  98     private void alertNoPatternMatch(String scanned) {
  99         MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(requireContext());
 100         builder.setCancelable(true)
 101                .setMessage(R.string.no_pattern_matches)
 102                .setPositiveButton(R.string.add_button,
 103                        (dialog, which) -> startNewPatternActivity(scanned))
 104                .create()
 105                .show();
 106     }
 107     protected void onQrScanned(String text) {
 108         Logger.debug("qr", String.format("Got QR scan result [%s]", text));
 109
 110         if (Misc.emptyIsNull(text) == null)
 111             return;
 112
 113         LiveData<List<PatternHeader>> allPatterns = DB.get()
 114                                                       .getPatternDAO()
 115                                                       .getPatterns();
 116         allPatterns.observe(getViewLifecycleOwner(), patternHeaders -> {
 117             ArrayList<PatternHeader> matchingPatterns = new ArrayList<>();
 118
 119             for (PatternHeader ph : patternHeaders) {
 120                 String patternSource = ph.getRegularExpression();
 121                 if (Misc.emptyIsNull(patternSource) == null)
 122                     continue;
 123                 try {
 124                     Pattern pattern = Pattern.compile(patternSource);
 125                     Matcher matcher = pattern.matcher(text);
 126                     if (!matcher.matches())
 127                         continue;
 128
 129                     Logger.debug("pattern",
 130                             String.format("Pattern '%s' [%s] matches '%s'", ph.getName(),
 131                                     patternSource, text));
 132                     matchingPatterns.add(ph);
 133                 }
 134                 catch (ParcelFormatException e) {
 135                     // ignored
 136                     Logger.debug("pattern",
 137                             String.format("Error compiling regular expression '%s'", patternSource),
 138                             e);
 139                 }
 140             }
 141
 142             if (matchingPatterns.isEmpty())
 143                 alertNoPatternMatch(text);
 144             else if (matchingPatterns.size() == 1)
 145                 applyPattern(matchingPatterns.get(0), text);
 146             else
 147                 choosePattern(matchingPatterns, text);
 148         });
 149     }
 150     private void choosePattern(ArrayList<PatternHeader> matchingPatterns, String matchedText) {
 151         final String patternNameColumn = getString(R.string.pattern_name);
 152         AbstractCursor cursor = new AbstractCursor() {
 153             @Override
 154             public int getCount() {
 155                 return matchingPatterns.size();
 156             }
 157             @Override
 158             public String[] getColumnNames() {
 159                 return new String[]{patternNameColumn};
 160             }
 161             @Override
 162             public String getString(int column) {
 163                 return matchingPatterns.get(getPosition())
 164                                        .getName();
 165             }
 166             @Override
 167             public short getShort(int column) {
 168                 return -1;
 169             }
 170             @Override
 171             public int getInt(int column) {
 172                 return -1;
 173             }
 174             @Override
 175             public long getLong(int column) {
 176                 return -1;
 177             }
 178             @Override
 179             public float getFloat(int column) {
 180                 return -1;
 181             }
 182             @Override
 183             public double getDouble(int column) {
 184                 return -1;
 185             }
 186             @Override
 187             public boolean isNull(int column) {
 188                 return false;
 189             }
 190         };
 191
 192         MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(requireContext());
 193         builder.setCancelable(true)
 194                .setTitle(R.string.choose_pattern_to_apply)
 195                .setSingleChoiceItems(cursor, -1, patternNameColumn,
 196                        (dialog, which) -> applyPattern(matchingPatterns.get(which), matchedText))
 197                .create()
 198                .show();
 199     }
 200     private void applyPattern(PatternHeader patternHeader, String text) {
 201         Pattern pattern = Pattern.compile(patternHeader.getRegularExpression());
 202
 203         Matcher m = pattern.matcher(text);
 204
 205         if (!m.matches()) {
 206             Snackbar.make(requireView(), R.string.pattern_does_not_match,
 207                     BaseTransientBottomBar.LENGTH_INDEFINITE)
 208                     .show();
 209             return;
 210         }
 211
 212         SimpleDate transactionDate;
 213         {
 214             int day = extractIntFromMatches(m, patternHeader.getDateDayMatchGroup(),
 215                     patternHeader.getDateDay());
 216             int month = extractIntFromMatches(m, patternHeader.getDateMonthMatchGroup(),
 217                     patternHeader.getDateMonth());
 218             int year = extractIntFromMatches(m, patternHeader.getDateYearMatchGroup(),
 219                     patternHeader.getDateYear());
 220
 221             SimpleDate today = SimpleDate.today();
 222             if (year <= 0)
 223                 year = today.year;
 224             if (month <= 0)
 225                 month = today.month;
 226             if (day <= 0)
 227                 day = today.day;
 228
 229             transactionDate = new SimpleDate(year, month, day);
 230
 231             Logger.debug("pattern", "setting transaction date to " + transactionDate);
 232         }
 233
 234         NewTransactionModel.Item head = viewModel.getItem(0);
 235         head.ensureType(NewTransactionModel.ItemType.generalData);
 236         final String transactionDescription =
 237                 extractStringFromMatches(m, patternHeader.getTransactionDescriptionMatchGroup(),
 238                         patternHeader.getTransactionDescription());
 239         head.setDescription(transactionDescription);
 240         Logger.debug("pattern", "Setting transaction description to " + transactionDescription);
 241         final String transactionComment =
 242                 extractStringFromMatches(m, patternHeader.getTransactionCommentMatchGroup(),
 243                         patternHeader.getTransactionComment());
 244         head.setTransactionComment(transactionComment);
 245         Logger.debug("pattern", "Setting transaction comment to " + transactionComment);
 246         head.setDate(transactionDate);
 247         listAdapter.notifyItemChanged(0);
 248
 249         DB.get()
 250           .getPatternDAO()
 251           .getPatternWithAccounts(patternHeader.getId())
 252           .observe(getViewLifecycleOwner(), entry -> {
 253               int rowIndex = 0;
 254               final boolean accountsInInitialState = viewModel.accountsInInitialState();
 255               for (PatternAccount acc : entry.accounts) {
 256                   rowIndex++;
 257
 258                   String accountName = extractStringFromMatches(m, acc.getAccountNameMatchGroup(),
 259                           acc.getAccountName());
 260                   String accountComment =
 261                           extractStringFromMatches(m, acc.getAccountCommentMatchGroup(),
 262                                   acc.getAccountComment());
 263                   Float amount =
 264                           extractFloatFromMatches(m, acc.getAmountMatchGroup(), acc.getAmount());
 265
 266                   if (accountsInInitialState) {
 267                       NewTransactionModel.Item item = viewModel.getItem(rowIndex);
 268                       if (item == null) {
 269                           Logger.debug("pattern", String.format(Locale.US,
 270                                   "Adding new account item [%s][c:%s][a:%s]", accountName,
 271                                   accountComment, amount));
 272                           final LedgerTransactionAccount ledgerAccount =
 273                                   new LedgerTransactionAccount(accountName);
 274                           ledgerAccount.setComment(accountComment);
 275                           if (amount != null)
 276                               ledgerAccount.setAmount(amount);
 277                           // TODO currency
 278                           viewModel.addAccount(ledgerAccount);
 279                           listAdapter.notifyItemInserted(viewModel.items.size() - 1);
 280                       }
 281                       else {
 282                           Logger.debug("pattern", String.format(Locale.US,
 283                                   "Stamping account item #%d [%s][c:%s][a:%s]", rowIndex,
 284                                   accountName, accountComment, amount));
 285
 286                           item.setAccountName(accountName);
 287                           item.setComment(accountComment);
 288                           if (amount != null)
 289                               item.getAccount()
 290                                   .setAmount(amount);
 291
 292                           listAdapter.notifyItemChanged(rowIndex);
 293                       }
 294                   }
 295                   else {
 296                       final LedgerTransactionAccount transactionAccount =
 297                               new LedgerTransactionAccount(accountName);
 298                       transactionAccount.setComment(accountComment);
 299                       if (amount != null)
 300                           transactionAccount.setAmount(amount);
 301                       // TODO currency
 302                       Logger.debug("pattern", String.format(Locale.US,
 303                               "Adding trailing account item [%s][c:%s][a:%s]", accountName,
 304                               accountComment, amount));
 305
 306                       viewModel.addAccount(transactionAccount);
 307                       listAdapter.notifyItemInserted(viewModel.items.size() - 1);
 308                   }
 309               }
 310
 311               listAdapter.checkTransactionSubmittable();
 312           });
 313     }
 314     private int extractIntFromMatches(Matcher m, Integer group, Integer literal) {
 315         if (literal != null)
 316             return literal;
 317
 318         if (group != null) {
 319             int grp = group;
 320             if (grp > 0 & grp <= m.groupCount())
 321                 try {
 322                     return Integer.parseInt(m.group(grp));
 323                 }
 324                 catch (NumberFormatException e) {
 325                     Snackbar.make(requireView(),
 326                             "Error extracting transaction date: " + e.getMessage(),
 327                             BaseTransientBottomBar.LENGTH_INDEFINITE)
 328                             .show();
 329                 }
 330         }
 331
 332         return 0;
 333     }
 334     private String extractStringFromMatches(Matcher m, Integer group, String literal) {
 335         if (literal != null)
 336             return literal;
 337
 338         if (group != null) {
 339             int grp = group;
 340             if (grp > 0 & grp <= m.groupCount())
 341                 return m.group(grp);
 342         }
 343
 344         return null;
 345     }
 346     private Float extractFloatFromMatches(Matcher m, Integer group, Float literal) {
 347         if (literal != null)
 348             return literal;
 349
 350         if (group != null) {
 351             int grp = group;
 352             if (grp > 0 & grp <= m.groupCount())
 353                 try {
 354                     return Float.valueOf(m.group(grp));
 355                 }
 356                 catch (NumberFormatException e) {
 357                     Snackbar.make(requireView(),
 358                             "Error extracting transaction amount: " + e.getMessage(),
 359                             BaseTransientBottomBar.LENGTH_INDEFINITE)
 360                             .show();
 361                 }
 362         }
 363
 364         return null;
 365     }
 366     @Override
 367     public void onCreateOptionsMenu(@NonNull Menu menu, @NonNull MenuInflater inflater) {
 368         super.onCreateOptionsMenu(menu, inflater);
 369         final FragmentActivity activity = getActivity();
 370
 371         inflater.inflate(R.menu.new_transaction_fragment, menu);
 372
 373         menu.findItem(R.id.scan_qr)
 374             .setOnMenuItemClickListener(this::onScanQrAction);
 375
 376         menu.findItem(R.id.action_reset_new_transaction_activity)
 377             .setOnMenuItemClickListener(item -> {
 378                 listAdapter.reset();
 379                 return true;
 380             });
 381
 382         final MenuItem toggleCurrencyItem = menu.findItem(R.id.toggle_currency);
 383         toggleCurrencyItem.setOnMenuItemClickListener(item -> {
 384             viewModel.toggleCurrencyVisible();
 385             return true;
 386         });
 387         if (activity != null)
 388             viewModel.showCurrency.observe(activity, toggleCurrencyItem::setChecked);
 389
 390         final MenuItem toggleCommentsItem = menu.findItem(R.id.toggle_comments);
 391         toggleCommentsItem.setOnMenuItemClickListener(item -> {
 392             viewModel.toggleShowComments();
 393             return true;
 394         });
 395         if (activity != null)
 396             viewModel.showComments.observe(activity, toggleCommentsItem::setChecked);
 397     }
 398     private boolean onScanQrAction(MenuItem item) {
 399         try {
 400             scanQrLauncher.launch(null);
 401         }
 402         catch (Exception e) {
 403             Logger.debug("qr", "Error launching QR scanner", e);
 404         }
 405
 406         return true;
 407     }
 408     @Override
 409     public View onCreateView(LayoutInflater inflater, ViewGroup container,
 410                              Bundle savedInstanceState) {
 411         // Inflate the layout for this fragment
 412         return inflater.inflate(R.layout.fragment_new_transaction, container, false);
 413     }
 414
 415     @Override
 416     public void onViewCreated(@NotNull View view, @Nullable Bundle savedInstanceState) {
 417         super.onViewCreated(view, savedInstanceState);
 418         FragmentActivity activity = getActivity();
 419         if (activity == null)
 420             throw new RSInvalidStateException(
 421                     "getActivity() returned null within onActivityCreated()");
 422
 423         viewModel = new ViewModelProvider(activity).get(NewTransactionModel.class);
 424         viewModel.observeDataProfile(this);
 425         mProfile = Data.getProfile();
 426         listAdapter = new NewTransactionItemsAdapter(viewModel, mProfile);
 427
 428         RecyclerView list = activity.findViewById(R.id.new_transaction_accounts);
 429         list.setAdapter(listAdapter);
 430         list.setLayoutManager(new LinearLayoutManager(activity));
 431
 432         Data.observeProfile(getViewLifecycleOwner(), profile -> {
 433             mProfile = profile;
 434             listAdapter.setProfile(profile);
 435         });
 436         listAdapter.notifyDataSetChanged();
 437         viewModel.isSubmittable()
 438                  .observe(getViewLifecycleOwner(), isSubmittable -> {
 439                      if (isSubmittable) {
 440                          if (fab != null) {
 441                              fab.show();
 442                          }
 443                      }
 444                      else {
 445                          if (fab != null) {
 446                              fab.hide();
 447                          }
 448                      }
 449                  });
 450 //        viewModel.checkTransactionSubmittable(listAdapter);
 451
 452         fab = activity.findViewById(R.id.fabAdd);
 453         fab.setOnClickListener(v -> onFabPressed());
 454
 455         boolean keep = false;
 456
 457         Bundle args = getArguments();
 458         if (args != null) {
 459             String error = args.getString("error");
 460             if (error != null) {
 461                 Logger.debug("new-trans-f", String.format("Got error: %s", error));
 462
 463                 Context context = getContext();
 464                 if (context != null) {
 465                     AlertDialog.Builder builder = new AlertDialog.Builder(context);
 466                     final Resources resources = context.getResources();
 467                     final StringBuilder message = new StringBuilder();
 468                     message.append(resources.getString(R.string.err_json_send_error_head));
 469                     message.append("\n\n");
 470                     message.append(error);
 471                     if (mProfile.getApiVersion()
 472                                 .equals(API.auto))
 473                         message.append(
 474                                 resources.getString(R.string.err_json_send_error_unsupported));
 475                     else {
 476                         message.append(resources.getString(R.string.err_json_send_error_tail));
 477                         builder.setPositiveButton(R.string.btn_profile_options, (dialog, which) -> {
 478                             Logger.debug("error", "will start profile editor");
 479                             MobileLedgerProfile.startEditProfileActivity(context, mProfile);
 480                         });
 481                     }
 482                     builder.setMessage(message);
 483                     builder.create()
 484                            .show();
 485                 }
 486                 else {
 487                     Snackbar.make(list, error, Snackbar.LENGTH_INDEFINITE)
 488                             .show();
 489                 }
 490                 keep = true;
 491             }
 492         }
 493
 494         int focused = 0;
 495         if (savedInstanceState != null) {
 496             keep |= savedInstanceState.getBoolean("keep", true);
 497             focused = savedInstanceState.getInt("focused", 0);
 498         }
 499
 500         if (!keep)
 501             viewModel.reset();
 502         else {
 503             viewModel.setFocusedItem(focused);
 504         }
 505
 506         ProgressBar p = activity.findViewById(R.id.progressBar);
 507         viewModel.observeBusyFlag(getViewLifecycleOwner(), isBusy -> {
 508             if (isBusy) {
 509 //                Handler h = new Handler();
 510 //                h.postDelayed(() -> {
 511 //                    if (viewModel.getBusyFlag())
 512 //                        p.setVisibility(View.VISIBLE);
 513 //
 514 //                }, 10);
 515                 p.setVisibility(View.VISIBLE);
 516             }
 517             else
 518                 p.setVisibility(View.INVISIBLE);
 519         });
 520     }
 521     @Override
 522     public void onSaveInstanceState(@NonNull Bundle outState) {
 523         super.onSaveInstanceState(outState);
 524         outState.putBoolean("keep", true);
 525         final int focusedItem = viewModel.getFocusedItem();
 526         outState.putInt("focused", focusedItem);
 527     }
 528     private void onFabPressed() {
 529         fab.hide();
 530         Misc.hideSoftKeyboard(this);
 531         if (mListener != null) {
 532             SimpleDate date = viewModel.getDate();
 533             LedgerTransaction tr =
 534                     new LedgerTransaction(null, date, viewModel.getDescription(), mProfile);
 535
 536             tr.setComment(viewModel.getComment());
 537             LedgerTransactionAccount emptyAmountAccount = null;
 538             float emptyAmountAccountBalance = 0;
 539             for (int i = 0; i < viewModel.getAccountCount(); i++) {
 540                 LedgerTransactionAccount acc =
 541                         new LedgerTransactionAccount(viewModel.getAccount(i));
 542                 if (acc.getAccountName()
 543                        .trim()
 544                        .isEmpty())
 545                     continue;
 546
 547                 if (acc.isAmountSet()) {
 548                     emptyAmountAccountBalance += acc.getAmount();
 549                 }
 550                 else {
 551                     emptyAmountAccount = acc;
 552                 }
 553
 554                 tr.addAccount(acc);
 555             }
 556
 557             if (emptyAmountAccount != null)
 558                 emptyAmountAccount.setAmount(-emptyAmountAccountBalance);
 559
 560             mListener.onTransactionSave(tr);
 561         }
 562     }
 563
 564     @Override
 565     public void onAttach(@NotNull Context context) {
 566         super.onAttach(context);
 567         if (context instanceof OnNewTransactionFragmentInteractionListener) {
 568             mListener = (OnNewTransactionFragmentInteractionListener) context;
 569         }
 570         else {
 571             throw new RuntimeException(
 572                     context.toString() + " must implement OnFragmentInteractionListener");
 573         }
 574     }
 575
 576     @Override
 577     public void onDetach() {
 578         super.onDetach();
 579         mListener = null;
 580     }
 581
 582     /**
 583      * This interface must be implemented by activities that contain this
 584      * fragment to allow an interaction in this fragment to be communicated
 585      * to the activity and potentially other fragments contained in that
 586      * activity.
 587      * <p>
 588      * See the Android Training lesson <a href=
 589      * "http://developer.android.com/training/basics/fragments/communicating.html"
 590      * >Communicating with Other Fragments</a> for more information.
 591      */
 592     public interface OnNewTransactionFragmentInteractionListener {
 593         void onTransactionSave(LedgerTransaction tr);
 594     }
 595 }