mostly linted

1 files changed, 80 insertions, 78 deletions

diff --git a/talerblog/blog/blog.py b/talerblog/blog/blog.py
index c42e9d4..101a968 100644
--- a/talerblog/blog/blog.py
+++ b/talerblog/blog/blog.py
@@ -20,37 +20,32 @@
 Implement URL handlers and payment logic for the blog merchant.
 """
 
-import flask
-from urllib.parse import urljoin, urlencode, quote, parse_qsl
-import requests
+from urllib.parse import urljoin, quote, parse_qsl
 import logging
 import os
 import base64
-import random
-import time
-import json
-import datetime
-from pprint import pprint
+import requests
+import flask
 from talerblog.talerconfig import TalerConfig
-from talerblog.helpers import (make_url,
-        expect_parameter, join_urlparts, get_query_string,
-        backend_error)
-from talerblog.blog.content import (articles,
-get_article_file, get_image_file)
+from talerblog.helpers import (make_url, \
+    expect_parameter, join_urlparts, \
+    get_query_string, backend_error)
+from talerblog.blog.content import (ARTICLES, \
+    get_article_file, get_image_file)
 
-logger = logging.getLogger(__name__)
+LOGGER = logging.getLogger(__name__)
 
-base_dir = os.path.dirname(os.path.abspath(__file__))
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
-app = flask.Flask(__name__, template_folder=base_dir)
+app = flask.Flask(__name__, template_folder=BASE_DIR)
 app.debug = True
 app.secret_key = base64.b64encode(os.urandom(64)).decode('utf-8')
 
-tc = TalerConfig.from_env()
+TC = TalerConfig.from_env()
 
-BACKEND_URL = tc["frontends"]["backend"].value_string(required=True)
-CURRENCY = tc["taler"]["currency"].value_string(required=True)
-INSTANCE = tc["blog"]["instance"].value_string(required=True)
+BACKEND_URL = TC["frontends"]["backend"].value_string(required=True)
+CURRENCY = TC["taler"]["currency"].value_string(required=True)
+INSTANCE = TC["blog"]["instance"].value_string(required=True)
 ARTICLE_AMOUNT = dict(value=1, fraction=0, currency=CURRENCY)
 
 app.config.from_object(__name__)
@@ -69,7 +64,7 @@ def utility_processor():
 def index():
     return flask.render_template("templates/index.html",
                                  merchant_currency=CURRENCY,
-                                 articles=articles.values())
+                                 articles=ARTICLES.values())
 
 
 @app.route("/javascript")
@@ -85,17 +80,17 @@ def refund():
         article_name = flask.request.form.get("article_name")
         if not article_name:
             return flask.jsonify(dict(error="No article_name found in form")), 400
-        logger.info("Looking for %s to refund" % article_name)
+        LOGGER.info("Looking for %s to refund" % article_name)
         order_id = payed_articles.get(article_name)
         if not order_id:
             return flask.jsonify(dict(error="Aborting refund: article not payed")), 401
-        r = requests.post(urljoin(BACKEND_URL, "refund"),
-                          json=dict(order_id=order_id,
-                                    refund=dict(value=1, fraction=0, currency=CURRENCY),
-                                    reason="Demo reimbursement",
-                                    instance=INSTANCE))
-        if 200 != r.status_code:
-            return backend_error(r)
+        resp = requests.post(urljoin(BACKEND_URL, "refund"),
+                             json=dict(order_id=order_id,
+                                       refund=dict(value=1, fraction=0, currency=CURRENCY),
+                                       reason="Demo reimbursement",
+                                       instance=INSTANCE))
+        if resp.status_code != 200:
+            return backend_error(resp)
         payed_articles[article_name] = "__refunded"
         response = flask.make_response()
         response.headers["X-Taler-Refund-Url"] = make_url("/refund", ("order_id", order_id))
@@ -104,13 +99,13 @@ def refund():
     else:
         order_id = expect_parameter("order_id", False)
         if not order_id:
-            logger.error("Missing parameter 'order_id'")
+            LOGGER.error("Missing parameter 'order_id'")
             return flask.jsonify(dict(error="Missing parameter 'order_id'")), 400
-        r = requests.get(urljoin(BACKEND_URL, "refund"), params=dict(order_id=order_id,
-                                                                     instance=INSTANCE))
-        if 200 != r.status_code:
-            return backend_error(r)
-        return flask.jsonify(r.json()), r.status_code
+        resp = requests.get(urljoin(BACKEND_URL, "refund"),
+                            params=dict(order_id=order_id, instance=INSTANCE))
+        if resp.status_code != 200:
+            return backend_error(resp)
+        return flask.jsonify(resp.json()), resp.status_code
 
 
 @app.route("/generate-contract", methods=["GET"])
@@ -140,10 +135,11 @@ def generate_contract():
         ),
         extra=dict(article_name=article_name),
     )
-    r = requests.post(urljoin(BACKEND_URL, "proposal"), json=dict(order=order))
-    if r.status_code != 200:
-        return backend_error(r)
-    proposal_resp = r.json()
+    resp = requests.post(urljoin(BACKEND_URL, "proposal"),
+                         json=dict(order=order))
+    if resp.status_code != 200:
+        return backend_error(resp)
+    proposal_resp = resp.json()
     return flask.jsonify(**proposal_resp)
 
 
@@ -155,34 +151,35 @@ def cc_payment(name):
 
 @app.route("/essay/<name>")
 @app.route("/essay/<name>/data/<data>")
-def article(name, data=None):
-    logger.info("processing %s" % name)
+def article(namex, data=None):
+    LOGGER.info("processing %s" % namex)
     payed_articles = flask.session.get("payed_articles", {})
 
-    if payed_articles.get(name, "") == "__refunded":
-        return flask.render_template("templates/article_refunded.html", article_name=name)
+    if payed_articles.get(namex, "") == "__refunded":
+        return flask.render_template("templates/article_refunded.html", article_name=namex)
 
-    if name in payed_articles:
-        article = articles[name]
-        if article is None:
+    if namex in payed_articles:
+        articlex = ARTICLES[namex]
+        if articlex is None:
             flask.abort(500)
         if data is not None:
-            if data in article.extra_files:
+            if data in articlex.extra_files:
                 return flask.send_file(get_image_file(data))
-            else:
-                return "permission denied", 400
+            return "permission denied", 400
         return flask.render_template("templates/article_frame.html",
-                                     article_file=get_article_file(article),
-                                     article_name=name)
+                                     article_file=get_article_file(articlex),
+                                     article_name=namex)
 
-    contract_url = make_url("/generate-contract", ("article_name",name))
-    response = flask.make_response(flask.render_template("templates/fallback.html"), 402)
+    contract_url = make_url("/generate-contract",
+                            ("article_name", namex))
+    response = flask.make_response(
+        flask.render_template("templates/fallback.html"), 402)
     response.headers["X-Taler-Contract-Url"] = contract_url
     response.headers["X-Taler-Contract-Query"] = "fulfillment_url"
     # Useless (?) header, as X-Taler-Contract-Url takes always (?) precedence
     # over X-Offer-Url.  This one might only be useful if the contract retrieval
     # goes wrong.
-    response.headers["X-Taler-Offer-Url"] = make_url("/essay/" + quote(name))
+    response.headers["X-Taler-Offer-Url"] = make_url("/essay/" + quote(namex))
     return response
 
 
@@ -190,36 +187,41 @@ def article(name, data=None):
 def pay():
     deposit_permission = flask.request.get_json()
     if deposit_permission is None:
-        e = flask.jsonify(error="no json in body"),
-        return e, 400
-    r = requests.post(urljoin(BACKEND_URL, "pay"), json=deposit_permission)
-    if 200 != r.status_code:
-        return backend_error(r)
-    proposal_data = r.json()["contract_terms"]
+        return flask.jsonify(error="no json in body"), 400
+    resp = requests.post(urljoin(BACKEND_URL, "pay"),
+                         json=deposit_permission)
+    if resp.status_code != 200:
+        return backend_error(resp)
+    proposal_data = resp.json()["contract_terms"]
     article_name = proposal_data["extra"]["article_name"]
     payed_articles = flask.session["payed_articles"] = flask.session.get("payed_articles", {})
-    if len(r.json()["refund_permissions"]) != 0:
+
+    try:
+        resp.json()["refund_permissions"].pop()
         # we had some refunds on the article purchase already!
-        logger.info("Article %s was refunded, before /pay" % article_name)
+        LOGGER.info("Article %s was refunded, before /pay" % article_name)
         payed_articles[article_name] = "__refunded"
-        return flask.jsonify(r.json()), 200
+        return flask.jsonify(resp.json()), 200
+    except IndexError:
+        pass
+
     if not deposit_permission["order_id"]:
-        logger.error("order_id missing from deposit_permission!")
+        LOGGER.error("order_id missing from deposit_permission!")
         return flask.jsonify(dict(error="internal error: ask for refund!")), 500
     if article_name not in payed_articles:
-        logger.info("Article %s goes in state" % article_name)
+        LOGGER.info("Article %s goes in state" % article_name)
         payed_articles[article_name] = deposit_permission["order_id"]
-    return flask.jsonify(r.json()), 200
+    return flask.jsonify(resp.json()), 200
 
 
 @app.route("/history")
 def history():
     qs = get_query_string().decode("utf-8")
     url = urljoin(BACKEND_URL, "history")
-    r = requests.get(url, params=dict(parse_qsl(qs)))
-    if 200 != r.status_code:
-        return backend_error(r)
-    return flask.jsonify(r.json()), r.status_code
+    resp = requests.get(url, params=dict(parse_qsl(qs)))
+    if resp.status_code != 200:
+        return backend_error(resp)
+    return flask.jsonify(resp.json()), resp.status_code
 
 
 @app.route("/backoffice")
@@ -232,17 +234,17 @@ def track():
 def track_transfer():
     qs = get_query_string().decode("utf-8")
     url = urljoin(BACKEND_URL, "track/transfer")
-    r = requests.get(url, params=dict(parse_qsl(qs)))
-    if 200 != r.status_code:
-        return backend_error(r)
-    return flask.jsonify(r.json()), r.status_code
+    resp = requests.get(url, params=dict(parse_qsl(qs)))
+    if resp.status_code != 200:
+        return backend_error(resp)
+    return flask.jsonify(resp.json()), resp.status_code
 
 
 @app.route("/track/order")
 def track_order():
     qs = get_query_string().decode("utf-8")
     url = urljoin(BACKEND_URL, "track/transaction")
-    r = requests.get(url, params=dict(parse_qsl(qs)))
-    if 200 != r.status_code:
-        return backend_error(r)
-    return flask.jsonify(r.json()), r.status_code
+    resp = requests.get(url, params=dict(parse_qsl(qs)))
+    if resp.status_code != 200:
+        return backend_error(resp)
+    return flask.jsonify(resp.json()), resp.status_code