[GNUnet-SVN] [taler-backoffice] branch master updated (3743b44 -> b10a052)

[gnunet]

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

marcello pushed a change to branch master
in repository backoffice.

    from 3743b44  transitioning towards talerbackoffice
     new e9e2371  adapting setup.py
     new b10a052  test GET "/" is 200 OK

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 Makefile.in                              |   4 +
 setup.py                                 |  17 ++--
 talerbackoffice/backoffice/backoffice.py | 161 +------------------------------
 talerbackoffice/tests.py                 |  46 ++-------
 4 files changed, 24 insertions(+), 204 deletions(-)

diff --git a/Makefile.in b/Makefile.in
index b0562d1..f71c2a5 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -50,3 +50,7 @@ install: $(templates) install-data
 check:
        @export address@hidden@/talerbackoffice/tests.conf; \
         python3 setup.py test
+
+.PHONY: pyliny
+pylint:
+       @pylint talerbackoffice/
diff --git a/setup.py b/setup.py
index b7fd69d..b7cdbb6 100755
--- a/setup.py
+++ b/setup.py
@@ -1,9 +1,9 @@
 from setuptools import setup, find_packages
 
-setup(name='talerblog',
+setup(name='talerbackoffice',
       version='0.0',
-      description='Example blog site for GNU Taler',
-      url='git://taler.net/blog',
+      description='Back-office site for GNU Taler',
+      url='git://taler.net/backoffice',
       author='Marcello Stanisci',
       author_email='address@hidden',
       license='GPL',
@@ -14,18 +14,13 @@ setup(name='talerblog',
       package_data={
           '':[
               "blog/templates/*.html",
-              "blog/static/*.svg",
-              "blog/static/*.css",
-              "blog/static/*.js",
-              "blog/static/*.js.tar.gz",
               "blog/static/web-common/*.png",
               "blog/static/web-common/*.css",
               "blog/static/web-common/*.js",
               "blog/static/web-common/*.js.tar.gz",
-              "blog/static/web-common/*.html",
-              "blog/articles/*",
-              "blog/data/*"
+              "blog/static/web-common/*.html"
       ]
       },
-      scripts=['taler-merchant-blog'],
+      scripts=['taler-merchant-backoffice-blog',
+               'taler-merchant-backoffice-donations'],
       zip_safe=False)
diff --git a/talerbackoffice/backoffice/backoffice.py 
b/talerbackoffice/backoffice/backoffice.py
index 8a48883..f62c78b 100644
--- a/talerbackoffice/backoffice/backoffice.py
+++ b/talerbackoffice/backoffice/backoffice.py
@@ -20,18 +20,15 @@
 Implement URL handlers and payment logic for the blog merchant.
 """
 
-from urllib.parse import urljoin, quote, parse_qsl
+from urllib.parse import urljoin, parse_qsl
 import logging
 import os
 import base64
 import requests
 import flask
 from talerblog.talerconfig import TalerConfig
-from ..helpers import (make_url, \
-    expect_parameter, join_urlparts, \
+from ..helpers import (join_urlparts, \
     get_query_string, backend_error)
-from ..blog.content import (ARTICLES, \
-    get_article_file, get_image_file)
 
 LOGGER = logging.getLogger(__name__)
 
@@ -43,15 +40,12 @@ app.secret_key = 
base64.b64encode(os.urandom(64)).decode('utf-8')
 
 TC = TalerConfig.from_env()
 
-BACKEND_URL = TC["frontends"]["backend"].value_string(required=True)
+BACKEND_URL = os.environ.get("BACKOFFICE_MERCHANT_BACKEND")
+INSTANCES = os.environ.get("BACKOFFICE_INSTANCES") # colon-separated list
 CURRENCY = TC["taler"]["currency"].value_string(required=True)
-INSTANCE = TC["blog"]["instance"].value_string(required=True)
-
-ARTICLE_AMOUNT = dict(value=0, fraction=50000000, currency=CURRENCY)
 
 app.config.from_object(__name__)
 
-
 @app.context_processor
 def utility_processor():
     def url(my_url):
@@ -63,158 +57,13 @@ def utility_processor():
 
 @app.route("/")
 def index():
-    return flask.render_template("templates/index.html",
-                                 merchant_currency=CURRENCY,
-                                 articles=ARTICLES.values())
+    return flask.render_template("templates/backoffice.html")
 
 
 @app.route("/javascript")
 def javascript_licensing():
     return flask.render_template("templates/javascript.html")
 
-# Triggers the refund by serving /refund/test?order_id=XY.
-# Will be triggered by a "refund button".
address@hidden("/refund", methods=["GET", "POST"])
-def refund():
-    if flask.request.method == "POST":
-        payed_articles = flask.session["payed_articles"] = 
flask.session.get("payed_articles", {})
-        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)
-        order_id = payed_articles.get(article_name)
-        if not order_id:
-            return flask.jsonify(dict(error="Aborting refund: article not 
payed")), 401
-        resp = requests.post(urljoin(BACKEND_URL, "refund"),
-                             json=dict(order_id=order_id,
-                                       refund=ARTICLE_AMOUNT,
-                                       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))
-        return response, 402
-
-    else:
-        order_id = expect_parameter("order_id", False)
-        if not order_id:
-            LOGGER.error("Missing parameter 'order_id'")
-            return flask.jsonify(dict(error="Missing parameter 'order_id'")), 
400
-        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
-
-
address@hidden("/generate-contract", methods=["GET"])
-def generate_contract():
-    article_name = expect_parameter("article_name")
-    pretty_name = article_name.replace("_", " ")
-    order = dict(
-        summary=pretty_name,
-        nonce=flask.request.args.get("nonce"),
-        amount=ARTICLE_AMOUNT,
-        max_fee=dict(value=1, fraction=0, currency=CURRENCY),
-        products=[
-            dict(
-                description="Essay: " + pretty_name,
-                quantity=1,
-                product_id=0,
-                price=ARTICLE_AMOUNT,
-            ),
-        ],
-        fulfillment_url=make_url("/essay/" + quote(article_name)),
-        pay_url=make_url("/pay"),
-        merchant=dict(
-            instance=INSTANCE,
-            address="nowhere",
-            name="Kudos Inc.",
-            jurisdiction="none",
-        ),
-        extra=dict(article_name=article_name),
-    )
-    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)
-
-
address@hidden("/cc-payment/<name>")
-def cc_payment(name):
-    return flask.render_template("templates/cc-payment.html",
-                                 article_name=name)
-
-
address@hidden("/essay/<name>")
address@hidden("/essay/<name>/data/<data>")
-def article(name, data=None):
-    LOGGER.info("processing %s" % name)
-    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 name in payed_articles:
-        articleInfo = ARTICLES[name]
-        if articleInfo is None:
-            flask.abort(500)
-        if data is not None:
-            if data in articleInfo.extra_files:
-                return flask.send_file(get_image_file(data))
-            return "permission denied", 400
-        return flask.render_template("templates/article_frame.html",
-                                     
article_file=get_article_file(articleInfo),
-                                     article_name=name)
-
-    contract_url = make_url("/generate-contract",
-                            ("article_name", name))
-    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))
-    return response
-
-
address@hidden("/pay", methods=["POST"])
-def pay():
-    deposit_permission = flask.request.get_json()
-    if deposit_permission is None:
-        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", {})
-
-    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)
-        payed_articles[article_name] = "__refunded"
-        return flask.jsonify(resp.json()), 200
-    except IndexError:
-        pass
-
-    if not deposit_permission["order_id"]:
-        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)
-        payed_articles[article_name] = deposit_permission["order_id"]
-    return flask.jsonify(resp.json()), 200
-
-
 @app.route("/history")
 def history():
     qs = get_query_string().decode("utf-8")
diff --git a/talerbackoffice/tests.py b/talerbackoffice/tests.py
index 050d852..6fa15cb 100644
--- a/talerbackoffice/tests.py
+++ b/talerbackoffice/tests.py
@@ -2,48 +2,20 @@
 
 import unittest
 from mock import patch, MagicMock
-from talerblog.blog import blog
-from talerblog.talerconfig import TalerConfig
+from talerbackoffice.backoffice import backoffice
+from talerbackoffice.talerconfig import TalerConfig
 
 TC = TalerConfig.from_env()
 CURRENCY = TC["taler"]["currency"].value_string(required=True)
 
-class BlogTestCase(unittest.TestCase):
+class BackofficeTestCase(unittest.TestCase):
     def setUp(self):
-        blog.app.testing = True
-        self.app = blog.app.test_client()
-
-    @patch("requests.post")
-    def test_proposal_creation(self, mocked_post):
-        ret_post = MagicMock()
-        ret_post.status_code = 200
-        ret_post.json.return_value = {}
-        mocked_post.return_value = ret_post
-        self.app.get("/generate-contract?nonce=55&article_name=Check_Me")
-        mocked_post.assert_called_with(
-            "http://backend.test.taler.net/proposal";,
-            json={
-                "order": {
-                    "summary": "Check Me",
-                    "nonce": "55",
-                    "amount": blog.ARTICLE_AMOUNT,
-                    "max_fee": {
-                        "value": 1,
-                        "fraction": 0,
-                        "currency": CURRENCY},
-                    "products": [{
-                        "description": "Essay: Check Me",
-                        "quantity": 1,
-                        "product_id": 0,
-                        "price": blog.ARTICLE_AMOUNT}],
-                    "fulfillment_url": "http://localhost/essay/Check_Me";,
-                    "pay_url": "http://localhost/pay";,
-                    "merchant": {
-                        "instance": 
TC["blog"]["instance"].value_string(required=True),
-                        "address": "nowhere",
-                        "name": "Kudos Inc.",
-                        "jurisdiction": "none"},
-                    "extra": {"article_name": "Check_Me"}}})
+        backoffice.app.testing = True
+        self.app = backoffice.app.test_client()
+    
+    def test_responsive(self):
+        response = self.app.get("/")
+        self.assertEqual(response.status_code, 200)
 
 if __name__ == "__main__":
     unittest.main()

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