Using this architecture diagram, please create  the  order management service and transaction logging service microservices. 
Please implement them in Python.
The Order Managment Service is responsible for supporting the creation, retrieval, updates and deletes to all orders for products. 
The Transaction Logging Service is responsible for persisting a record of all business APIs called. This should be an immutable data store using No SQL
The code created should have the following:
1. implementations of the APIs for the Business Class. The API name should include the name of the class as a suffix.
2. The service should authenticate the JWT Bearer token passed in the API header against the Identity Mgmt Service represented by the diagram
3. Please include implementations of all APIs for the Order class and appropriate exception support.
4. All exceptions raised in the MicroService should be logged against the cloud logging service. 
5. each API call to the Microservice should be logged as a transaction in the Transaction Management Service.
6. The transaction Management Service takes as an API parameter a JSON representation of the API call to the Order mgmt Service. This is the TransactionMsg. 
7. The Transaction Management service create a “Business Transaction” message and persist in a NoSQL MongoDB Collection.
8. create the DDL for the Order class in the SQL data base. 
9. create the JSON representation of the Business Transaction class that is written to MongoDB.
10. create the docker file statements to containerize each MicroService in separate containers
11. create a Helm Chart to deploy the containers in a Kubernetes Cluster

import os
import logging
import json
import requests
from flask import Flask, request, jsonify
from sqlalchemy import create_engine, Column, Integer, String, Date, Float
from sqlalchemy.orm import declarative_base, sessionmaker
from sqlalchemy.exc import SQLAlchemyError
import jwt

app = Flask(__name__)

# Configuration
DATABASE_URL = os.environ.get("DATABASE_URL")
IDENTITY_SERVICE_URL = os.environ.get("IDENTITY_SERVICE_URL")
TRANSACTION_SERVICE_URL = os.environ.get("TRANSACTION_SERVICE_URL")
CLOUD_LOGGING_URL = os.environ.get("CLOUD_LOGGING_URL")
JWT_SECRET = os.environ.get("JWT_SECRET")

# Logging setup (replace with actual cloud logging integration)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Database setup
Base = declarative_base()

class Order(Base):
    __tablename__ = 'orders'
    orderID = Column(Integer, primary_key=True)
    orderName = Column(String)
    orderDate = Column(Date)
    orderAmt = Column(Float)
    orderProductID = Column(Integer)

engine = create_engine(DATABASE_URL)
Base.metadata.create_all(engine) #create the table
Session = sessionmaker(bind=engine)

def authenticate(token):
    try:
        decoded_token = jwt.decode(token, JWT_SECRET, algorithms=["HS256"])
        # In real scenario, you'd verify with the Identity Service
        # response = requests.get(f"{IDENTITY_SERVICE_URL}/verify", headers={"Authorization": f"Bearer {token}"})
        # if response.status_code != 200:
        #     return False
        return True # Simulate successful authentication
    except jwt.ExpiredSignatureError:
        return False
    except jwt.InvalidTokenError:
        return False

def log_transaction(transaction_msg):
    try:
        requests.post(TRANSACTION_SERVICE_URL + "/transactions", json=transaction_msg)
    except requests.exceptions.RequestException as e:
        logger.error(f"Error logging transaction: {e}")

def log_exception(e):
    try:
        requests.post(CLOUD_LOGGING_URL, json={"message": str(e), "service": "order-management"})
    except requests.exceptions.RequestException as e:
        logger.error(f"Error logging exception to cloud logging: {e}")

@app.route('/orders', methods=['POST'])
def create_order():
    token = request.headers.get('Authorization').split(" ")[1] if request.headers.get('Authorization') else None

    if not token or not authenticate(token):
        return jsonify({"message": "Unauthorized"}), 401

    try:
        data = request.get_json()
        new_order = Order(**data)
        session = Session()
        session.add(new_order)
        session.commit()
        log_transaction({"transactionType":"create", "transactionMsg":json.dumps(data)})
        return jsonify({"message": "Order created", "orderID": new_order.orderID}), 201
    except SQLAlchemyError as e:
        session.rollback()
        log_exception(e)
        return jsonify({"message": "Database error"}), 500
    except Exception as e:
        log_exception(e)
        return jsonify({"message": "Error creating order"}), 500
    finally:
        session.close()
# ... (Other order APIs - get_order, update_order, delete_order - similar structure)

from flask import Flask, request, jsonify
from pymongo import MongoClient
import os
import datetime
import logging

app = Flask(__name__)

MONGO_URI = os.environ.get("MONGO_URI")
CLOUD_LOGGING_URL = os.environ.get("CLOUD_LOGGING_URL")

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

try:
    client = MongoClient(MONGO_URI)
    db = client["transaction_db"]
    transactions = db["transactions"]
except Exception as e:
    logger.error(f"Error connecting to MongoDB: {e}")

def log_exception(e):
    try:
        requests.post(CLOUD_LOGGING_URL, json={"message": str(e), "service": "transaction-logging"})
    except requests.exceptions.RequestException as e:
        logger.error(f"Error logging exception to cloud logging: {e}")


@app.route('/transactions', methods=['POST'])
def create_transaction():
    try:
        data = request.get_json()
        transaction = {
            "transactionID": datetime.datetime.now().timestamp(), # generate a unique ID
            "transactionDateTime": datetime.datetime.utcnow(),
            "transactionType": data.get("transactionType"),
            "transactionMsg": data.get("transactionMsg")
        }
        transactions.insert_one(transaction)
        return jsonify({"message": "Transaction logged"}), 201
    except Exception as e:
        log_exception(e)
        return jsonify({"message": "Error logging transaction"}), 500

CREATE TABLE orders (
    orderID INT PRIMARY KEY AUTO_INCREMENT,
    orderName VARCHAR(255),
    orderDate DATE,
    orderAmt DECIMAL(10, 2),
    orderProductID INT
);

{
  "transactionID": "timestamp",
  "transactionDateTime": "datetime",
  "transactionType": "string (new, update, delete)",
  "transactionMsg": "JSON" // Original API Request
}

FROM python:3.9-slim-buster

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY order_management_service.py .

ENV DATABASE_URL=postgresql://user:password@db:5432/orders_db # Replace with your DB URL
ENV IDENTITY_SERVICE_URL=http://identity-service:5000
ENV TRANSACTION_SERVICE_URL=http://transaction-service:5001
ENV CLOUD_LOGGING_URL=http://cloud-logging:5002 # Replace with your logging URL
ENV JWT_SECRET="your_jwt_secret" # Replace with a strong secret

EXPOSE 5000

CMD ["python", "order_management_service.py"]

FROM python:3.9-slim-buster

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY transaction_logging_service.py .

ENV MONGO_URI=mongodb://mongo:27017/ # Replace with your Mongo URI
ENV CLOUD_LOGGING_URL=http://cloud-logging:5002

EXPOSE 5001

CMD ["python", "transaction_logging_service.py"]

Flask
SQLAlchemy
psycopg2-binary # For PostgreSQL
pymongo
requests
PyJWT

order_management:
  replicaCount: 1
  image:
    repository: <your-dockerhub-username>/order-management-service
    tag: latest
  service:
    port: 5000
  env:
    DATABASE_URL: postgresql://user:password@postgres:5432/orders_db
    IDENTITY_SERVICE_URL: http://identity-service:5000
    TRANSACTION_SERVICE_URL: http://transaction-service:5001
    CLOUD_LOGGING_URL: http://cloud-logging:5002
    JWT_SECRET: your_jwt_secret

transaction_logging:
  replicaCount: 1
  image:
    repository: <your-dockerhub-username>/transaction-logging-service
    tag: latest
  service:
    port: 5001
  env:
    MONGO_URI: mongodb://mongo:27017/
    CLOUD_LOGGING_URL: http://cloud-logging:5002

postgres: # Example PostgreSQL deployment
  enabled: true
  auth:
      username: user
      password: password
  persistence:
      enabled: false

mongo: # Example MongoDB deployment
  enabled: true
  auth:
      enabled: false