http error handling in legacy parsing code

[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 35277d6749e5f048c77f6ff62c78b1b0b1d465e3..88b36c8b4a8c27a2b9e510f8e17de27014a63311 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;
@@ -107,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<>();
@@ -118,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)
@@ -166,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,
@@ -188,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);
                                         }
                                     }
 
@@ -213,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);
                                 }
@@ -284,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);
                                     }
@@ -356,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()) {
@@ -372,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();
@@ -397,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);
@@ -418,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)) {
@@ -430,11 +464,12 @@ 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);
                         }
@@ -443,8 +478,11 @@ public class RetrieveTransactionsTask
                         publishProgress(progress);
                     }
 
+                    throwIfCancelled();
                     profile.deleteNotPresentTransactions(db);
+                    throwIfCancelled();
                     db.setTransactionSuccessful();
+                    profile.setLastUpdateStamp();
                 }
                 finally {
                     db.endTransaction();
@@ -468,13 +506,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 "Parse error";
         }
         catch (ParseException e) {
             e.printStackTrace();