[GNUnet-SVN] [taler-bank] branch master updated: returning error codes

[gnunet]

This is an automated email from the git hooks/post-receive script.

marcello pushed a commit to branch master
in repository bank.

The following commit(s) were added to refs/heads/master by this push:
     new 071f971  returning error codes
071f971 is described below

commit 071f9712fa85ff2ee31f651456794d899bce3529
Author: Marcello Stanisci <address@hidden>
AuthorDate: Fri Dec 15 16:13:10 2017 +0100

    returning error codes
---
 talerbank/app/schemas.py |   2 +-
 talerbank/app/views.py   | 121 ++++++++++++++++++++++++++++++++++-------------
 talerbank/settings.py    |  14 ++++++
 3 files changed, 102 insertions(+), 35 deletions(-)

diff --git a/talerbank/app/schemas.py b/talerbank/app/schemas.py
index d65b082..26d32ef 100644
--- a/talerbank/app/schemas.py
+++ b/talerbank/app/schemas.py
@@ -135,7 +135,7 @@ def validate_pintan_types(validator, fieldname, value, 
format_option):
             validate_wiredetails(data)
     except Exception:
         raise validictory.FieldValidationError(
-            "Missing/malformed '%s'" % fieldname, fieldname, value)
+            "Malformed '%s'" % fieldname, fieldname, value)
 
 def validate_pin_tan_args(pin_tan_args):
     format_dict = {
diff --git a/talerbank/app/views.py b/talerbank/app/views.py
index d65d38a..33cf870 100644
--- a/talerbank/app/views.py
+++ b/talerbank/app/views.py
@@ -199,8 +199,16 @@ def pin_tan_question(request):
         # Currency is not checked, as any mismatches will be
         # detected afterwards
     except (FVE, RFVE) as err:
-        LOGGER.error("invalid '%s'" % err.fieldname)
-        return HRBR("invalid '%s'" % err.fieldname)
+        ec = settings.TALER_EC_PARAMETER_MALFORMED
+        if isinstance(err, RFVE):
+          ec = settings.TALER_EC_PARAMETER_MISSING
+        LOGGER.error(
+            "missing/malformed parameter '%s'" % err.fieldname)
+        return JsonResponse(
+            {"error": "missing parameter '%s'" % err.fieldname,
+             "ec": ec},
+            status=400)
+
     user_account = BankAccount.objects.get(user=request.user)
     wd = json.loads(request.GET["exchange_wire_details"])
     request.session["exchange_account_number"] = \
@@ -255,7 +263,8 @@ def pin_tan_verify(request):
 
     except BankAccount.DoesNotExist as exc:
         return JsonResponse(
-            {"error": "That exchange is unknown to this bank"},
+            {"error": "That exchange is unknown to this bank",
+             "ec": settings.TALER_EC_BANK_ACCOUNT_NOT_FOUND},
             status=404)
     except WireTransferException as exc:
         return exc.response
@@ -283,8 +292,9 @@ def register(request):
         return render(request, "register.html",
                       dict(not_available=True))
     with transaction.atomic():
-        user = User.objects.create_user(username=username,
-                                        password=password)
+        user = User.objects.create_user(
+            username=username,
+            password=password)
         user_account = BankAccount(user=user)
         user_account.save()
     bank_internal_account = BankAccount.objects.get(account_no=1)
@@ -343,10 +353,11 @@ def serve_public_accounts(request, name=None):
         name = settings.TALER_PREDEFINED_ACCOUNTS[0]
     try:
         user = User.objects.get(username=name)
-        account = BankAccount.objects.get(user=user, is_public=True)
-    except (User.DoesNotExist, BankAccount.DoesNotExist):
-        return HttpResponse("account '{}' not found".format(name),
-                            status=404)
+    except User.DoesNotExist:
+        return HttpResponse(
+            {"error": "account '%s' not found" % name,
+             "ec": settings.TALER_EC_BANK_UNKNOWN_ACCOUNT},
+             status=404)
     public_accounts = BankAccount.objects.filter(is_public=True)
     history = extract_history(account)
     context = dict(
@@ -364,8 +375,15 @@ def login_via_headers(view_func):
         user_account = auth_and_login(request)
         if not user_account:
             LOGGER.error("authentication failed")
-            return JsonResponse(dict(error="authentication failed"),
-                                status=401)
+            switch = {
+            "serve_history":
+                settings.TALER_EC_BANK_HISTORY_NOT_AUTHORIZED}
+            ec = switch.get(view_func.__name,
+                            settings.TALER_EC_BANK_NOT_AUTHORIZED)
+            return JsonResponse(
+                {"error": "authentication failed",
+                 "ec": ec},
+                status=401)
         return view_func(request, user_account, *args, **kwargs)
     return wraps(view_func)(_decorator)
 
@@ -380,10 +398,14 @@ def serve_history(request, user_account):
         # Note, this does check the currency.
         validate_history_request(request.GET.dict())
     except (FVE, RFVE) as exc:
+        ec = settings.TALER_EC_PARAMETER_MALFORMED
+        if isinstance(exc, RFVE):
+          ec = settings.TALER_EC_PARAMETER_MISSING
         LOGGER.error("/history, bad '%s' arg" % exc.fieldname)
-        return JsonResponse({"error": "invalid '%s'" \
-                                      % exc.fieldname},
-                            status=400)
+        return JsonResponse(
+            {"error": "invalid '%s'" % exc.fieldname,
+             "ec": ec},
+            status=400)
 
     # delta
     parsed_delta = re.search(r"([\+-])?([0-9]+)",
@@ -461,11 +483,13 @@ def auth_and_login(request):
     if not username or not password:
         LOGGER.error("user or password not given")
         return False
-    return django.contrib.auth.authenticate(username=username,
-                                            password=password)
+    return django.contrib.auth.authenticate(
+        username=username,
+        password=password)
 
 @login_required
 def strike(request):
+    # FIXME: to be soon removed
     trans = BankTransaction.objects.get(id=request.GET["row_id"])
     trans.cancelled = True
     trans.save()
@@ -480,21 +504,28 @@ def reject(request, user_account):
     try:
         validate_reject_request(data)
     except (FVE, RFVE) as exc:
+        ec = settings.TALER_EC_PARAMETER_MALFORMED
+        if isinstance(err, RFVE):
+          ec = settings.TALER_EC_PARAMETER_MISSING
         LOGGER.error("invalid %s" % exc.fieldname)
         return JsonResponse(
-            {"error": "invalid '%s'" % exc.fieldname}, status=400)
+            {"error": "invalid '%s'" % exc.fieldname,
+             "ec": ec},
+            status=400)
     try:
         trans = BankTransaction.objects.get(id=data["row_id"])
     except BankTransaction.DoesNotExist:
         return JsonResponse(
-            {"error": "unknown transaction"}, status=404)
+            {"error": "unknown transaction",
+             "ec": settings.TALER_EC_BANK_REJECT_NOT_FOUND},
+            status=404)
     if trans.credit_account.account_no != \
             user_account.bankaccount.account_no:
         LOGGER.error("you can only reject a transaction where you"
                      " _got_ money")
         return JsonResponse(
-            {"error": "you can only reject a transaction where"
-                      " you _got_ money"},
+            {"error": "no rights to reject",
+             "ec": settings.TALER_EC_BANK_REJECT_NO_RIGHTS},
              status=401) # Unauthorized
     trans.cancelled = True
     trans.debit_account.amount.add(trans.amount)
@@ -519,9 +550,16 @@ def add_incoming(request, user_account):
         # Note, this does check the currency.
         validate_incoming_request(data)
     except (FVE, RFVE) as exc:
+        ec = settings.TALER_EC_PARAMETER_MALFORMED
+        if isinstance(exc, RFVE):
+          ec = settings.TALER_EC_PARAMETER_MISSING
+        LOGGER.error(
+            "missing/malformed parameter '%s'" % exc.fieldname)
         return JsonResponse(
-            {"error": "invalid '%s'" % exc.fieldname},
-             status=406 if exc.fieldname == "currency" else 400)
+            {"error": "missing parameter '%s'" % exc.fieldname,
+             "ec": ec},
+            status=406 if exc.fieldname == "currency" else 400)
+
     subject = "%s %s" % (data["subject"], data["exchange_url"])
     try:
         credit_account = BankAccount.objects.get(
@@ -532,9 +570,11 @@ def add_incoming(request, user_account):
                                subject)
     except BankAccount.DoesNotExist:
         return JsonResponse(
-            {"error": "credit_account (%d) not found" \
-                      % data["credit_account"]},
-                            status=404)
+            {"error":
+                 "credit_account (%d) not found" \
+                 % data["credit_account"],
+             "ec": settings.TALER_EC_BANK_UNKNOWN_ACCOUNT},
+            status=404)
     except WireTransferException as exc:
         return exc.response
     return JsonResponse(
@@ -547,10 +587,17 @@ def add_incoming(request, user_account):
 def withdraw_nojs(request):
 
     try:
-        amount = Amount.parse(request.POST.get("kudos_amount", ""))
+        amount = Amount.parse(
+            request.POST.get("kudos_amount", "not-given"))
     except BadFormatAmount:
-        LOGGER.error("Amount did not pass parsing")
-        return HRBR()
+        LOGGER.error("Amount ('%s') did not pass parsing" % amount)
+        ec = settings.TALER_EC_PARAMETER_MALFORMED
+        if amount == "not-given":
+            ec = settings.TALER_EC_PARAMETER_MISSING
+        return JsonResponse({
+            "error": "bad 'kudos_amount' parameter",
+            "ec": ec},
+            status=400)
 
     user_account = BankAccount.objects.get(user=request.user)
 
@@ -565,7 +612,8 @@ def withdraw_nojs(request):
         account_number=user_account.account_no
     ))
     if settings.TALER_SUGGESTED_EXCHANGE:
-        response["X-Taler-Suggested-Exchange"] = 
settings.TALER_SUGGESTED_EXCHANGE
+        response["X-Taler-Suggested-Exchange"] = \
+            settings.TALER_SUGGESTED_EXCHANGE
     return response
 
 class WireTransferException(Exception):
@@ -654,8 +702,10 @@ def wire_transfer(amount,
             credit_account,
             subject)
     except (CurrencyMismatch, BadFormatAmount) as exc:
-        err_cb(exc, JsonResponse({"error": "internal server error"},
-                                 status=500))
+        err_cb(exc, JsonResponse(
+            {"error": "internal server error",
+             "ec": settings.TALER_EC_INTERNAL_LOGIC_ERROR},
+             status=500))
     except DebtLimitExceededException as exc:
         if kwargs.get("request"):
             if kwargs.get("session_expand"):
@@ -664,9 +714,12 @@ def wire_transfer(amount,
             if kwargs["request"].request.path == "/pin/verify":
                 err_cb(exc, redirect("profile"))
         else:
-            err_cb(exc, JsonResponse({"error": "Unallowed debit"},
-                                     status=403))
+            err_cb(exc, JsonResponse(
+                {"error": "Unallowed debit",
+                 "ec": settings.TALER_EC_BANK_TRANSFER_DEBIT},
+                 status=403))
     except SameAccountException as exc:
         err_cb(exc, JsonResponse(
-            {"error": "sender account == receiver account"},
+            {"error": "sender account == receiver account",
+             "ec": settings.TALER_EC_BANK_TRANSFER_SAME_ACCOUNT},
             status=422))
diff --git a/talerbank/settings.py b/talerbank/settings.py
index bf16326..77e3c4f 100644
--- a/talerbank/settings.py
+++ b/talerbank/settings.py
@@ -198,3 +198,17 @@ TALER_EXPECTS_DONATIONS = [
     'Tor', 'GNUnet', 'Taler', 'FSF']
 TALER_SUGGESTED_EXCHANGE = TC.value_string(
     "bank", "suggested_exchange")
+
+TALER_EC_INTERNAL_LOGIC_ERROR = 1011
+TALER_EC_PARAMETER_MISSING = 1008
+TALER_EC_PARAMETER_MALFORMED = 1009
+TALER_EC_BANK_NOT_AUTHORIZED = 5000
+TALER_EC_BANK_UNKNOWN_ACCOUNT = 5001
+TALER_EC_BANK_TRANSFER_NOT_AUTHORIZED = 5100
+TALER_EC_BANK_TRANSFER_DEBIT = 5101
+TALER_EC_BANK_TRANSFER_SAME_ACCOUNT = 5102
+TALER_EC_BANK_HISTORY_NOT_AUTHORIZED = 5200
+TALER_EC_BANK_HISTORY_HTTP_FAILURE = 5201
+TALER_EC_BANK_REJECT_NOT_FOUND = 5300
+TALER_EC_BANK_REJECT_NOT_AUTHORIZED = 5301
+TALER_EC_BANK_REJECT_NO_RIGHTS = 5302

-- 
To stop receiving notification emails like this one, please contact
address@hidden