Merge pull request #12 from gofynd/add-routes-for-partner-extension-launch-in-fdk-extension-python-FPCO-27967

Add routes for partner extension launch

Author: brijeshgajjarfynd

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+---
+## [v0.6.0]
+### Added
+- Added `partner_api_routes` to support calling partners server APIs through `PartnerClient`
+- Added Support to launch extension Admin inside partners panel
+
 ---
 ## [v0.5.2] - 2022-12-31
 ### Added

README.md

@@ -74,8 +74,8 @@ async def test_route_handler(request):
     except Exception as e:
         return response.json({"error_message": str(e)}, 500)
 
-fdk_extension_client.platform_api_routes_bp.add_route(test_route_handler, "/test/routes")
-app.blueprint(fdk_extension_client.platform_api_routes_bp)
+fdk_extension_client.platform_api_routes.add_route(test_route_handler, "/test/routes")
+app.blueprint(fdk_extension_client.platform_api_routes)
 ```
 
 #### How to call platform apis in background tasks?
@@ -94,6 +94,26 @@ async def background_handler(request):
         return response.json({"error_message": str(e)}, 500)
 ```
 
+#### How to call partner apis?
+
+To call partner api you need to have instance of `PartnerClient`. Instance holds methods for SDK classes. All routes registered under `partner_api_routes` blueprint will have `partner_client` under request context object which is instance of `PartnerClient`.
+
+> Here `partner_api_routes` has middleware attached which allows passing such request which are called after launching extension under any company.
+
+```python
+async def test_route_handler(request):
+    try:
+        partner_client = request.conn_info.ctx.partner_client
+        data = await partner_client.lead.getTickets()
+        return response.json({"data": data["json"]})
+    except Exception as e:
+        return response.json({"error_message": str(e)}, 500)
+        
+fdk_extension_client.partner_api_routes.add_route(test_route_handler, "/test/routes")
+app.blueprint(fdk_extension_client.partner_api_routes)
+```
+
+
 
 #### How to register for webhook events?
 

fdk_extension/__init__.py

@@ -2,7 +2,7 @@
 FDK Extension helper Library
 """
 
-__version__ = '0.6.0.beta2'
+__version__ = '0.6.0'
 
 
 from fdk_extension.main import setup_fdk

fdk_extension/api_blueprints.py

@@ -3,9 +3,8 @@
 from sanic import Blueprint
 from sanic.blueprint_group import BlueprintGroup
 
-from .middleware.api_middleware import application_proxy_on_request
-from .middleware.api_middleware import platform_api_on_request
-from .middleware.session_middleware import session_middleware
+from .middleware.api_middleware import application_proxy_on_request, platform_api_on_request, partner_api_on_request
+from .middleware.session_middleware import session_middleware, partner_session_middleware
 
 
 class ClientBlueprintGroup(BlueprintGroup):
@@ -35,6 +34,13 @@ def chain(nested):
                 if platform_api_on_request not in middleware_function:
                     bp.middleware(platform_api_on_request, "request", *args, **kwargs)
 
+            elif self.client_type == "partner":
+                if partner_session_middleware not in middleware_function:
+                    bp.middleware(partner_session_middleware, "request", *args, **kwargs)
+
+                if partner_api_on_request not in middleware_function:
+                    bp.middleware(partner_api_on_request, "request", *args, **kwargs)
+
             elif self.client_type == "application":
                 if application_proxy_on_request not in middleware_function:
                     bp.middleware(application_proxy_on_request, "request", *args, **kwargs)
@@ -43,5 +49,6 @@ def chain(nested):
 def setup_proxy_routes() -> Tuple[BlueprintGroup, BlueprintGroup]:
     platform_api_routes = ClientBlueprintGroup(client_type="platform")
     application_proxy_routes = ClientBlueprintGroup(client_type="application")
+    partner_proxy_routes = ClientBlueprintGroup(client_type="partner")
 
-    return platform_api_routes, application_proxy_routes
+    return platform_api_routes, application_proxy_routes, partner_proxy_routes

fdk_extension/constants.py

@@ -6,6 +6,7 @@
 ONLINE_ACCESS_MODE = "online"
 
 SESSION_COOKIE_NAME = "ext_session"
+ADMIN_SESSION_COOKIE_NAME='ext_adm_session'
 
 SESSION_EXPIRY_IN_SECONDS = 900
 

fdk_extension/extension.py

@@ -4,6 +4,7 @@
 
 from fdk_client.platform.PlatformClient import PlatformClient
 from fdk_client.platform.PlatformConfig import PlatformConfig
+from fdk_client.partner import PartnerClient, PartnerConfig
 from fdk_client.application.ApplicationClient import ApplicationClient
 from fdk_client.common.utils import get_headers_with_signature
 from fdk_client.common.aiohttp_helper import AiohttpHelper
@@ -102,6 +103,9 @@ def verify_scopes(self, scopes: list, extension_data: dict) -> list:
 
     def get_auth_callback(self) -> str:
         return urljoin(self.base_url, "/fp/auth")
+    
+    def get_adm_auth_callback(self) -> str:
+        return urljoin(self.base_url, "/adm/auth")
 
     def is_online_access_mode(self) -> bool:
         return self.access_mode == ONLINE_ACCESS_MODE
@@ -146,6 +150,45 @@ async def get_platform_client(self, company_id, session: Session) -> PlatformCli
         })
         return platform_client
 
+    def get_partner_config(self, organization_id) -> PartnerConfig:
+        if (not self.is_initialized()):
+            raise FdkInvalidConfig("Extension not initialized due to invalid data")
+
+        partner_config = PartnerConfig({
+            "organizationId": organization_id,
+            "domain": self.cluster,
+            "apiKey": self.api_key,
+            "apiSecret": self.api_secret,
+            "useAutoRenewTimer": False,
+            "logLevel": "DEBUG"
+        })
+        return partner_config
+    
+    async def get_partner_client(self, organization_id, session: Session) -> PartnerClient:
+        if (not self.is_initialized()):
+            raise FdkInvalidConfig("Extension not initialized due to invalid data")
+
+        from .session.session_storage import SessionStorage
+
+        partner_config = self.get_partner_config(organization_id)
+        partner_config.oauthClient.setTokenFromSession(session)
+        partner_config.oauthClient.token_expires_at = session.access_token_validity
+
+        if (session.access_token_validity and session.refresh_token):
+            ac_nr_expired = ((session.access_token_validity - get_current_timestamp()) // 1000) <= 120
+            if ac_nr_expired:
+                logger.debug(f"Renewing access token for organization {organization_id} with partner config {json.dumps(safe_stringify(partner_config))}")
+                renew_token_res = await partner_config.oauthClient.renewAccessToken(session.access_mode == OFFLINE_ACCESS_MODE)
+                renew_token_res["access_token_validity"] = partner_config.oauthClient.token_expires_at
+                session.update_token(renew_token_res)
+                await SessionStorage.save_session(session)
+                logger.debug(f"Access token renewed for organization {organization_id} with response {renew_token_res}")
+
+        partner_client = PartnerClient(partner_config)
+        partner_client.setExtraHeaders({
+            'x-ext-lib-version': f"py/{__version__}"
+        })
+        return partner_client
 
     # Making API request to fetch extension details
     async def get_extension_details(self) -> dict:
@@ -184,6 +227,7 @@ def __init__(self, **client_data):
         self.platform_api_routes: ClientBlueprintGroup = client_data["platform_api_routes"]
         self.webhook_registry: WebhookRegistry = client_data["webhook_registry"]
         self.application_proxy_routes: ClientBlueprintGroup = client_data["application_proxy_routes"]
+        self.partner_proxy_routes: ClientBlueprintGroup = client_data["partner_proxy_routes"]
         self.get_platform_client: PlatformClient = client_data["get_platform_client"]
         self.get_application_client: ApplicationClient = client_data["get_application_client"]
 

fdk_extension/handlers.py

@@ -1,5 +1,6 @@
 """Request handlers."""
 from datetime import datetime, timedelta
+from urllib.parse import urljoin
 import uuid
 
 from sanic.blueprints import Blueprint
@@ -11,7 +12,7 @@
 from .constants import *
 from .exceptions import FdkSessionNotFoundError, FdkInvalidOAuthError
 from .extension import extension
-from .middleware.session_middleware import session_middleware
+from .middleware.session_middleware import session_middleware, partner_session_middleware
 from .session.session import Session
 from .session.session_storage import SessionStorage
 from .utilities import logger
@@ -99,7 +100,7 @@ async def auth_handler(request: Request):
         if not extension.is_online_access_mode():
             session_id = Session.generate_session_id(False, **{
                 "cluster": extension.cluster,
-                "company_id": company_id
+                "id": company_id
             })
             session = await SessionStorage.get_session(session_id)
             if not session:
@@ -156,7 +157,7 @@ async def auto_install_handler(request: Request):
         platform_config = extension.get_platform_config(company_id=company_id)
         session_id = Session.generate_session_id(False, **{
             "cluster": extension.cluster,
-            "company_id": company_id
+            "id": company_id
         })
 
         session = await SessionStorage.get_session(session_id=session_id)
@@ -203,7 +204,7 @@ async def uninstall_handler(request: Request):
         if not extension.is_online_access_mode():
             session_id = Session.generate_session_id(False, **{
                 "cluster": extension.cluster,
-                "company_id": company_id
+                "id": company_id
             })
             await SessionStorage.delete_session(session_id=session_id)
 
@@ -214,17 +215,137 @@ async def uninstall_handler(request: Request):
         logger.exception(e)
         return json_response({"error_message": str(e)}, 500)
 
+async def adm_install_handler(request: Request):
+    try:
+        organization_id = request.args.get("organization_id")
+        partner_config = extension.get_partner_config(organization_id)
+
+        session = Session(Session.generate_session_id(True))
+        session_expires = datetime.now() + timedelta(seconds=SESSION_EXPIRY_IN_SECONDS) # 15 mins
+
+        if session.is_new:
+            session.organization_id = organization_id
+            session.scope = extension.scopes
+            session.expires = session_expires
+            session.access_mode = ONLINE_ACCESS_MODE  # Always generate online mode token for extension launch
+            session.extension_id = extension.api_key
+
+        request.conn_info.ctx.fdk_session = session
+        request.conn_info.ctx.extension = extension
+
+        session.state = str(uuid.uuid4())
+
+        auth_callback = extension.get_adm_auth_callback()
+
+        # start authorization flow
+        redirect_url = partner_config.oauthClient.startAuthorization({
+            "scope": session.scope,
+            "redirectUri": auth_callback,
+            "state": session.state,
+            "access_mode": ONLINE_ACCESS_MODE # Always generate online mode token for extension launch
+        })
+
+        logger.debug(f"Redirecting after partner install callback to url: {redirect_url}")
+
+        cookie_name =  ADMIN_SESSION_COOKIE_NAME
+
+        next_response = redirect(redirect_url)
+        next_response.cookies[cookie_name] = session.session_id
+        next_response.cookies[cookie_name]["secure"] = True
+        next_response.cookies[cookie_name]["samesite"] = "None"
+        next_response.cookies[cookie_name]["httponly"] = True
+        next_response.cookies[cookie_name]["expires"] = session.expires
+
+        await SessionStorage.save_session(session)
+
+        return next_response
+    except Exception as e:
+        logger.exception(e)
+        return json_response({"error_message": str(e)}, 500)
+
+async def adm_auth_handler(request: Request):
+    try:
+        if not request.conn_info.ctx.fdk_session:
+            raise FdkSessionNotFoundError("Can not complete oauth process as session not found")
+
+        if request.conn_info.ctx.fdk_session.state != request.args.get("state"):
+            raise FdkInvalidOAuthError("Invalid oauth call")
+
+        organization_id = request.conn_info.ctx.fdk_session.organization_id
+
+        partner_config = extension.get_partner_config(organization_id)
+        await partner_config.oauthClient.verifyCallback(request.args)
+
+        token: dict = partner_config.oauthClient.raw_token
+        session_expires = datetime.now() + timedelta(seconds=token["expires_in"])
+
+        request.conn_info.ctx.fdk_session.expires = session_expires
+        token["access_token_validity"] = int(session_expires.timestamp()*1000)
+        request.conn_info.ctx.fdk_session.update_token(token)
+
+        await SessionStorage.save_session(request.conn_info.ctx.fdk_session)
+
+
+        if not extension.is_online_access_mode():
+            session_id = Session.generate_session_id(False, **{
+                "cluster": extension.cluster,
+                "id": organization_id
+            })
+            session = await SessionStorage.get_session(session_id)
+            if not session:
+                session = Session(session_id=session_id)
+            elif session.extension_id != extension.api_key:
+                session = Session(session_id=session_id)
+            
+            #TODO: Do we need this here again
+            partner_config = extension.get_partner_config(organization_id)
+            offline_token_response = await partner_config.oauthClient.getOfflineAccessToken(
+                extension.scopes, request.args.get("code")
+                )
+            
+            session.organization_id = organization_id
+            session.scope = extension.scopes
+            session.state = request.conn_info.ctx.fdk_session.state
+            session.extension_id = extension.api_key
+            offline_token_response["access_token_validity"] = partner_config.oauthClient.token_expires_at
+            offline_token_response["access_mode"] = OFFLINE_ACCESS_MODE
+            session.update_token(offline_token_response)
+
+            await SessionStorage.save_session(session=session)        
+
+        
+        redirect_url = urljoin(extension.base_url, '/admin')
+        next_response = redirect(redirect_url)
+
+        cookie_name = ADMIN_SESSION_COOKIE_NAME
+        next_response.cookies[cookie_name] = request.conn_info.ctx.fdk_session.session_id
+        next_response.cookies[cookie_name]["secure"] = True
+        next_response.cookies[cookie_name]["samesite"] = "None"
+        next_response.cookies[cookie_name]["httponly"] = True
+        next_response.cookies[cookie_name]["expires"] = session_expires
+
+        logger.debug(f"Redirecting after auth callback to url: {redirect_url}")
+
+        return next_response
+    except Exception as e:
+        logger.exception(e)
+        return json_response({"error_message": str(e)}, 500)
 
 def setup_routes() -> BlueprintGroup:
     fdk_routes_bp1 = Blueprint("fdk_routes_bp1")
     fdk_routes_bp2 = Blueprint("fdk_routes_bp2")
+    fdk_routes_bp3 = Blueprint("fdk_routes_bp3")
 
     fdk_routes_bp1.middleware(session_middleware, "request")
     fdk_routes_bp1.add_route(auth_handler, "/fp/auth", methods=["GET"])
     fdk_routes_bp1.add_route(auto_install_handler, "/fp/auto_install", methods=["POST"])
 
     fdk_routes_bp2.add_route(install_handler, "/fp/install", methods=["GET"])
+    fdk_routes_bp2.add_route(adm_install_handler, "/adm/install", methods=["GET"])
     fdk_routes_bp2.add_route(uninstall_handler, "/fp/uninstall", methods=["POST"])
 
-    fdk_route = Blueprint.group(fdk_routes_bp1, fdk_routes_bp2)
+    fdk_routes_bp3.middleware(partner_session_middleware, "request")
+    fdk_routes_bp3.add_route(adm_auth_handler, "/adm/auth", methods=["GET"])
+
+    fdk_route = Blueprint.group(fdk_routes_bp1, fdk_routes_bp2, fdk_routes_bp3)
     return fdk_route