added first views of rest api, added config and misc files

Author: mimmon

README.md

@@ -52,14 +52,14 @@ That's all folks.
 
 * INIT: crawl through and index whole site - i.e. we will get url for each order
   This function will be handy if we have to start from scratch
-* parse orders so that we know the customer, the price and discount info + shipping details
+* _**parse orders so that we know the customer, the price and discount info + shipping details**_
 * add argument parser so that the program can be used from command line
 
 ### DB
 
 * _**integration with db - sqlite3 would be enough (using peewee)**_
 * _**create relevant models and convenience methods for easy data manipulation**_
-* store and use relevant data for faster data fetching
+* _**store and use relevant data for faster data fetching**_
 * allow updates on records, allow marking finished to deny updates if impossible
 
 
@@ -72,7 +72,7 @@ That's all folks.
 ### Cron jobs
 
 * must be available through PhantomJS or other driver not requiring GUI **!** 
-* allow regular checks for new orders
+* allow regular checks for new orders (require recording the last updated order)
 * automatic evaluation if user should get voucher
 * auto create voucher and send to user
 
@@ -81,10 +81,32 @@ That's all folks.
 
 * get voucher status
 * _create voucher_
-* use voucher in brick shop
-* convert points from brick shop to voucher
+* use voucher in brick shop (=deactivate on in shoptet)
+* convert points from brick shop to voucher 
 
 
 ### Client interface
 
-* server based api (flask rest?) to access db from third party apps (django: verne?)
+* server based api (flask rest?) to access db from third party apps (django: verne?)
+
+
+
+### SHOPTET API
+
+fetch - get from url and save to db (if save=True), return dictionary
+get - get from db (and update if fetch=True), return object
+
+`fetch_first_order()`
+
+`fetch_next_order(order=None)`
+
+`fetch_order(id=?, shop_id=?, url=?)`
+
+`get_last_added_order()`
+
+`fetch_next_link(order=None)` - open order in browser and get url of next order, 
+        if order is None, use the last added order, if none added, use the very first
+
+`fetch_close_date(order)`: open in browser, click on history and update activity status/close date
+
+logging - create order, update order

__init__.py

@@ -1,3 +1,3 @@
-from shoptet_api import models
-from shoptet_api import utils
-from shoptet_api import shoptet
+from shoptet_api import (config, models, app, auth, models, utils,
+                         shoptet, api, serializer, views
+                         )

admin.py

@@ -0,0 +1,33 @@
+import datetime
+from flask import request, redirect
+
+from flask_peewee.admin import Admin, ModelAdmin, AdminPanel
+from flask_peewee.filters import QueryFilter
+
+from shoptet_api.app import app, db
+from shoptet_api.auth import authentification
+from shoptet_api.models import User, Order, Log, Voucher, Shop, SysUser
+
+
+admin = Admin(app, authentification, branding='Example Site')
+
+
+class UserAdmin(ModelAdmin):
+    columns = ('email', 'name', 'last_name',)
+    # foreign_key_lookups = {'user': 'email'}
+    # filter_fields = ('user', 'content', 'pub_date', 'user__username')
+
+
+class OrderAdmin(ModelAdmin):
+    columns = ('user_id', 'order_num', 'open_date', 'close_date', 'total_price')
+    # exclude = ('created_date',)
+
+
+class LogAdmin(ModelAdmin):
+    columns = ('log_time', 'event', 'model', 'record', 'user_id', 'details')
+
+
+authentification.register_admin(admin)
+admin.register(User, UserAdmin)
+admin.register(Order, OrderAdmin)
+admin.register(Log, LogAdmin)

api.py

@@ -0,0 +1,48 @@
+from flask_peewee.rest import RestAPI, RestResource, UserAuthentication, AdminAuthentication, RestrictOwnerResource
+
+from shoptet_api.app import app
+from shoptet_api.auth import authentification
+from shoptet_api.models import User, Order, OrderLine, Voucher, Log, Shop
+
+
+user_auth = UserAuthentication(authentification)
+admin_auth = AdminAuthentication(authentification)
+
+# instantiate our api wrapper
+api = RestAPI(app, default_auth=user_auth)
+
+
+class UserResource(RestResource):
+    # exclude = ('password', 'email',)
+    pass
+
+class OrderResource(RestResource):
+    # owner_field = 'user'
+    include_resources = {'user_id': UserResource}
+
+
+class OrderLineResource(RestResource):
+    include_resources = {'order_id': OrderResource}
+
+
+class LogResource(RestResource):
+    pass
+    # include_resources = {
+    #     'from_user': UserResource,
+    #     'to_user': UserResource,
+    # }
+    # paginate_by = None
+
+class ShopResource(RestResource):
+    pass
+
+class VoucherResource(RestResource):
+    pass
+
+# register our models so they are exposed via /api/<model>/
+api.register(User, UserResource, auth=admin_auth)
+api.register(Order, OrderResource)
+api.register(OrderLine, OrderLineResource)
+api.register(Log, LogResource)
+api.register(Voucher, VoucherResource)
+api.register(Shop, ShopResource)

app.py

@@ -0,0 +1,23 @@
+from flask import Flask
+
+# flask-peewee bindings
+from flask_peewee.db import Database
+from peewee import SqliteDatabase
+
+
+app = Flask(__name__)
+app.config.from_object('config.Configuration')
+
+# db = Database(app)
+db = SqliteDatabase('shoptet.db')
+
+# from shoptet_api.models import SysUser, User, Order, OrderLine, Log, Voucher, Shop
+#
+# def create_tables():
+#     SysUser.create_table()
+#     User.create_table()
+#     Order.create_table()
+#     OrderLine.create_table()
+#     Log.create_table()
+#     Voucher.create_table()
+#     Shop.create_table()

auth.py

@@ -0,0 +1,7 @@
+from flask_peewee.auth import Auth
+
+from shoptet_api.app import app, db
+from shoptet_api.models import SysUser
+
+
+authentification = Auth(app, db, user_model=SysUser)

config.py

@@ -0,0 +1,8 @@
+class Configuration(object):
+    DATABASE = {
+        'name': 'shoptet.db',
+        'engine': 'peewee.SqliteDatabase',
+        'check_same_thread': False,
+    }
+    DEBUG = True
+    SECRET_KEY = 'replace-this'

main.py

@@ -0,0 +1,14 @@
+from shoptet_api.app import app, db
+
+from shoptet_api.auth import *
+from shoptet_api.admin import admin
+from shoptet_api.api import api
+from shoptet_api.models import *
+from shoptet_api.views import *
+
+admin.setup()
+api.setup()
+
+
+if __name__ == '__main__':
+    app.run()

models.py

@@ -3,10 +3,13 @@
 import random
 import re
 import string
+import uuid
 
 from peewee import *
+from flask_peewee.utils import get_dictionary_from_model
+from shoptet_api.app import db
 
-db = SqliteDatabase('shoptet.db')
+# db = SqliteDatabase('shoptet.db')
 
 
 # TODO make mapping from shoptet to choices (regex?)
@@ -43,14 +46,51 @@ class DBModel(Model):
     class Meta:
         database = db
 
+    date_format = '%Y-%m-%d'
+    time_format = '%H:%M:%S'
+    datetime_format = ' '.join([date_format, time_format])
+
     create_date = DateTimeField(default=datetime.datetime.now)
     write_date = DateTimeField(default=datetime.datetime.now)
 
+    def convert_value(self, value):
+        if isinstance(value, datetime.datetime):
+            return value.strftime(self.datetime_format)
+        elif isinstance(value, datetime.date):
+            return value.strftime(self.date_format)
+        elif isinstance(value, datetime.time):
+            return value.strftime(self.time_format)
+        elif isinstance(value, Model):
+            return value._pk
+        elif isinstance(value, (uuid.UUID, Decimal)):
+            return str(value)
+        else:
+            return value
+
+    def clean_data(self, data):
+        for key, value in data.items():
+            if isinstance(value, dict):
+                self.clean_data(value)
+            elif isinstance(value, (list, tuple)):
+                data[key] = map(self.clean_data, value)
+            else:
+                data[key] = self.convert_value(value)
+        return data
+
     def save(self, *args, **kwargs):
         _now = datetime.datetime.now()
         self.__data__.update({'write_date': _now})
         return super().save(*args, **kwargs)
 
+    def serialize(self, fields=None, exclude=None):
+        data = get_dictionary_from_model(self, fields, exclude)
+        return self.clean_data(data)
+
+    @property
+    def serialized(self):
+        # returns all fields
+        return self.serialize()
+
 
 class SysUser(DBModel):
     username = CharField()
@@ -127,7 +167,7 @@ class Voucher(DBModel):
     amount = DecimalField(null=True)
     valid_from = DateField(null=True)
     valid_to = DateField(null=True)
-    user_id = ForeignKeyField(User, backref='orders')
+    user_id = ForeignKeyField(User, backref='vouchers')
 
 
 class Log(DBModel):

serializer.py

@@ -0,0 +1,48 @@
+import datetime
+import sys
+import uuid
+
+from peewee import Model
+from flask_peewee.utils import get_dictionary_from_model, get_model_from_dictionary
+
+
+class Serializer(object):
+    date_format = '%Y-%m-%d'
+    time_format = '%H:%M:%S'
+    datetime_format = ' '.join([date_format, time_format])
+
+    def convert_value(self, value):
+        if isinstance(value, datetime.datetime):
+            return value.strftime(self.datetime_format)
+        elif isinstance(value, datetime.date):
+            return value.strftime(self.date_format)
+        elif isinstance(value, datetime.time):
+            return value.strftime(self.time_format)
+        elif isinstance(value, Model):
+            return value._pk
+        elif isinstance(value, uuid.UUID):
+            return str(value)
+        else:
+            return value
+
+    def clean_data(self, data):
+        for key, value in data.items():
+            if isinstance(value, dict):
+                self.clean_data(value)
+            elif isinstance(value, (list, tuple)):
+                data[key] = map(self.clean_data, value)
+            else:
+                data[key] = self.convert_value(value)
+        return data
+
+    def serialize_object(self, obj, fields=None, exclude=None):
+        data = get_dictionary_from_model(obj, fields, exclude)
+        return self.clean_data(data)
+
+    def serialize_list(self, lst, fields=None, exclude=None):
+        return [self.clean_data(get_dictionary_from_model(obj, fields, exclude)) for obj in lst]
+
+
+class Deserializer(object):
+    def deserialize_object(self, model, data):
+        return get_model_from_dictionary(model, data)

shoptet.py

@@ -171,6 +171,7 @@ def read_order_from_url(self, url):
         # this is to ensure we can get those independently from sheer url
         r = re.search(r'\?id=(?P<order_id>\d+)', url)
         order_details['shop_order_id'] = r.group('order_id') if r else None
+        # todo handle last order!
         order_details['order_num'] = soup.h1.strong.text
         order_details['url'] = url
         order_details['next_url'] = self.get_next_url_from_soup(soup)
@@ -245,7 +246,11 @@ def fetch_order_from_url(self, url, update=True):
             _logger.warning('No url for order.')
             return None
 
-        order_details = self.read_order_from_url(url)
+        try:
+            order_details = self.read_order_from_url(url)
+        except AttributeError:  # reads from empty order site, does not find ceratin element
+            return None
+
         order = save_order(order_details, update=update)
 
         # make log

utils.py

@@ -1,6 +1,7 @@
 from decimal import Decimal
 import logging
 import re
+from flask import Response, jsonify
 from peewee import *
 # from peewee import Expression  # the building block for expressions
 
@@ -253,3 +254,21 @@ def get_orderlines_from_soup(soup):
             'total_vat_including': p_total_vat_including,
         })
     return orderlines
+
+
+def make_response(data, status=None, mimetype=None):
+    if status is None:
+        status = 200
+    if mimetype is None:
+        mimetype = 'application/json'
+    return Response(data, status=status, mimetype=mimetype)
+
+
+def isdict(x):
+    return isinstance(x, dict)
+
+
+def data_to_response(data):
+    res = jsonify(**data) if isdict(data) else jsonify(data)
+    res.status_code = 200
+    return res