X-Git-Url: https://git.ktnx.net/?a=blobdiff_plain;f=app%2Fsrc%2Fmain%2Fjava%2Fnet%2Fktnx%2Fmobileledger%2Fasync%2FRetrieveTransactionsTask.java;h=d092a1cbfc55f1f0294cef1f6fc583248e14efa6;hb=a87079ed41bdc3ad89fe8bd15dfba10e37b29b76;hp=ac9ec5093e54ece20790e6107f8fe2d593c5d9af;hpb=1930f3fa34616229bd6a83654e6527672064196a;p=mobile-ledger-staging.git 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 ac9ec509..d092a1cb 100644 --- a/app/src/main/java/net/ktnx/mobileledger/async/RetrieveTransactionsTask.java +++ b/app/src/main/java/net/ktnx/mobileledger/async/RetrieveTransactionsTask.java @@ -24,18 +24,20 @@ import android.os.OperationCanceledException; import androidx.annotation.NonNull; +import com.fasterxml.jackson.databind.RuntimeJsonMappingException; + import net.ktnx.mobileledger.App; import net.ktnx.mobileledger.err.HTTPException; -import net.ktnx.mobileledger.json.v1_15.AccountListParser; -import net.ktnx.mobileledger.json.v1_15.ParsedBalance; -import net.ktnx.mobileledger.json.v1_15.ParsedLedgerAccount; -import net.ktnx.mobileledger.json.v1_15.ParsedLedgerTransaction; -import net.ktnx.mobileledger.json.v1_15.TransactionListParser; +import net.ktnx.mobileledger.json.AccountListParser; +import net.ktnx.mobileledger.json.ApiNotSupportedException; +import net.ktnx.mobileledger.json.TransactionListParser; import net.ktnx.mobileledger.model.Data; import net.ktnx.mobileledger.model.LedgerAccount; import net.ktnx.mobileledger.model.LedgerTransaction; import net.ktnx.mobileledger.model.LedgerTransactionAccount; import net.ktnx.mobileledger.model.MobileLedgerProfile; +import net.ktnx.mobileledger.ui.MainModel; +import net.ktnx.mobileledger.utils.Logger; import net.ktnx.mobileledger.utils.NetworkUtil; import java.io.BufferedReader; @@ -48,15 +50,17 @@ import java.net.URLDecoder; import java.nio.charset.StandardCharsets; import java.text.ParseException; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Locale; import java.util.Objects; import java.util.regex.Matcher; import java.util.regex.Pattern; -public class RetrieveTransactionsTask - extends AsyncTask { +public class RetrieveTransactionsTask extends + AsyncTask { private static final int MATCHING_TRANSACTIONS_LIMIT = 150; private static final Pattern reComment = Pattern.compile("^\\s*;"); private static final Pattern reTransactionStart = Pattern.compile( @@ -71,13 +75,20 @@ public class RetrieveTransactionsTask private static final Pattern reDecimalPoint = Pattern.compile("\\.\\d\\d?$"); private static final Pattern reDecimalComma = Pattern.compile(",\\d\\d?$"); // %3A is '=' - private Pattern reAccountName = Pattern.compile("/register\\?q=inacct%3A([a-zA-Z0-9%]+)\""); - private Pattern reAccountValue = Pattern.compile( + private final Pattern reAccountName = + Pattern.compile("/register\\?q=inacct%3A([a-zA-Z0-9%]+)\""); + private final Pattern reAccountValue = Pattern.compile( "\\s*([-+]?[\\d.,]+)(?:\\s+(\\S+))?"); - private MobileLedgerProfile profile; + private final MainModel mainModel; + private final MobileLedgerProfile profile; + private final List prevAccounts; private int expectedPostingsCount = -1; - public RetrieveTransactionsTask(@NonNull MobileLedgerProfile profile) { + public RetrieveTransactionsTask(@NonNull MainModel mainModel, + @NonNull MobileLedgerProfile profile, + List accounts) { + this.mainModel = mainModel; this.profile = profile; + this.prevAccounts = accounts; } private static void L(String msg) { //debug("transaction-parser", msg); @@ -109,17 +120,20 @@ public class RetrieveTransactionsTask return null; } } + public MobileLedgerProfile getProfile() { + return profile; + } @Override protected void onProgressUpdate(Progress... values) { super.onProgressUpdate(values); Data.backgroundTaskProgress.postValue(values[0]); } @Override - protected void onPostExecute(String error) { - super.onPostExecute(error); + protected void onPostExecute(Result result) { + super.onPostExecute(result); Progress progress = new Progress(); progress.setState(ProgressState.FINISHED); - progress.setError(error); + progress.setError(result.error); onProgressUpdate(progress); } @Override @@ -129,15 +143,14 @@ public class RetrieveTransactionsTask progress.setState(ProgressState.FINISHED); onProgressUpdate(progress); } - private String retrieveTransactionListLegacy() throws IOException, HTTPException { + private void retrieveTransactionListLegacy(List accounts, + List transactions) + throws IOException, HTTPException { Progress progress = Progress.indeterminate(); progress.setState(ProgressState.RUNNING); progress.setTotal(expectedPostingsCount); int maxTransactionId = -1; - ArrayList list = new ArrayList<>(); HashMap map = new HashMap<>(); - ArrayList displayed = new ArrayList<>(); - ArrayList transactions = new ArrayList<>(); LedgerAccount lastAccount = null; ArrayList syntheticAccounts = new ArrayList<>(); @@ -202,7 +215,7 @@ public class RetrieveTransactionsTask } lastAccount = new LedgerAccount(profile, accName, parentAccount); - list.add(lastAccount); + accounts.add(lastAccount); map.put(accName, lastAccount); state = ParserState.EXPECTING_ACCOUNT_AMOUNT; @@ -284,7 +297,7 @@ public class RetrieveTransactionsTask if (m.find()) { if (transactionId == 0) throw new TransactionParserException( - "Transaction Id is 0 while expecting " + "description"); + "Transaction Id is 0 while expecting description"); String date = Objects.requireNonNull(m.group(1)); try { @@ -295,8 +308,8 @@ public class RetrieveTransactionsTask new LedgerTransaction(transactionId, date, m.group(2)); } catch (ParseException e) { - e.printStackTrace(); - return String.format("Error parsing date '%s'", date); + throw new TransactionParserException( + String.format("Error parsing date '%s'", date)); } state = ParserState.EXPECTING_TRANSACTION_DETAILS; L(String.format(Locale.ENGLISH, @@ -345,15 +358,11 @@ public class RetrieveTransactionsTask } throwIfCancelled(); - - profile.setAndStoreAccountAndTransactionListFromWeb(list, transactions); - - return null; } } - private @NonNull - LedgerAccount ensureAccountExists(String accountName, HashMap map, - ArrayList createdAccounts) { + @NonNull + public LedgerAccount ensureAccountExists(String accountName, HashMap map, + ArrayList createdAccounts) { LedgerAccount acc = map.get(accountName); if (acc != null) @@ -372,14 +381,50 @@ public class RetrieveTransactionsTask createdAccounts.add(acc); return acc; } - private boolean retrieveAccountList() throws IOException, HTTPException { + public void addNumberOfPostings(int number) { + expectedPostingsCount += number; + } + private List retrieveAccountList() + throws IOException, HTTPException, ApiNotSupportedException { + final SendTransactionTask.API apiVersion = profile.getApiVersion(); + if (apiVersion.equals(SendTransactionTask.API.auto)) { + return retrieveAccountListAnyVersion(); + } + else if (apiVersion.equals(SendTransactionTask.API.html)) { + Logger.debug("json", + "Declining using JSON API for /accounts with configured legacy API version"); + return null; + } + else { + return retrieveAccountListForVersion(apiVersion); + } + } + private List retrieveAccountListAnyVersion() + throws HTTPException, ApiNotSupportedException { + for (SendTransactionTask.API ver : SendTransactionTask.API.allVersions) { + try { + return retrieveAccountListForVersion(ver); + } + catch (Exception e) { + Logger.debug("json", + String.format(Locale.US, "Error during account list retrieval using API %s", + ver.getDescription())); + } + + throw new ApiNotSupportedException(); + } + + throw new RuntimeException("This should never be reached"); + } + private List retrieveAccountListForVersion(SendTransactionTask.API version) + throws IOException, HTTPException { HttpURLConnection http = NetworkUtil.prepareConnection(profile, "accounts"); http.setAllowUserInteraction(false); switch (http.getResponseCode()) { case 200: break; case 404: - return false; + return null; default: throw new HTTPException(http.getResponseCode(), http.getResponseMessage()); } @@ -388,64 +433,23 @@ public class RetrieveTransactionsTask ArrayList list = new ArrayList<>(); HashMap map = new HashMap<>(); HashMap currentMap = new HashMap<>(); - for (LedgerAccount acc : Objects.requireNonNull(profile.getAllAccounts())) + for (LedgerAccount acc : prevAccounts) currentMap.put(acc.getName(), acc); + throwIfCancelled(); try (InputStream resp = http.getInputStream()) { + throwIfCancelled(); if (http.getResponseCode() != 200) throw new IOException(String.format("HTTP error %d", http.getResponseCode())); - AccountListParser parser = new AccountListParser(resp); + AccountListParser parser = AccountListParser.forApiVersion(version, resp); expectedPostingsCount = 0; while (true) { throwIfCancelled(); - ParsedLedgerAccount parsedAccount = parser.nextAccount(); - if (parsedAccount == null) { + LedgerAccount acc = parser.nextAccount(this, map); + if (acc == null) break; - } - expectedPostingsCount += parsedAccount.getAnumpostings(); - final String accName = parsedAccount.getAname(); - LedgerAccount acc = map.get(accName); - if (acc != null) - throw new RuntimeException( - String.format("Account '%s' already present", acc.getName())); - String parentName = LedgerAccount.extractParentName(accName); - ArrayList createdParents = new ArrayList<>(); - LedgerAccount parent; - if (parentName == null) { - parent = null; - } - else { - parent = ensureAccountExists(parentName, map, createdParents); - parent.setHasSubAccounts(true); - } - acc = new LedgerAccount(profile, accName, parent); list.add(acc); - map.put(accName, acc); - - String lastCurrency = null; - float lastCurrencyAmount = 0; - for (ParsedBalance b : parsedAccount.getAibalance()) { - throwIfCancelled(); - final String currency = b.getAcommodity(); - final float amount = b.getAquantity() - .asFloat(); - if (currency.equals(lastCurrency)) { - lastCurrencyAmount += amount; - } - else { - if (lastCurrency != null) { - acc.addAmount(lastCurrencyAmount, lastCurrency); - } - lastCurrency = currency; - lastCurrencyAmount = amount; - } - } - if (lastCurrency != null) { - acc.addAmount(lastCurrencyAmount, lastCurrency); - } - for (LedgerAccount p : createdParents) - acc.propagateAmountsTo(p); } throwIfCancelled(); } @@ -459,12 +463,44 @@ public class RetrieveTransactionsTask } } - profile.setAndStoreAccountListFromWeb(list); - return true; + return list; + } + private List retrieveTransactionList() + throws ParseException, HTTPException, IOException, ApiNotSupportedException { + final SendTransactionTask.API apiVersion = profile.getApiVersion(); + if (apiVersion.equals(SendTransactionTask.API.auto)) { + return retrieveTransactionListAnyVersion(); + } + else if (apiVersion.equals(SendTransactionTask.API.html)) { + Logger.debug("json", + "Declining using JSON API for /accounts with configured legacy API version"); + return null; + } + else { + return retrieveTransactionListForVersion(apiVersion); + } + + } + private List retrieveTransactionListAnyVersion() + throws ApiNotSupportedException { + for (SendTransactionTask.API ver : SendTransactionTask.API.allVersions) { + try { + return retrieveTransactionListForVersion(ver); + } + catch (Exception | HTTPException e) { + Logger.debug("json", + String.format(Locale.US, "Error during account list retrieval using API %s", + ver.getDescription())); + } + + throw new ApiNotSupportedException(); + } + + throw new RuntimeException("This should never be reached"); } - private boolean retrieveTransactionList() throws IOException, ParseException, HTTPException { + private List retrieveTransactionListForVersion( + SendTransactionTask.API apiVersion) throws IOException, ParseException, HTTPException { Progress progress = new Progress(); - int maxTransactionId = Data.transactions.size(); progress.setTotal(expectedPostingsCount); HttpURLConnection http = NetworkUtil.prepareConnection(profile, "transactions"); @@ -474,74 +510,115 @@ public class RetrieveTransactionsTask case 200: break; case 404: - return false; + return null; default: throw new HTTPException(http.getResponseCode(), http.getResponseMessage()); } + ArrayList trList = new ArrayList<>(); try (InputStream resp = http.getInputStream()) { throwIfCancelled(); - ArrayList trList = new ArrayList<>(); - TransactionListParser parser = new TransactionListParser(resp); + TransactionListParser parser = TransactionListParser.forApiVersion(apiVersion, resp); int processedPostings = 0; while (true) { throwIfCancelled(); - ParsedLedgerTransaction parsedTransaction = parser.nextTransaction(); + LedgerTransaction transaction = parser.nextTransaction(); throwIfCancelled(); - if (parsedTransaction == null) + if (transaction == null) break; - LedgerTransaction transaction = parsedTransaction.asLedgerTransaction(); trList.add(transaction); progress.setProgress(processedPostings += transaction.getAccounts() .size()); +// Logger.debug("trParser", +// String.format(Locale.US, "Parsed transaction %d - %s", transaction +// .getId(), +// transaction.getDescription())); +// for (LedgerTransactionAccount acc : transaction.getAccounts()) { +// Logger.debug("trParser", +// String.format(Locale.US, " %s", acc.getAccountName())); +// } publishProgress(progress); } throwIfCancelled(); - profile.setAndStoreTransactionList(trList); } - return true; + // json interface returns transactions if file order and the rest of the machinery + // expects them in reverse chronological order + Collections.sort(trList, (o1, o2) -> { + int res = o2.getDate() + .compareTo(o1.getDate()); + if (res != 0) + return res; + return Integer.compare(o2.getId(), o1.getId()); + }); + return trList; } @SuppressLint("DefaultLocale") @Override - protected String doInBackground(Void... params) { + protected Result doInBackground(Void... params) { Data.backgroundTaskStarted(); + List accounts; + List transactions; try { - if (!retrieveAccountList() || !retrieveTransactionList()) - return retrieveTransactionListLegacy(); - return null; + accounts = retrieveAccountList(); + // accounts is null in API-version auto-detection and means + // requesting 'html' API version via the JSON classes + // this can't work, and the null results in the legacy code below + // being called + if (accounts == null) + transactions = null; + else + transactions = retrieveTransactionList(); + + if (accounts == null || transactions == null) { + accounts = new ArrayList<>(); + transactions = new ArrayList<>(); + retrieveTransactionListLegacy(accounts, transactions); + } + mainModel.setAndStoreAccountAndTransactionListFromWeb(accounts, transactions); + + return new Result(accounts, transactions); } catch (MalformedURLException e) { e.printStackTrace(); - return "Invalid server URL"; + return new Result("Invalid server URL"); } catch (HTTPException e) { e.printStackTrace(); - return String.format("HTTP error %d: %s", e.getResponseCode(), e.getResponseMessage()); + return new Result(String.format("HTTP error %d: %s", e.getResponseCode(), + e.getResponseMessage())); } catch (IOException e) { e.printStackTrace(); - return e.getLocalizedMessage(); + return new Result(e.getLocalizedMessage()); + } + catch (RuntimeJsonMappingException e) { + e.printStackTrace(); + return new Result(Result.ERR_JSON_PARSER_ERROR); } catch (ParseException e) { e.printStackTrace(); - return "Network error"; + return new Result("Network error"); } catch (OperationCanceledException e) { e.printStackTrace(); - return "Operation cancelled"; + return new Result("Operation cancelled"); + } + catch (ApiNotSupportedException e) { + e.printStackTrace(); + return new Result("Server version not supported"); } finally { Data.backgroundTaskFinished(); } } - private void throwIfCancelled() { + public void throwIfCancelled() { if (isCancelled()) throw new OperationCanceledException(null); } @@ -624,4 +701,18 @@ public class RetrieveTransactionsTask super(message); } } + + public static class Result { + public static String ERR_JSON_PARSER_ERROR = "err_json_parser"; + public String error; + public List accounts; + public List transactions; + Result(String error) { + this.error = error; + } + Result(List accounts, List transactions) { + this.accounts = accounts; + this.transactions = transactions; + } + } }