app/src/main/java/net/ktnx/mobileledger/async/RetrieveTransactionsTask.java

   1 /*
   2  * Copyright © 2018 Damyan Ivanov.
   3  * This file is part of Mobile-Ledger.
   4  * Mobile-Ledger 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  * Mobile-Ledger 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 Mobile-Ledger. If not, see <https://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.ktnx.mobileledger.async;
  19
  20 import android.annotation.SuppressLint;
  21 import android.content.Context;
  22 import android.content.SharedPreferences;
  23 import android.database.sqlite.SQLiteDatabase;
  24 import android.os.AsyncTask;
  25 import android.util.Log;
  26
  27 import net.ktnx.mobileledger.R;
  28 import net.ktnx.mobileledger.TransactionListActivity;
  29 import net.ktnx.mobileledger.model.LedgerTransaction;
  30 import net.ktnx.mobileledger.model.LedgerTransactionItem;
  31 import net.ktnx.mobileledger.utils.MLDB;
  32 import net.ktnx.mobileledger.utils.NetworkUtil;
  33
  34 import java.io.BufferedReader;
  35 import java.io.FileNotFoundException;
  36 import java.io.IOException;
  37 import java.io.InputStream;
  38 import java.io.InputStreamReader;
  39 import java.lang.ref.WeakReference;
  40 import java.net.HttpURLConnection;
  41 import java.net.MalformedURLException;
  42 import java.util.regex.Matcher;
  43 import java.util.regex.Pattern;
  44
  45
  46 public class RetrieveTransactionsTask extends
  47         AsyncTask<RetrieveTransactionsTask.Params, RetrieveTransactionsTask.Progress, Void> {
  48     private static final Pattern transactionStartPattern = Pattern.compile("<tr class=\"title\" " +
  49                                                                            "id=\"transaction-(\\d+)\"><td class=\"date\"[^\\\"]*>([\\d.-]+)</td>");
  50     private static final Pattern transactionDescriptionPattern =
  51             Pattern.compile("<tr class=\"posting\" title=\"(\\S+)\\s(.+)");
  52     private static final Pattern transactionDetailsPattern =
  53             Pattern.compile("^\\s+" + "(\\S[\\S\\s]+\\S)\\s\\s+([-+]?\\d[\\d,.]*)");
  54     private static final Pattern endPattern = Pattern.compile("\\bid=\"addmodal\"");
  55     protected WeakReference<TransactionListActivity> contextRef;
  56     protected int error;
  57     private boolean success;
  58     public RetrieveTransactionsTask(WeakReference<TransactionListActivity> contextRef) {
  59         this.contextRef = contextRef;
  60     }
  61     private static final void L(String msg) {
  62         Log.d("transaction-parser", msg);
  63     }
  64     @Override
  65     protected void onProgressUpdate(Progress... values) {
  66         super.onProgressUpdate(values);
  67         TransactionListActivity context = getContext();
  68         if (context == null) return;
  69         context.onRetrieveProgress(values[0]);
  70     }
  71     @Override
  72     protected void onPreExecute() {
  73         super.onPreExecute();
  74         TransactionListActivity context = getContext();
  75         if (context == null) return;
  76         context.onRetrieveStart();
  77     }
  78     @Override
  79     protected void onPostExecute(Void aVoid) {
  80         super.onPostExecute(aVoid);
  81         TransactionListActivity context = getContext();
  82         if (context == null) return;
  83         context.onRetrieveDone(success);
  84     }
  85     @SuppressLint("DefaultLocale")
  86     @Override
  87     protected Void doInBackground(Params... params) {
  88         Progress progress = new Progress();
  89         success = false;
  90         try {
  91             HttpURLConnection http =
  92                     NetworkUtil.prepare_connection(params[0].getBackendPref(), "journal");
  93             http.setAllowUserInteraction(false);
  94             publishProgress(progress);
  95             Context ctx = contextRef.get();
  96             if (ctx == null) return null;
  97             try (SQLiteDatabase db = MLDB.getWritableDatabase(ctx)) {
  98                     try (InputStream resp = http.getInputStream()) {
  99                         if (http.getResponseCode() != 200) throw new IOException(
 100                                 String.format("HTTP error %d", http.getResponseCode()));
 101                         db.beginTransaction();
 102                         try {
 103                             db.execSQL("DELETE FROM transactions;");
 104                             db.execSQL("DELETE FROM transaction_accounts");
 105
 106                             int state = ParserState.EXPECTING_JOURNAL;
 107                             String line;
 108                             BufferedReader buf =
 109                                     new BufferedReader(new InputStreamReader(resp, "UTF-8"));
 110
 111                             int transactionCount = 0;
 112                             int transactionId = 0;
 113                             LedgerTransaction transaction = null;
 114                             LINES:
 115                             while ((line = buf.readLine()) != null) {
 116                                 if (isCancelled()) break;
 117                                 if (!line.isEmpty() && (line.charAt(0) == ' ')) continue;
 118                                 Matcher m;
 119                                 //L(String.format("State is %d", state));
 120                                 switch (state) {
 121                                     case ParserState.EXPECTING_JOURNAL:
 122                                         if (line.equals("<h2>General Journal</h2>")) {
 123                                             state = ParserState.EXPECTING_TRANSACTION;
 124                                             L("→ expecting transaction");
 125                                         }
 126                                         break;
 127                                     case ParserState.EXPECTING_TRANSACTION:
 128                                         m = transactionStartPattern.matcher(line);
 129                                         if (m.find()) {
 130                                             transactionId = Integer.valueOf(m.group(1));
 131                                             state = ParserState.EXPECTING_TRANSACTION_DESCRIPTION;
 132                                             L(String.format("found transaction %d → expecting " +
 133                                                             "description", transactionId));
 134                                             progress.setProgress(++transactionCount);
 135                                             if (progress.getTotal() == Progress.INDETERMINATE)
 136                                                 progress.setTotal(transactionId);
 137                                             publishProgress(progress);
 138                                         }
 139                                         m = endPattern.matcher(line);
 140                                         if (m.find()) {
 141                                             L("--- transaction list complete ---");
 142                                             success = true;
 143                                             break LINES;
 144                                         }
 145                                         break;
 146                                     case ParserState.EXPECTING_TRANSACTION_DESCRIPTION:
 147                                         m = transactionDescriptionPattern.matcher(line);
 148                                         if (m.find()) {
 149                                             if (transactionId == 0)
 150                                                 throw new TransactionParserException(
 151                                                         "Transaction Id is 0 while expecting " +
 152                                                         "description");
 153
 154                                             transaction =
 155                                                     new LedgerTransaction(transactionId, m.group(1),
 156                                                             m.group(2));
 157                                             state = ParserState.EXPECTING_TRANSACTION_DETAILS;
 158                                             L(String.format("transaction %d created for %s (%s) →" +
 159                                                             " expecting details", transactionId,
 160                                                     m.group(1), m.group(2)));
 161                                         }
 162                                         break;
 163                                     case ParserState.EXPECTING_TRANSACTION_DETAILS:
 164                                         if (line.isEmpty()) {
 165                                             // transaction data collected
 166                                             transaction.insertInto(db);
 167
 168                                             state = ParserState.EXPECTING_TRANSACTION;
 169                                             L(String.format("transaction %s saved → expecting " +
 170                                                             "transaction", transaction.getId()));
 171
 172 // sounds like a good idea, but transaction-1 may not be the first one chronologically
 173 // for example, when you add the initial seeding transaction after entering some others
 174 //                                            if (transactionId == 1) {
 175 //                                                L("This was the initial transaction. Terminating " +
 176 //                                                  "parser");
 177 //                                                break LINES;
 178 //                                            }
 179                                         }
 180                                         else {
 181                                             m = transactionDetailsPattern.matcher(line);
 182                                             if (m.find()) {
 183                                                 String acc_name = m.group(1);
 184                                                 String amount = m.group(2);
 185                                                 amount = amount.replace(',', '.');
 186                                                 transaction.add_item(
 187                                                         new LedgerTransactionItem(acc_name,
 188                                                                 Float.valueOf(amount)));
 189                                                 L(String.format("%s = %s", acc_name, amount));
 190                                             }
 191                                             else throw new IllegalStateException(String.format(
 192                                                     "Can't parse transaction details"));
 193                                         }
 194                                         break;
 195                                     default:
 196                                         throw new RuntimeException(
 197                                                 String.format("Unknown " + "parser state %d",
 198                                                         state));
 199                                 }
 200                             }
 201                             if (!isCancelled()) db.setTransactionSuccessful();
 202                         }
 203                         finally {
 204                             db.endTransaction();
 205                         }
 206                     }
 207                 }
 208             }
 209         }
 210         catch (MalformedURLException e) {
 211             error = R.string.err_bad_backend_url;
 212             e.printStackTrace();
 213         }
 214         catch (FileNotFoundException e) {
 215             error = R.string.err_bad_auth;
 216             e.printStackTrace();
 217         }
 218         catch (IOException e) {
 219             error = R.string.err_net_io_error;
 220             e.printStackTrace();
 221         }
 222         return null;
 223     }
 224     TransactionListActivity getContext() {
 225         return contextRef.get();
 226     }
 227
 228     public static class Params {
 229         static final int DEFAULT_LIMIT = 100;
 230         private SharedPreferences backendPref;
 231         private String accountsRoot;
 232         private int limit;
 233
 234         public Params(SharedPreferences backendPref) {
 235             this.backendPref = backendPref;
 236             this.accountsRoot = null;
 237             this.limit = DEFAULT_LIMIT;
 238         }
 239         Params(SharedPreferences backendPref, String accountsRoot) {
 240             this(backendPref, accountsRoot, DEFAULT_LIMIT);
 241         }
 242         Params(SharedPreferences backendPref, String accountsRoot, int limit) {
 243             this.backendPref = backendPref;
 244             this.accountsRoot = accountsRoot;
 245             this.limit = limit;
 246         }
 247         String getAccountsRoot() {
 248             return accountsRoot;
 249         }
 250         SharedPreferences getBackendPref() {
 251             return backendPref;
 252         }
 253         int getLimit() {
 254             return limit;
 255         }
 256     }
 257
 258     public class Progress {
 259         public static final int INDETERMINATE = -1;
 260         private int progress;
 261         private int total;
 262         Progress() {
 263             this(INDETERMINATE, INDETERMINATE);
 264         }
 265         Progress(int progress, int total) {
 266             this.progress = progress;
 267             this.total = total;
 268         }
 269         public int getProgress() {
 270             return progress;
 271         }
 272         protected void setProgress(int progress) {
 273             this.progress = progress;
 274         }
 275         public int getTotal() {
 276             return total;
 277         }
 278         protected void setTotal(int total) {
 279             this.total = total;
 280         }
 281     }
 282
 283     private class TransactionParserException extends IllegalStateException {
 284         TransactionParserException(String message) {
 285             super(message);
 286         }
 287     }
 288
 289     private class ParserState {
 290         static final int EXPECTING_JOURNAL = 0;
 291         static final int EXPECTING_TRANSACTION = 1;
 292         static final int EXPECTING_TRANSACTION_DESCRIPTION = 2;
 293         static final int EXPECTING_TRANSACTION_DETAILS = 3;
 294     }
 295 }