init

Author: gaborvecsei

.gitignore

@@ -0,0 +1,2 @@
+.idea
+__pycache__

code/backend/__init__.py

@@ -0,0 +1,24 @@
+import os
+
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import scoped_session, sessionmaker
+
+user = os.environ['POSTGRES_USER']
+pwd = os.environ['POSTGRES_PASSWORD']
+db = os.environ['POSTGRES_DB']
+# Docker creates hostnames from the service names defined in docker-compose
+host = os.environ['DB_DOCKER_SERVICE_NAME']
+port = os.environ['DB_PORT']
+
+engine = create_engine("postgres://{0}:{1}@{2}:{3}/{4}".format(user, pwd, host, port, db))
+
+db_session = scoped_session(sessionmaker(autocommit=False,
+                                         autoflush=False,
+                                         bind=engine))
+Base = declarative_base()
+Base.query = db_session.query_property()
+
+
+def init_db():
+    Base.metadata.create_all(bind=engine)

code/backend/database/__init__.py

@@ -0,0 +1,33 @@
+from sqlalchemy import Column, Integer, String, BigInteger, ForeignKey, Boolean
+from sqlalchemy.orm import relationship
+from sqlalchemy.types import DateTime
+
+from database import db
+
+
+class ApiKey(db.Base):
+    __tablename__ = "api_key"
+
+    # Auto incrementing ID
+    id = Column(Integer, primary_key=True)
+    api_key = Column(String(256), unique=True)
+    date_created = Column(DateTime())
+    date_last_used = Column(DateTime())
+    active = Column(Boolean, default=True)
+
+
+class User(db.Base):
+    __tablename__ = "user"
+
+    # Auto incrementing ID
+    id = Column(Integer, primary_key=True)
+    first_name = Column(String(256))
+    last_name = Column(String(256))
+    email = Column(String(256), unique=True)
+    date_signed_up = Column(DateTime())
+    available_units = Column(BigInteger)
+    used_units = Column(BigInteger)
+
+    # Foreign Key
+    api_key_id = Column(Integer, ForeignKey(ApiKey.id))
+    api_key = relationship(ApiKey)

code/backend/database/db.py

@@ -0,0 +1,47 @@
+import os
+from binascii import hexlify
+from datetime import datetime
+
+from database import db_models, db
+
+
+def generate_api_key() -> str:
+    key = hexlify(os.urandom(16)).decode("utf-8")
+    return key
+
+
+def init_api_key_object(api_key: str = None) -> db_models.ApiKey:
+    if api_key is None:
+        api_key = generate_api_key()
+    new_api_key = db_models.ApiKey(api_key=api_key,
+                                   date_created=datetime.now(),
+                                   date_last_used=datetime.now(),
+                                   active=True)
+    return new_api_key
+
+
+def create_user(first_name: str, last_name: str, email: str, api_key: str = None) -> None:
+    new_api_key = init_api_key_object(api_key)
+    new_user = db_models.User(first_name=first_name,
+                              last_name=last_name,
+                              email=email,
+                              date_signed_up=datetime.now(),
+                              available_units=0,
+                              used_units=0,
+                              api_key=new_api_key, )
+    db.db_session.add(new_user)
+    db.db_session.commit()
+
+
+def find_user_by_api_key(api_key: str) -> db_models.User:
+    user = db.db_session.query(db_models.User).join(db_models.ApiKey).filter(
+        db_models.ApiKey.api_key == api_key).first()
+    return user
+
+
+def update_after_service_usage(user: db_models.User, unit_used: int) -> None:
+    user.used_units = user.used_units + unit_used
+    user.available_units = user.available_units - unit_used
+    user.api_key.date_last_used = datetime.now()
+
+    db.db_session.commit()

code/backend/database/db_models.py

@@ -0,0 +1,7 @@
+import random
+import string
+
+
+def generate_random_string(size: int):
+    chars = string.ascii_uppercase + string.digits
+    return ''.join(random.choice(chars) for _ in range(size))

code/backend/database/db_repo.py

@@ -0,0 +1,96 @@
+import logging
+import os
+
+from flask import Flask, request, jsonify
+
+from database import db, db_repo
+from my_service import super_service
+
+app = Flask(__name__)
+app.secret_key = os.environ['APP_SECRET_KEY']
+
+file_handler = logging.FileHandler('rest_api.log')
+logger_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+file_handler.setFormatter(logger_formatter)
+app.logger.addHandler(file_handler)
+app.logger.setLevel(logging.INFO)
+
+
+def not_found_error(msg):
+    status_code = 404
+    message = {
+        'status': status_code,
+        'message': msg
+    }
+    resp = jsonify(message)
+    resp.status_code = status_code
+    return resp
+
+
+def sample_response(msg):
+    status_code = 200
+    message = {
+        'status': status_code,
+        'message': msg
+    }
+    resp = jsonify(message)
+    resp.status_code = status_code
+    return resp
+
+
+@app.route("/microservice/", methods=["GET", "POST"])
+def microservice_index():
+    app.logger.info("Is this the real life? Or is this just fantasy?")
+    return "Please use my service, this is how I get money"
+
+
+@app.route("/microservice/add_test_users/<nb_of_users>", methods=["GET"])
+def add_test_users(nb_of_users: int):
+    nb_of_users = int(nb_of_users)
+
+    for i in range(nb_of_users):
+        db_repo.create_user("Test", "User{0}".format(i), "just{0}@test.com".format(i))
+
+    app.logger.info("Test users are created")
+
+    return sample_response("Created {0} test users".format(nb_of_users))
+
+
+@app.route("/microservice/sample_service", methods=["POST"])
+def use_sample_service():
+    req_json = request.get_json()
+
+    try:
+        # For authentication
+        api_key_str = req_json["api_key"]
+        # For the service
+        size = int(req_json["size"])
+    except KeyError:
+        app.logger.error("Could not find the necessary keys in the request's body")
+        return not_found_error("Required keys are not found in POST's body")
+
+    user = db_repo.find_user_by_api_key(api_key_str)
+
+    if user is None:
+        app.logger.error("No user found with {0} api key".format(api_key_str))
+        return not_found_error("No associated user with this api key")
+
+    if user.available_units < size:
+        app.logger.error("User with api key {0} has no units to use the service".format(api_key_str))
+        return not_found_error("Not enough unit to use the service")
+
+    # Using the Sample Service
+    random_str = super_service.generate_random_string(size)
+
+    app.logger.info("Successful service usage by {0}".format(api_key_str))
+
+    db_repo.update_after_service_usage(user, size)
+
+    response_dict = {"service_result": random_str}
+
+    return jsonify(response_dict)
+
+
+if __name__ == '__main__':
+    db.init_db()
+    app.run(host='0.0.0.0', port=5000, debug=True, threaded=True)

code/backend/my_service/__init__.py

@@ -0,0 +1,22 @@
+body {
+    height: 100%;
+    background-image: linear-gradient(135deg, #ffffff 60%, #f2f2f2 100%);
+}
+
+.btn-dark {
+    background-color: #333;
+    color: #fff;
+}
+
+.card-with-shadow {
+    box-shadow: 0 14px 28px rgba(0, 0, 0, 0.25), 0 10px 10px rgba(0, 0, 0, 0.22);
+}
+
+.bloody-mary-gradient {
+    background-image: linear-gradient(120deg, #ff512f 0%, #dd2476 100%);
+}
+
+svg path,
+svg rect {
+    fill: #333;
+}