better error message on network errors

[mobile-ledger.git] / app / src / main / java / net / ktnx / mobileledger / async / RetrieveTransactionsTask.java

diff --git a/app/src/main/java/net/ktnx/mobileledger/async/RetrieveTransactionsTask.java b/app/src/main/java/net/ktnx/mobileledger/async/RetrieveTransactionsTask.java
index 4ca3f827449c0c0ea5364229169b501877ea4a25..47154b0b8744ca66302172db2380a3a337525e46 100644 (file)
--- a/app/src/main/java/net/ktnx/mobileledger/async/RetrieveTransactionsTask.java
+++ b/app/src/main/java/net/ktnx/mobileledger/async/RetrieveTransactionsTask.java
@@ -23,6 +23,7 @@ import android.os.AsyncTask;
 import android.os.OperationCanceledException;
 import android.util.Log;
 
+import net.ktnx.mobileledger.err.HTTPException;
 import net.ktnx.mobileledger.json.AccountListParser;
 import net.ktnx.mobileledger.json.ParsedBalance;
 import net.ktnx.mobileledger.json.ParsedLedgerAccount;
@@ -38,7 +39,6 @@ import net.ktnx.mobileledger.utils.MLDB;
 import net.ktnx.mobileledger.utils.NetworkUtil;
 
 import java.io.BufferedReader;
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -49,7 +49,6 @@ import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
 import java.text.ParseException;
 import java.util.ArrayList;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.Stack;
 import java.util.regex.Matcher;
@@ -108,7 +107,7 @@ public class RetrieveTransactionsTask
         context.onRetrieveDone(null);
     }
     private String retrieveTransactionListLegacy(MobileLedgerProfile profile)
-            throws IOException, ParseException {
+            throws IOException, ParseException, HTTPException {
         Progress progress = new Progress();
         int maxTransactionId = Progress.INDETERMINATE;
         ArrayList<LedgerAccount> accountList = new ArrayList<>();
@@ -119,6 +118,12 @@ public class RetrieveTransactionsTask
         HttpURLConnection http = NetworkUtil.prepareConnection(profile, "journal");
         http.setAllowUserInteraction(false);
         publishProgress(progress);
+        switch (http.getResponseCode()) {
+            case 200:
+                break;
+            default:
+                throw new HTTPException(http.getResponseCode(), http.getResponseMessage());
+        }
         try (SQLiteDatabase db = MLDB.getWritableDatabase()) {
             try (InputStream resp = http.getInputStream()) {
                 if (http.getResponseCode() != 200)
@@ -167,7 +172,7 @@ public class RetrieveTransactionsTask
                                     lastAccount = profile.loadAccount(acct_name);
                                     if (lastAccount == null) {
                                         lastAccount = new LedgerAccount(acct_name);
-                                        profile.storeAccount(lastAccount);
+                                        profile.storeAccount(db, lastAccount);
                                     }
 
                                     // make sure the parent account(s) are present,
@@ -189,7 +194,7 @@ public class RetrieveTransactionsTask
                                                 accountList.add(acc);
                                             L(String.format("gap-filling with %s", aName));
                                             accountNames.put(aName, null);
-                                            profile.storeAccount(acc);
+                                            profile.storeAccount(db, acc);
                                         }
                                     }
 
@@ -214,7 +219,7 @@ public class RetrieveTransactionsTask
                                     if (currency == null) currency = "";
                                     value = value.replace(',', '.');
                                     L("curr=" + currency + ", value=" + value);
-                                    profile.storeAccountValue(lastAccount.getName(), currency,
+                                    profile.storeAccountValue(db, lastAccount.getName(), currency,
                                             Float.valueOf(value));
                                     lastAccount.addAmount(Float.parseFloat(value), currency);
                                 }
@@ -285,14 +290,15 @@ public class RetrieveTransactionsTask
                                         if (matchedTransactionsCount ==
                                             MATCHING_TRANSACTIONS_LIMIT)
                                         {
-                                            profile.markTransactionsBeforeTransactionAsPresent(db, transaction);
+                                            profile.markTransactionsBeforeTransactionAsPresent(db,
+                                                    transaction);
                                             progress.setTotal(progress.getProgress());
                                             publishProgress(progress);
                                             break LINES;
                                         }
                                     }
                                     else {
-                                        profile.storeTransaction(transaction);
+                                        profile.storeTransaction(db, transaction);
                                         matchedTransactionsCount = 0;
                                         progress.setTotal(maxTransactionId);
                                     }
@@ -340,10 +346,7 @@ public class RetrieveTransactionsTask
                     profile.deleteNotPresentTransactions(db);
                     db.setTransactionSuccessful();
 
-                    Log.d("db", "Updating transaction value stamp");
-                    Date now = new Date();
-                    profile.setLongOption(MLDB.OPT_LAST_SCRAPE, now.getTime());
-                    Data.lastUpdateDate.set(now);
+                    profile.setLastUpdateStamp();
 
                     return null;
                 }
@@ -360,11 +363,20 @@ public class RetrieveTransactionsTask
                 new String[]{profile.getUuid()});
         db.execSQL("update accounts set keep=0 where profile=?;", new String[]{profile.getUuid()});
     }
-    private boolean retrieveAccountList(MobileLedgerProfile profile) throws IOException {
+    private boolean retrieveAccountList(MobileLedgerProfile profile)
+            throws IOException, HTTPException {
         Progress progress = new Progress();
 
         HttpURLConnection http = NetworkUtil.prepareConnection(profile, "accounts");
         http.setAllowUserInteraction(false);
+        switch (http.getResponseCode()) {
+            case 200:
+                break;
+            case 404:
+                return false;
+            default:
+                throw new HTTPException(http.getResponseCode(), http.getResponseMessage());
+        }
         publishProgress(progress);
         try (SQLiteDatabase db = MLDB.getWritableDatabase()) {
             try (InputStream resp = http.getInputStream()) {
@@ -376,21 +388,28 @@ public class RetrieveTransactionsTask
                     profile.markAccountsAsNotPresent(db);
 
                     AccountListParser parser = new AccountListParser(resp);
+                    ArrayList<LedgerAccount> accountList = new ArrayList<>();
 
                     while (true) {
+                        throwIfCancelled();
                         ParsedLedgerAccount parsedAccount = parser.nextAccount();
                         if (parsedAccount == null) break;
 
                         LedgerAccount acc = new LedgerAccount(parsedAccount.getAname());
-                        profile.storeAccount(acc);
+                        profile.storeAccount(db, acc);
                         for (ParsedBalance b : parsedAccount.getAebalance()) {
-                            profile.storeAccountValue(acc.getName(), b.getAcommodity(),
+                            profile.storeAccountValue(db, acc.getName(), b.getAcommodity(),
                                     b.getAquantity().asFloat());
                         }
+
+                        accountList.add(acc);
                     }
+                    throwIfCancelled();
 
                     profile.deleteNotPresentAccounts(db);
+                    throwIfCancelled();
                     db.setTransactionSuccessful();
+                    Data.accounts.set(accountList);
                 }
                 finally {
                     db.endTransaction();
@@ -401,17 +420,26 @@ public class RetrieveTransactionsTask
         return true;
     }
     private boolean retrieveTransactionList(MobileLedgerProfile profile)
-            throws IOException, ParseException {
+            throws IOException, ParseException, HTTPException {
         Progress progress = new Progress();
         int maxTransactionId = Progress.INDETERMINATE;
 
         HttpURLConnection http = NetworkUtil.prepareConnection(profile, "transactions");
         http.setAllowUserInteraction(false);
         publishProgress(progress);
+        switch (http.getResponseCode()) {
+            case 200:
+                break;
+            case 404:
+                return false;
+            default:
+                throw new HTTPException(http.getResponseCode(), http.getResponseMessage());
+        }
         try (SQLiteDatabase db = MLDB.getWritableDatabase()) {
             try (InputStream resp = http.getInputStream()) {
                 if (http.getResponseCode() != 200)
                     throw new IOException(String.format("HTTP error %d", http.getResponseCode()));
+                throwIfCancelled();
                 db.beginTransaction();
                 try {
                     profile.markTransactionsAsNotPresent(db);
@@ -422,7 +450,9 @@ public class RetrieveTransactionsTask
                     int processedTransactionCount = 0;
 
                     while (true) {
+                        throwIfCancelled();
                         ParsedLedgerTransaction parsedTransaction = parser.nextTransaction();
+                        throwIfCancelled();
                         if (parsedTransaction == null) break;
                         LedgerTransaction transaction = parsedTransaction.asLedgerTransaction();
                         if (transaction.existsInDb(db)) {
@@ -434,21 +464,29 @@ public class RetrieveTransactionsTask
                                 progress.setTotal(progress.getProgress());
                                 publishProgress(progress);
                                 db.setTransactionSuccessful();
+                                profile.setLastUpdateStamp();
                                 return true;
                             }
                         }
                         else {
-                            profile.storeTransaction(transaction);
+                            profile.storeTransaction(db, transaction);
                             matchedTransactionsCount = 0;
                             progress.setTotal(maxTransactionId);
                         }
 
+                        if ((progress.getTotal() == Progress.INDETERMINATE) ||
+                            (progress.getTotal() < transaction.getId()))
+                            progress.setTotal(transaction.getId());
+
                         progress.setProgress(++processedTransactionCount);
                         publishProgress(progress);
                     }
 
+                    throwIfCancelled();
                     profile.deleteNotPresentTransactions(db);
+                    throwIfCancelled();
                     db.setTransactionSuccessful();
+                    profile.setLastUpdateStamp();
                 }
                 finally {
                     db.endTransaction();
@@ -472,13 +510,13 @@ public class RetrieveTransactionsTask
             e.printStackTrace();
             return "Invalid server URL";
         }
-        catch (FileNotFoundException e) {
+        catch (HTTPException e) {
             e.printStackTrace();
-            return "Invalid user name or password";
+            return String.format("HTTP error %d: %s", e.getResponseCode(), e.getResponseMessage());
         }
         catch (IOException e) {
             e.printStackTrace();
-            return "Network error";
+            return e.getLocalizedMessage();
         }
         catch (ParseException e) {
             e.printStackTrace();