MPT-8098 Provision FinOps order, create employee and organization

Author: d3rky

ffc/client.py

@@ -0,0 +1,159 @@
+import logging
+from datetime import datetime, timedelta, timezone
+from functools import wraps
+from urllib.parse import urljoin
+from uuid import uuid4
+
+import jwt
+import requests
+from requests import HTTPError
+
+logger = logging.getLogger(__name__)
+
+
+class FinOpsError(Exception):
+    pass
+
+
+class FinOpsHttpError(FinOpsError):
+    def __init__(self, status_code: int, content: str):
+        self.status_code = status_code
+        self.content = content
+        super().__init__(f"{self.status_code} - {self.content}")
+
+
+class FinOpsNotFoundError(FinOpsHttpError):
+    def __init__(self, content):
+        super().__init__(404, content)
+
+
+def wrap_http_error(func):
+    @wraps(func)
+    def _wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except HTTPError as e:
+            if e.response.status_code == 404:
+                raise FinOpsNotFoundError(e.response.json())
+            else:
+                raise FinOpsHttpError(e.response.status_code, e.response.json())
+
+    return _wrapper
+
+
+class FinOpsClient:
+    def __init__(self, base_url, sub, secret):
+        self._sub = sub
+        self._secret = secret
+        self._api_base_url = base_url
+
+        self._jwt = None
+
+    @wrap_http_error
+    def get_employee(self, email):
+        headers = self._get_headers()
+        response = requests.get(
+            urljoin(self._api_base_url, f"/ops/v1/employees/{email}"),
+            headers=headers,
+        )
+
+        response.raise_for_status()
+
+        return response.json()
+
+    @wrap_http_error
+    def create_employee(self, email, name):
+        headers = self._get_headers()
+
+        response = requests.post(
+            urljoin(self._api_base_url, "/ops/v1/employees"),
+            headers=headers,
+            json={
+                "email": email,
+                "display_name": name,
+            },
+        )
+
+        response.raise_for_status()
+
+        return response.json()
+
+    @wrap_http_error
+    def create_organization(
+        self,
+        name,
+        currency,
+        billing_currency,
+        external_id,
+        user_id,
+    ):
+        headers = self._get_headers()
+
+        response = requests.post(
+            urljoin(self._api_base_url, "/ops/v1/organizations"),
+            headers=headers,
+            json={
+                "name": name,
+                "currency": currency,
+                "billing_currency": billing_currency,
+                "operations_external_id": external_id,
+                "user_id": user_id,
+            },
+        )
+
+        response.raise_for_status()
+
+        return response.json()
+
+    def _get_headers(self):
+        return {
+            "Authorization": f"Bearer {self._get_auth_token()}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "X-Request-Id": str(uuid4()),
+        }
+
+    def _get_auth_token(self):
+        if not self._jwt or self._is_token_expired():
+            now = datetime.now(tz=timezone.utc)
+            self._jwt = jwt.encode(
+                {
+                    "sub": self._sub,
+                    "exp": now + timedelta(minutes=5),
+                    "nbf": now,
+                    "iat": now,
+                },
+                self._secret,
+                algorithm="HS256",
+            )
+
+        return self._jwt
+
+    def _is_token_expired(self):
+        try:
+            jwt.decode(self._jwt, self._secret, algorithms=["HS256"])
+            return False
+        except jwt.ExpiredSignatureError:
+            return True
+
+
+_FFC_CLIENT = None
+
+
+def get_ffc_client():
+    """
+    Returns an instance of the `FinOpsClient`.
+
+    Returns:
+        FinOpsClient: An instance of the `FinOpsClient`.
+    """
+    from django.conf import settings
+
+    global _FFC_CLIENT
+    if not _FFC_CLIENT:
+        _FFC_CLIENT = FinOpsClient(
+            settings.EXTENSION_CONFIG["FFC_OPERATIONS_API_BASE_URL"],
+            settings.EXTENSION_CONFIG["FFC_SUB"],
+            settings.EXTENSION_CONFIG["FFC_OPERATIONS_SECRET"],
+        )
+    return _FFC_CLIENT

ffc/flows/error.py

@@ -5,3 +5,20 @@
 
 def strip_trace_id(traceback):
     return TRACE_ID_REGEX.sub("(<omitted>)", traceback)
+
+
+class ValidationError:
+    def __init__(self, id, message):
+        self.id = id
+        self.message = message
+
+    def to_dict(self, **kwargs):
+        return {
+            "id": self.id,
+            "message": self.message.format(**kwargs),
+        }
+
+
+ERR_ORGANIZATION_NAME = ValidationError("FFC0001", "Organization name is required")
+ERR_CURRENCY = ValidationError("FFC0002", "Currency is required")
+ERR_ADMIN_CONTACT = ValidationError("FFC0003", "Administrator contact is required")

ffc/flows/fulfillment.py

@@ -6,15 +6,17 @@
 from ffc.flows.error import strip_trace_id
 from ffc.flows.order import (
     OrderContext,
-    is_change_order,
     is_purchase_order,
-    is_termination_order,
 )
 from ffc.flows.steps import (
     CheckDueDate,
+    CheckOrderParameters,
     CompleteOrder,
+    CreateEmployee,
+    CreateOrganization,
     CreateSubscription,
     ResetDueDate,
+    SetupAgreementExternalId,
     SetupDueDate,
 )
 from ffc.notifications import notify_unhandled_exception_in_teams
@@ -25,21 +27,11 @@
 purchase = Pipeline(
     SetupDueDate(),
     CheckDueDate(),
+    CheckOrderParameters(),
+    CreateEmployee(),
+    CreateOrganization(),
     CreateSubscription(),
-    ResetDueDate(),
-    CompleteOrder("purchase_order"),
-)
-
-change_order = Pipeline(
-    SetupDueDate(),
-    CheckDueDate(),
-    ResetDueDate(),
-    CompleteOrder("purchase_order"),
-)
-
-terminate = Pipeline(
-    SetupDueDate(),
-    CheckDueDate(),
+    SetupAgreementExternalId(),
     ResetDueDate(),
     CompleteOrder("purchase_order"),
 )
@@ -62,10 +54,6 @@ def fulfill_order(client, order):
     try:
         if is_purchase_order(order):
             purchase.run(client, context)
-        elif is_change_order(order):
-            change_order.run(client, context)
-        elif is_termination_order(order):  # pragma: no branch
-            terminate.run(client, context)
     except Exception:
         notify_unhandled_exception_in_teams(
             "fulfillment",

ffc/flows/fulfillment/__init__.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from swo.mpt.extensions.flows.context import Context as BaseContext
 
@@ -9,8 +9,6 @@
 MPT_ORDER_STATUS_COMPLETED = "Completed"
 
 ORDER_TYPE_PURCHASE = "Purchase"
-ORDER_TYPE_CHANGE = "Change"
-ORDER_TYPE_TERMINATION = "Termination"
 
 
 def is_purchase_order(order):
@@ -25,17 +23,11 @@ def is_purchase_order(order):
     return order["type"] == ORDER_TYPE_PURCHASE
 
 
-def is_change_order(order):
-    return order["type"] == ORDER_TYPE_CHANGE
-
-
-def is_termination_order(order):
-    return order["type"] == ORDER_TYPE_TERMINATION
-
-
 @dataclass
 class OrderContext(BaseContext):
     order: dict
+    employee: dict = field(init=False, default=None)
+    organization: dict = field(init=False, default=None)
 
     def __str__(self):
         return f"{(self.type or '-').upper()} {self.order['id']}"

ffc/flows/fulfillment/pipelines.py

@@ -1,11 +1,20 @@
-from ffc.flows.steps.complete_order import CompleteOrder
-from ffc.flows.steps.create_subscription import CreateSubscription
 from ffc.flows.steps.due_date import CheckDueDate, ResetDueDate, SetupDueDate
+from ffc.flows.steps.finops import CreateEmployee, CreateOrganization
+from ffc.flows.steps.order import (
+    CheckOrderParameters,
+    CompleteOrder,
+    SetupAgreementExternalId,
+)
+from ffc.flows.steps.subscription import CreateSubscription
 
 __all__ = [
     "CompleteOrder",
     "CreateSubscription",
     "CheckDueDate",
     "ResetDueDate",
     "SetupDueDate",
+    "CreateEmployee",
+    "CreateOrganization",
+    "CheckOrderParameters",
+    "SetupAgreementExternalId",
 ]