1233 lines
50 KiB
Python
1233 lines
50 KiB
Python
"""
|
|
Copyright 2024-2026 ChatterMate
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
"""
|
|
|
|
import traceback
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response
|
|
from fastapi.responses import RedirectResponse, HTMLResponse
|
|
from sqlalchemy.orm import Session
|
|
from app.core.config import settings
|
|
from app.core.logger import get_logger
|
|
from app.database import get_db
|
|
from app.models.schemas.shopify import ShopifyShopCreate, ShopifyShop, ShopifyShopUpdate
|
|
from app.models.schemas.shopify import AgentShopifyConfigBase, AgentShopifyConfig, AgentShopifyConfigCreate, AgentShopifyConfigUpdate
|
|
from app.repositories.shopify_shop_repository import ShopifyShopRepository
|
|
from app.repositories.agent_shopify_config_repository import AgentShopifyConfigRepository
|
|
from typing import Optional
|
|
import requests
|
|
import hmac
|
|
import hashlib
|
|
import base64
|
|
import json
|
|
from urllib.parse import urlencode, quote
|
|
from app.core.auth import get_current_user, require_permissions, get_current_organization, check_permissions
|
|
from app.models.user import User
|
|
from app.models.organization import Organization
|
|
from app.repositories.widget import WidgetRepository
|
|
from app.services.shopify import ShopifyService
|
|
from app.services.shopify_auth_service import ShopifyAuthService
|
|
from app.services.shopify_helper_service import ShopifyHelperService
|
|
from app.services.shopify_session import require_shopify_session
|
|
from app.services.shopify_urls import shopify_admin_url, shopify_oauth_token_url
|
|
from app.repositories.knowledge import KnowledgeRepository
|
|
from app.repositories.knowledge_queue import KnowledgeQueueRepository
|
|
from app.repositories.knowledge_to_agent import KnowledgeToAgentRepository
|
|
from app.models.knowledge import SourceType
|
|
from app.models.knowledge_queue import KnowledgeQueue, QueueStatus
|
|
from app.models.knowledge_to_agent import KnowledgeToAgent
|
|
from uuid import UUID
|
|
from app.core.cors import update_cors_middleware
|
|
from app.core.application import app
|
|
from app.core.params import MAX_DB_INT
|
|
|
|
router = APIRouter()
|
|
logger = get_logger(__name__)
|
|
|
|
# Define the scopes needed for your app
|
|
SCOPES = "read_products,read_themes,write_themes,write_script_tags,read_script_tags,read_orders,read_all_orders,read_customers"
|
|
|
|
|
|
def _require_shopify_agent_in_org(db, agent_id, org_id) -> None:
|
|
"""The agent being configured must belong to the resolved org, else 404.
|
|
|
|
agent_id and org_id both arrive as either strings or UUIDs depending on the
|
|
auth path; a malformed id is simply not found rather than a 500.
|
|
"""
|
|
from app.repositories.agent import AgentRepository
|
|
try:
|
|
agent_uuid = UUID(str(agent_id))
|
|
org_uuid = UUID(str(org_id))
|
|
except (ValueError, TypeError):
|
|
raise HTTPException(status_code=404, detail="Agent not found")
|
|
if not AgentRepository(db).get_agent_in_org(agent_uuid, org_uuid):
|
|
raise HTTPException(status_code=404, detail="Agent not found")
|
|
|
|
|
|
@router.post("/exchange-token")
|
|
async def exchange_session_token(
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Exchange Shopify session token for offline access token via Shopify token exchange API.
|
|
Called when app is first loaded in embedded context.
|
|
Stores offline access token in database for future Shopify API calls.
|
|
"""
|
|
try:
|
|
# 1. Get session token from Authorization header
|
|
from app.services.shopify_session import ShopifySessionService
|
|
|
|
session_token = ShopifySessionService.get_session_token_from_request(request)
|
|
if not session_token:
|
|
raise HTTPException(status_code=401, detail="Session token required")
|
|
|
|
logger.info("Exchanging session token for offline access token")
|
|
|
|
# 2. Verify the session token's signature before trusting any claim. This request
|
|
# carries client_secret to the host named by `dest`, so an unverified token
|
|
# would let a caller steer our credentials to a host of their choosing.
|
|
decoded = ShopifySessionService.validate_session_token(session_token)
|
|
shop_domain = decoded.get('dest', '').replace('https://', '').replace('http://', '')
|
|
|
|
# `dest` must be a Shopify shop domain, never a caller-chosen host.
|
|
if not shop_domain or not shop_domain.split('/')[0].endswith('.myshopify.com'):
|
|
raise HTTPException(status_code=400, detail="Invalid session token: bad shop domain")
|
|
|
|
logger.info(f"Extracted shop domain from token: {shop_domain}")
|
|
|
|
# 3. Call Shopify token exchange API
|
|
token_url = shopify_oauth_token_url(shop_domain)
|
|
payload = {
|
|
"client_id": settings.SHOPIFY_API_KEY,
|
|
"client_secret": settings.SHOPIFY_API_SECRET,
|
|
"grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
|
|
"subject_token": session_token,
|
|
"subject_token_type": "urn:ietf:params:oauth:token-type:id_token",
|
|
"requested_token_type": "urn:shopify:params:oauth:token-type:offline-access-token"
|
|
}
|
|
|
|
logger.info(f"Calling Shopify token exchange API for shop: {shop_domain}")
|
|
response = requests.post(token_url, json=payload)
|
|
|
|
if response.status_code != 200:
|
|
logger.error(f"Token exchange failed: {response.status_code} - {response.text}")
|
|
raise HTTPException(
|
|
status_code=response.status_code,
|
|
detail=f"Token exchange failed: {response.text}"
|
|
)
|
|
|
|
token_data = response.json()
|
|
access_token = token_data.get('access_token')
|
|
|
|
if not access_token:
|
|
logger.error(f"No access token in response: {token_data}")
|
|
raise HTTPException(status_code=500, detail="No access token received from Shopify")
|
|
|
|
logger.info(f"Successfully received offline access token for shop: {shop_domain}")
|
|
|
|
# 4. Create or update shop with offline access token
|
|
shop_repo = ShopifyShopRepository(db)
|
|
db_shop = shop_repo.get_shop_by_domain(shop_domain)
|
|
|
|
if not db_shop:
|
|
logger.info(f"Creating new shop record for: {shop_domain}")
|
|
shop_data = ShopifyShopCreate(
|
|
shop_domain=shop_domain,
|
|
access_token=access_token,
|
|
is_installed=True
|
|
)
|
|
db_shop = shop_repo.create_shop(shop_data)
|
|
else:
|
|
logger.info(f"Updating existing shop record for: {shop_domain}")
|
|
shop_update = ShopifyShopUpdate(access_token=access_token, is_installed=True)
|
|
db_shop = shop_repo.update_shop(db_shop.id, shop_update)
|
|
|
|
db.commit()
|
|
db.refresh(db_shop)
|
|
|
|
logger.info(f"Shop record saved successfully. Shop ID: {db_shop.id}, Org ID: {db_shop.organization_id}")
|
|
|
|
return {
|
|
"shop_id": str(db_shop.id),
|
|
"shop_domain": db_shop.shop_domain,
|
|
"organization_id": str(db_shop.organization_id) if db_shop.organization_id else None,
|
|
"is_installed": True
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error exchanging session token: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Token exchange error: {str(e)}")
|
|
|
|
|
|
@router.post("/link-organization")
|
|
async def link_shop_to_org(
|
|
request: Request,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""
|
|
Link Shopify shop to authenticated user's organization after login.
|
|
Called after user logs in via popup window.
|
|
"""
|
|
try:
|
|
# Get shop_id from request body
|
|
body = await request.json()
|
|
shop_id = body.get('shop_id')
|
|
|
|
if not shop_id:
|
|
raise HTTPException(status_code=400, detail="shop_id is required")
|
|
|
|
logger.info(f"Linking shop {shop_id} to user {current_user.id}'s organization")
|
|
|
|
# Verify user has manage_organization permission
|
|
if not check_permissions(current_user, ["manage_organization"]):
|
|
raise HTTPException(status_code=403, detail="Insufficient permissions")
|
|
|
|
if not current_user.organization_id:
|
|
raise HTTPException(status_code=400, detail="User not associated with an organization")
|
|
|
|
# Get shop from database
|
|
shop_repo = ShopifyShopRepository(db)
|
|
db_shop = shop_repo.get_shop(shop_id)
|
|
|
|
if not db_shop:
|
|
raise HTTPException(status_code=404, detail="Shop not found")
|
|
|
|
org_id_str = str(current_user.organization_id)
|
|
|
|
# Claiming is only for shops nobody owns yet — the same guard
|
|
# /link-shop/{shop_id} has. Without it, any manage_organization user
|
|
# could re-point another tenant's installed shop (and its stored
|
|
# access token) at their own org, and drag that shop's domain onto
|
|
# their organization record in the process.
|
|
if db_shop.organization_id and str(db_shop.organization_id) != org_id_str:
|
|
raise HTTPException(
|
|
status_code=404,
|
|
detail="Shop not found"
|
|
)
|
|
|
|
# Update shop with organization_id
|
|
shop_update = ShopifyShopUpdate(organization_id=org_id_str)
|
|
shop_repo.update_shop(shop_id, shop_update)
|
|
|
|
# Update organization domain with shop domain
|
|
try:
|
|
from app.repositories.organization import OrganizationRepository
|
|
org_repo = OrganizationRepository(db)
|
|
organization = org_repo.get_organization(org_id_str)
|
|
|
|
if organization and db_shop.shop_domain:
|
|
# Only update if domain is different
|
|
if organization.domain != db_shop.shop_domain:
|
|
# Check if domain is already used by another organization
|
|
existing_org = org_repo.get_organization_by_domain(db_shop.shop_domain)
|
|
if not existing_org or str(existing_org.id) == str(organization.id):
|
|
# Update organization domain to shop domain
|
|
organization.domain = db_shop.shop_domain
|
|
db.add(organization)
|
|
logger.info(f"Updated organization {org_id_str} domain to {db_shop.shop_domain}")
|
|
else:
|
|
logger.warning(f"Domain {db_shop.shop_domain} is already used by organization {existing_org.id}, skipping update")
|
|
except Exception as domain_error:
|
|
logger.error(f"Error updating organization domain: {str(domain_error)}")
|
|
# Don't fail the linking if domain update fails
|
|
|
|
db.commit()
|
|
|
|
# Update CORS middleware to include new domain
|
|
try:
|
|
update_cors_middleware(app)
|
|
logger.info("Updated CORS middleware after linking shop to organization")
|
|
except Exception as cors_error:
|
|
logger.error(f"Error updating CORS middleware: {str(cors_error)}")
|
|
# Don't fail the linking if CORS update fails
|
|
|
|
logger.info(f"Successfully linked shop {shop_id} to organization {org_id_str}")
|
|
|
|
return {
|
|
"success": True,
|
|
"shop_id": shop_id,
|
|
"organization_id": org_id_str
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error linking shop to organization: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail=f"Failed to link organization: {str(e)}")
|
|
|
|
|
|
@router.get("/shops", response_model=list[ShopifyShop])
|
|
async def get_shops(
|
|
db: Session = Depends(get_db),
|
|
skip: int = Query(0, ge=0, le=MAX_DB_INT),
|
|
limit: int = Query(100, ge=1, le=1000),
|
|
organization: Organization = Depends(get_current_organization),
|
|
current_user: User = Depends(require_permissions("manage_organization"))
|
|
):
|
|
"""
|
|
Get all shops for the current organization
|
|
"""
|
|
# Ensure organization_id is a string, not a UUID object
|
|
org_id_str = str(organization.id) if organization and organization.id else None
|
|
shop_repository = ShopifyShopRepository(db)
|
|
shops = shop_repository.get_shops_by_organization(org_id_str, skip=skip, limit=limit)
|
|
|
|
# Ensure organization_id is a string in each shop object
|
|
for shop in shops:
|
|
if shop.organization_id and not isinstance(shop.organization_id, str):
|
|
shop.organization_id = str(shop.organization_id)
|
|
|
|
return shops
|
|
|
|
@router.get("/shops/{shop_id}", response_model=ShopifyShop)
|
|
async def get_shop(
|
|
shop_id: str,
|
|
db: Session = Depends(get_db),
|
|
organization: Organization = Depends(get_current_organization),
|
|
current_user: User = Depends(require_permissions("manage_organization"))
|
|
):
|
|
"""
|
|
Get a shop by ID
|
|
"""
|
|
shop_repository = ShopifyShopRepository(db)
|
|
db_shop = shop_repository.get_shop(shop_id)
|
|
if not db_shop:
|
|
raise HTTPException(status_code=404, detail="Shop not found")
|
|
|
|
# Convert organization IDs to strings for comparison
|
|
shop_org_id = str(db_shop.organization_id) if db_shop.organization_id else None
|
|
current_org_id = str(organization.id) if organization.id else None
|
|
|
|
# Ensure organization_id is a string, not a UUID object
|
|
if db_shop.organization_id and not isinstance(db_shop.organization_id, str):
|
|
db_shop.organization_id = str(db_shop.organization_id)
|
|
|
|
# Verify that the shop belongs to the current organization
|
|
if shop_org_id != current_org_id:
|
|
logger.warning(f"Unauthorized attempt to access shop {shop_id} from organization {current_org_id}")
|
|
raise HTTPException(status_code=403, detail="This shop does not belong to your organization")
|
|
|
|
return db_shop
|
|
|
|
@router.delete("/shops/{shop_id}")
|
|
async def delete_shop(
|
|
shop_id: str,
|
|
db: Session = Depends(get_db),
|
|
organization: Organization = Depends(get_current_organization),
|
|
current_user: User = Depends(require_permissions("manage_organization"))
|
|
):
|
|
"""
|
|
Delete a shop and disconnect from Shopify
|
|
"""
|
|
shop_repository = ShopifyShopRepository(db)
|
|
db_shop = shop_repository.get_shop(shop_id)
|
|
if not db_shop:
|
|
raise HTTPException(status_code=404, detail="Shop not found")
|
|
|
|
# Convert organization IDs to strings for comparison
|
|
shop_org_id = str(db_shop.organization_id) if db_shop.organization_id else None
|
|
current_org_id = str(organization.id) if organization.id else None
|
|
|
|
# Verify that the shop belongs to the current organization
|
|
if shop_org_id != current_org_id:
|
|
logger.warning(f"Unauthorized attempt to delete shop {shop_id} from organization {current_org_id}")
|
|
raise HTTPException(status_code=403, detail="This shop does not belong to your organization")
|
|
|
|
# Send an uninstall request to Shopify if we have an access token
|
|
if db_shop.access_token:
|
|
try:
|
|
# Request to delete app data from Shopify
|
|
uninstall_url = shopify_admin_url(db_shop.shop_domain, "graphql.json")
|
|
headers = {
|
|
"X-Shopify-Access-Token": db_shop.access_token,
|
|
"Content-Type": "application/json"
|
|
}
|
|
|
|
# GraphQL mutation to uninstall the app
|
|
mutation = """
|
|
mutation {
|
|
appSubscriptionCancel(
|
|
id: "gid://shopify/AppSubscription/current"
|
|
) {
|
|
appSubscription {
|
|
id
|
|
status
|
|
}
|
|
userErrors {
|
|
field
|
|
message
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
|
|
response = requests.post(
|
|
uninstall_url,
|
|
headers=headers,
|
|
json={"query": mutation}
|
|
)
|
|
|
|
logger.info(f"Shopify uninstall response: {response.status_code} - {response.text}")
|
|
except Exception as e:
|
|
logger.error(f"Error uninstalling app from Shopify: {str(e)}")
|
|
# Continue with deletion even if uninstall fails
|
|
|
|
# Get all agent configs linked to this shop and delete them
|
|
try:
|
|
agent_config_repository = AgentShopifyConfigRepository(db)
|
|
agent_configs = agent_config_repository.get_configs_by_shop(shop_id)
|
|
if agent_configs:
|
|
logger.info(f"Deleting {len(agent_configs)} agent Shopify configs for shop {shop_id}")
|
|
for config in agent_configs:
|
|
# Update the config to disable and remove shop_id
|
|
agent_config_repository.update_agent_shopify_config(
|
|
config.agent_id,
|
|
AgentShopifyConfigUpdate(enabled=False, shop_id=None)
|
|
)
|
|
logger.info(f"Successfully deleted agent Shopify configs for shop {shop_id}")
|
|
except Exception as e:
|
|
logger.error(f"Error deleting agent Shopify configs: {str(e)}")
|
|
# Continue with shop deletion even if config deletion fails
|
|
|
|
# Delete the shop from our database
|
|
success = shop_repository.delete_shop(shop_id)
|
|
if not success:
|
|
raise HTTPException(status_code=500, detail="Failed to delete shop")
|
|
|
|
return {"status": "success", "message": "Shop successfully disconnected"}
|
|
|
|
@router.post("/link-shop/{shop_id}")
|
|
async def link_shop_to_organization(
|
|
shop_id: str,
|
|
db: Session = Depends(get_db),
|
|
organization: Organization = Depends(get_current_organization),
|
|
current_user: User = Depends(require_permissions("manage_organization"))
|
|
):
|
|
"""
|
|
Link a Shopify shop to the current organization after user logs in.
|
|
This is called after successful login from the embedded app flow.
|
|
"""
|
|
try:
|
|
shop_repository = ShopifyShopRepository(db)
|
|
db_shop = shop_repository.get_shop(shop_id)
|
|
|
|
if not db_shop:
|
|
raise HTTPException(status_code=404, detail="Shop not found")
|
|
|
|
# Link shop to organization if not already linked
|
|
if not db_shop.organization_id:
|
|
org_id_str = str(organization.id)
|
|
shop_update = ShopifyShopUpdate(organization_id=org_id_str)
|
|
db_shop = shop_repository.update_shop(shop_id, shop_update)
|
|
db.commit()
|
|
logger.info(f"Linked shop {shop_id} to organization {org_id_str}")
|
|
|
|
return {
|
|
"success": True,
|
|
"shop_id": str(db_shop.id),
|
|
"shop_domain": db_shop.shop_domain,
|
|
"organization_id": str(db_shop.organization_id)
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error linking shop to organization: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail="Error linking shop to organization"
|
|
)
|
|
|
|
@router.get("/status")
|
|
async def check_connection(
|
|
db: Session = Depends(get_db),
|
|
organization: Organization = Depends(get_current_organization),
|
|
current_user: User = Depends(require_permissions("manage_organization"))
|
|
):
|
|
"""
|
|
Check if Shopify is connected for the current organization
|
|
"""
|
|
try:
|
|
# Get shops for the current organization
|
|
org_id_str = str(organization.id) if organization.id else None
|
|
shop_repository = ShopifyShopRepository(db)
|
|
shops = shop_repository.get_shops_by_organization(org_id_str, limit=1)
|
|
is_connected = len(shops) > 0 and any(shop.is_installed for shop in shops)
|
|
|
|
result = {
|
|
"connected": is_connected
|
|
}
|
|
|
|
# If connected, include the shop domain
|
|
if is_connected:
|
|
result["shop_domain"] = shops[0].shop_domain
|
|
|
|
return result
|
|
except Exception as e:
|
|
logger.error(f"Error checking Shopify connection: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail="Error checking Shopify connection status"
|
|
)
|
|
|
|
@router.get("/shop-config-status")
|
|
async def get_shop_config_status(
|
|
shopify_session: dict = Depends(require_shopify_session),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Check configuration status for a shop (agents configured, widget ID, etc.)
|
|
Uses session token authentication for embedded apps.
|
|
"""
|
|
try:
|
|
# Shop info already validated by session token
|
|
db_shop = shopify_session['db_shop']
|
|
|
|
# Check if any agents are configured for this shop
|
|
agent_config_repository = AgentShopifyConfigRepository(db)
|
|
configs = agent_config_repository.get_configs_by_shop(str(db_shop.id), enabled_only=True)
|
|
agents_connected = len(configs) if configs else 0
|
|
|
|
# Get widget ID if agents are configured
|
|
widget_id = None
|
|
if configs and len(configs) > 0:
|
|
widget_repo = WidgetRepository(db)
|
|
widgets = widget_repo.get_widgets_by_agent(configs[0].agent_id)
|
|
if widgets and len(widgets) > 0:
|
|
widget_id = str(widgets[0].id)
|
|
|
|
return {
|
|
"shop_id": str(db_shop.id),
|
|
"shop_domain": db_shop.shop_domain,
|
|
"is_installed": db_shop.is_installed,
|
|
"agents_connected": agents_connected,
|
|
"widget_id": widget_id,
|
|
"organization_id": str(db_shop.organization_id) if db_shop.organization_id else None
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting shop config status: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail="Error retrieving shop configuration status"
|
|
)
|
|
|
|
@router.get("/organization-domain")
|
|
async def get_organization_domain(
|
|
shopify_session: dict = Depends(require_shopify_session),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Get organization domain from the organization table.
|
|
Uses session token authentication for embedded apps.
|
|
"""
|
|
try:
|
|
# Shop info already validated by session token
|
|
db_shop = shopify_session['db_shop']
|
|
|
|
if not db_shop.organization_id:
|
|
raise HTTPException(status_code=400, detail="Shop not linked to organization")
|
|
|
|
# Get organization
|
|
from app.repositories.organization import OrganizationRepository
|
|
org_repo = OrganizationRepository(db)
|
|
organization = org_repo.get_organization(str(db_shop.organization_id))
|
|
|
|
if not organization:
|
|
raise HTTPException(status_code=404, detail="Organization not found")
|
|
|
|
return {
|
|
"organization_id": str(organization.id),
|
|
"domain": organization.domain,
|
|
"name": organization.name
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting organization domain: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail="Error retrieving organization domain"
|
|
)
|
|
|
|
@router.put("/update-domain")
|
|
async def update_organization_domain(
|
|
request: Request,
|
|
shopify_session: dict = Depends(require_shopify_session),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Update organization domain.
|
|
Uses session token authentication for embedded apps.
|
|
"""
|
|
try:
|
|
# Shop info already validated by session token
|
|
db_shop = shopify_session['db_shop']
|
|
|
|
# Get domain from request body
|
|
body = await request.json()
|
|
new_domain = body.get('domain')
|
|
|
|
if not new_domain:
|
|
raise HTTPException(status_code=400, detail="domain is required")
|
|
|
|
# Validate domain format (basic validation)
|
|
new_domain = new_domain.strip()
|
|
if not new_domain:
|
|
raise HTTPException(status_code=400, detail="domain cannot be empty")
|
|
|
|
# Get organization
|
|
if not db_shop.organization_id:
|
|
raise HTTPException(status_code=400, detail="Shop not linked to organization")
|
|
|
|
from app.repositories.organization import OrganizationRepository
|
|
org_repo = OrganizationRepository(db)
|
|
organization = org_repo.get_organization(str(db_shop.organization_id))
|
|
|
|
if not organization:
|
|
raise HTTPException(status_code=404, detail="Organization not found")
|
|
|
|
# Update organization domain
|
|
organization.domain = new_domain
|
|
db.add(organization)
|
|
db.commit()
|
|
|
|
logger.info(f"Updated organization {organization.id} domain to {new_domain}")
|
|
|
|
# Update CORS middleware to include new domain
|
|
update_cors_middleware(app)
|
|
logger.info("Updated CORS middleware after domain update")
|
|
|
|
return {
|
|
"success": True,
|
|
"domain": new_domain,
|
|
"organization_id": str(organization.id)
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error updating organization domain: {str(e)}")
|
|
# Check if it's a unique constraint violation
|
|
if "duplicate key" in str(e).lower() or "unique constraint" in str(e).lower():
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Domain is already connected to another organization"
|
|
)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail="Error updating organization domain"
|
|
)
|
|
|
|
@router.get("/connected-agents")
|
|
async def get_connected_agents(
|
|
shop_id: str = Query(..., description="Shop ID"),
|
|
shopify_session: dict = Depends(require_shopify_session),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Get all agents connected to a Shopify shop.
|
|
Uses session token authentication for embedded apps.
|
|
"""
|
|
try:
|
|
# Verify shop_id matches the session
|
|
if shop_id != shopify_session['shop_id']:
|
|
raise HTTPException(status_code=403, detail="Shop ID mismatch")
|
|
|
|
# Get agent configurations for this shop
|
|
agent_config_repository = AgentShopifyConfigRepository(db)
|
|
configs = agent_config_repository.get_configs_by_shop(shop_id, enabled_only=True)
|
|
|
|
if not configs:
|
|
return []
|
|
|
|
# Get full agent details for each config
|
|
from app.repositories.agent import AgentRepository
|
|
agent_repo = AgentRepository(db)
|
|
agents = []
|
|
|
|
for config in configs:
|
|
agent = agent_repo.get_agent(str(config.agent_id))
|
|
if agent:
|
|
agents.append({
|
|
"id": str(agent.id),
|
|
"name": agent.name,
|
|
"display_name": agent.display_name,
|
|
"description": agent.description,
|
|
"is_active": agent.is_active,
|
|
"organization_id": str(agent.organization_id)
|
|
})
|
|
|
|
return agents
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting connected agents: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail="Error retrieving connected agents"
|
|
)
|
|
|
|
@router.get("/agent-config/{agent_id}", response_model=AgentShopifyConfig)
|
|
async def get_agent_shopify_config(
|
|
agent_id: str,
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Get Shopify configuration for an agent.
|
|
Supports both session token auth (embedded) and JWT auth (dashboard).
|
|
"""
|
|
# Try session token first (for embedded apps)
|
|
org_id = None
|
|
try:
|
|
shopify_session = await require_shopify_session(request, db)
|
|
# Session token valid - verify agent belongs to shop's organization
|
|
if not shopify_session['organization_id']:
|
|
raise HTTPException(status_code=403, detail="Shop not linked to organization")
|
|
org_id = shopify_session['organization_id']
|
|
logger.info(f"GET agent-config using session token for org: {org_id}")
|
|
except HTTPException:
|
|
# Fall back to JWT auth (for dashboard)
|
|
current_user = await get_current_user(request=request, db=db)
|
|
if not check_permissions(current_user, ["manage_organization"]):
|
|
raise HTTPException(status_code=403, detail="Insufficient permissions")
|
|
org_id = current_user.organization_id
|
|
logger.info(f"GET agent-config using JWT auth for user: {current_user.id}")
|
|
|
|
# The comment above always promised this — the agent must be in the
|
|
# resolved org, else any tenant could read any agent's Shopify config.
|
|
_require_shopify_agent_in_org(db, agent_id, org_id)
|
|
|
|
agent_config_repository = AgentShopifyConfigRepository(db)
|
|
config = agent_config_repository.get_agent_shopify_config(agent_id)
|
|
if not config:
|
|
# Return a default config if none exists
|
|
raise HTTPException(status_code=404, detail="Shopify configuration not found for this agent")
|
|
return config
|
|
|
|
@router.post("/agent-config/{agent_id}", response_model=AgentShopifyConfig)
|
|
async def save_agent_shopify_config(
|
|
agent_id: str,
|
|
config: AgentShopifyConfigBase,
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Save Shopify configuration for an agent.
|
|
Automatically determines the shop ID for the organization.
|
|
Supports both session token auth (embedded) and JWT auth (dashboard).
|
|
"""
|
|
agent_config_repository = AgentShopifyConfigRepository(db)
|
|
shop_repository = ShopifyShopRepository(db)
|
|
|
|
# Try session token first (for embedded apps)
|
|
org_id_str = None
|
|
user_id = None
|
|
try:
|
|
shopify_session = await require_shopify_session(request, db)
|
|
# Session token valid - verify shop is linked to organization
|
|
if not shopify_session['organization_id']:
|
|
raise HTTPException(status_code=403, detail="Shop not linked to organization")
|
|
# Ensure org_id_str is always a string
|
|
org_id_str = str(shopify_session['organization_id'])
|
|
# For session token, we don't have user_id - use None (optional for knowledge queue)
|
|
logger.info(f"POST agent-config using session token for org: {org_id_str}")
|
|
except HTTPException:
|
|
# Fall back to JWT auth (for dashboard)
|
|
current_user = await get_current_user(request=request, db=db)
|
|
if not check_permissions(current_user, ["manage_organization"]):
|
|
raise HTTPException(status_code=403, detail="Insufficient permissions")
|
|
if not current_user.organization_id:
|
|
raise HTTPException(status_code=403, detail="User not linked to organization")
|
|
org_id_str = str(current_user.organization_id)
|
|
user_id = current_user.id
|
|
logger.info(f"POST agent-config using JWT auth for user: {current_user.id}")
|
|
|
|
# The agent being configured must belong to the resolved org.
|
|
_require_shopify_agent_in_org(db, agent_id, org_id_str)
|
|
|
|
# Get the current config for the agent, if it exists
|
|
existing_config = agent_config_repository.get_agent_shopify_config(agent_id)
|
|
|
|
# Automatically determine the shop ID for this organization
|
|
target_shop = None
|
|
|
|
# Find the available installed shop for the organization
|
|
shops = shop_repository.get_shops_by_organization(org_id_str, limit=10)
|
|
installed_shops = [s for s in shops if s.is_installed]
|
|
|
|
if installed_shops:
|
|
target_shop = installed_shops[0]
|
|
target_shop_id = target_shop.id
|
|
else:
|
|
target_shop_id = None
|
|
|
|
if not installed_shops and config.enabled:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Cannot enable Shopify integration: No installed Shopify shops found for this organization."
|
|
)
|
|
|
|
# --- Save Config to DB ---
|
|
try:
|
|
if existing_config:
|
|
# Update existing config
|
|
# Always use the automatically determined shop_id
|
|
update_config = AgentShopifyConfigUpdate(
|
|
enabled=config.enabled,
|
|
shop_id=target_shop_id if config.enabled else None
|
|
)
|
|
updated_config = agent_config_repository.update_agent_shopify_config(
|
|
agent_id, update_config
|
|
)
|
|
logger.info(f"Updated Shopify config for agent {agent_id}")
|
|
saved_config = updated_config
|
|
else:
|
|
# Create new config
|
|
# Always use the automatically determined shop_id
|
|
config_create_data = AgentShopifyConfigCreate(
|
|
agent_id=agent_id,
|
|
enabled=config.enabled,
|
|
shop_id=target_shop_id if config.enabled else None
|
|
)
|
|
new_config = agent_config_repository.create_agent_shopify_config(config_create_data)
|
|
logger.info(f"Created Shopify config for agent {agent_id}")
|
|
saved_config = new_config
|
|
|
|
# --- Link or Queue Knowledge Source ---
|
|
if config.enabled and target_shop:
|
|
try:
|
|
org_uuid = UUID(org_id_str)
|
|
agent_uuid = UUID(agent_id)
|
|
shop_domain = target_shop.shop_domain
|
|
|
|
if shop_domain:
|
|
knowledge_repo = KnowledgeRepository(db)
|
|
# Check if knowledge source already exists for this shop domain and org
|
|
existing_knowledge_list = knowledge_repo.get_by_sources(org_uuid, [shop_domain])
|
|
existing_knowledge = existing_knowledge_list[0] if existing_knowledge_list else None
|
|
|
|
if existing_knowledge is None:
|
|
# Knowledge doesn't exist, queue it
|
|
logger.info(f"Shop domain {shop_domain} not found in knowledge base for org {org_uuid}. Queuing...")
|
|
queue_repo = KnowledgeQueueRepository(db)
|
|
queue_item = KnowledgeQueue(
|
|
organization_id=org_uuid,
|
|
agent_id=agent_uuid, # Link to current agent
|
|
user_id=user_id, # user_id from auth (JWT) or None (session token)
|
|
source_type=SourceType.WEBSITE,
|
|
source=shop_domain,
|
|
status=QueueStatus.PENDING,
|
|
queue_metadata={}
|
|
)
|
|
queue_repo.create(queue_item)
|
|
logger.info(f"Shop domain {shop_domain} queued for knowledge processing for agent {agent_id}.")
|
|
else:
|
|
# Knowledge exists, check if linked to agent
|
|
logger.info(f"Shop domain {shop_domain} found in knowledge base (ID: {existing_knowledge.id}). Checking agent link...")
|
|
link_repo = KnowledgeToAgentRepository(db)
|
|
existing_link = link_repo.get_by_ids(existing_knowledge.id, agent_uuid)
|
|
if existing_link is None:
|
|
# Link doesn't exist, create it
|
|
logger.info(f"Linking knowledge source {existing_knowledge.id} to agent {agent_id}...")
|
|
link = KnowledgeToAgent(knowledge_id=existing_knowledge.id, agent_id=agent_uuid)
|
|
link_repo.create(link)
|
|
# Optional: Could add vector DB filter update here later if needed
|
|
logger.info(f"Successfully linked knowledge source {existing_knowledge.id} to agent {agent_id}.")
|
|
else:
|
|
logger.info(f"Knowledge source {existing_knowledge.id} already linked to agent {agent_id}.")
|
|
|
|
except Exception as ke:
|
|
# Log the error but don't fail the main config saving operation
|
|
logger.error(f"Failed to link or queue knowledge for shop {target_shop.id if target_shop else 'N/A'} / agent {agent_id}: {str(ke)}", exc_info=True)
|
|
|
|
return saved_config # Return the saved/updated config
|
|
except Exception as e:
|
|
logger.error(f"Failed to save agent Shopify config to DB: {str(e)}", exc_info=True)
|
|
raise HTTPException(status_code=500, detail="Failed to save Shopify configuration to database.")
|
|
|
|
@router.post("/webhooks/app-uninstalled")
|
|
async def shopify_app_uninstalled_webhook(
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Webhook handler for Shopify app uninstallation.
|
|
This endpoint is called by Shopify when a merchant uninstalls the app.
|
|
|
|
It performs the following cleanup:
|
|
1. Marks the shop as uninstalled (is_installed = False)
|
|
2. Disables all agent Shopify configs for this shop
|
|
3. Optionally: Can clear access tokens for security
|
|
|
|
Documentation: https://shopify.dev/docs/apps/build/webhooks/subscribe/get-started
|
|
"""
|
|
try:
|
|
# Get the request body and headers
|
|
request_body = await request.body()
|
|
request_headers = request.headers
|
|
|
|
# Verify the webhook signature
|
|
if not ShopifyHelperService.verify_shopify_webhook(request_headers, request_body):
|
|
logger.warning("Invalid webhook signature for app/uninstalled")
|
|
raise HTTPException(status_code=401, detail="Invalid webhook signature")
|
|
|
|
# Parse the webhook payload
|
|
try:
|
|
payload = json.loads(request_body.decode('utf-8'))
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Failed to parse webhook payload: {str(e)}")
|
|
raise HTTPException(status_code=400, detail="Invalid JSON payload")
|
|
|
|
# Extract shop domain from payload
|
|
# Shopify sends the shop domain in the payload
|
|
shop_domain = payload.get('domain') or payload.get('myshopify_domain')
|
|
|
|
if not shop_domain:
|
|
logger.error(f"No shop domain in webhook payload: {payload}")
|
|
raise HTTPException(status_code=400, detail="Missing shop domain in payload")
|
|
|
|
logger.info(f"Processing app uninstall webhook for shop: {shop_domain}")
|
|
|
|
# Initialize repositories
|
|
shop_repo = ShopifyShopRepository(db)
|
|
config_repo = AgentShopifyConfigRepository(db)
|
|
|
|
# Find the shop in our database
|
|
db_shop = shop_repo.get_shop_by_domain(shop_domain)
|
|
|
|
if not db_shop:
|
|
logger.warning(f"Shop not found in database: {shop_domain}")
|
|
# Return 200 anyway to acknowledge receipt
|
|
return {"success": True, "message": "Shop not found, no action needed"}
|
|
|
|
logger.info(f"Found shop in database: {db_shop.id}")
|
|
|
|
# Delete all agent configurations for this shop
|
|
configs = config_repo.get_configs_by_shop(str(db_shop.id))
|
|
deleted_configs = 0
|
|
|
|
for config in configs:
|
|
config_repo.delete_agent_shopify_config(config.agent_id)
|
|
deleted_configs += 1
|
|
logger.info(f"Deleted Shopify config for agent {config.agent_id}")
|
|
|
|
logger.info(f"Deleted {deleted_configs} agent config(s) for shop {shop_domain}")
|
|
|
|
# Delete the shop record from the database
|
|
shop_repo.delete_shop(str(db_shop.id))
|
|
logger.info(f"Deleted shop record for {shop_domain}")
|
|
|
|
# Commit the changes
|
|
db.commit()
|
|
|
|
logger.info(f"Successfully processed uninstall for {shop_domain}. Deleted shop and {deleted_configs} agent config(s)")
|
|
|
|
# Return 200 OK to acknowledge receipt
|
|
return {
|
|
"success": True,
|
|
"message": f"App uninstalled successfully for {shop_domain}",
|
|
"shop_domain": shop_domain,
|
|
"configs_deleted": deleted_configs
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error processing app uninstall webhook: {str(e)}")
|
|
logger.error(traceback.format_exc())
|
|
# Return 200 to prevent Shopify from retrying
|
|
# Log the error for investigation
|
|
return {
|
|
"success": False,
|
|
"message": "An internal error occurred while processing the uninstall webhook."
|
|
}
|
|
|
|
@router.post("/webhooks/customers/data_request")
|
|
async def shopify_customers_data_request_webhook(
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
GDPR Compliance Webhook: Customer Data Request
|
|
|
|
This webhook is called when a customer requests access to their data.
|
|
You must provide the customer's data within a specified timeframe.
|
|
|
|
Shopify sends the following information:
|
|
- shop_id: The ID of the shop
|
|
- shop_domain: The shop's domain
|
|
- customer: Customer information including email, phone
|
|
- orders_requested: List of order IDs the customer has placed
|
|
|
|
Documentation: https://shopify.dev/docs/apps/build/privacy-law-compliance
|
|
"""
|
|
try:
|
|
# Get the request body and headers
|
|
request_body = await request.body()
|
|
request_headers = request.headers
|
|
|
|
# Verify the webhook signature
|
|
if not ShopifyHelperService.verify_shopify_webhook(request_headers, request_body):
|
|
logger.warning("Invalid webhook signature for customers/data_request")
|
|
raise HTTPException(status_code=401, detail="Invalid webhook signature")
|
|
|
|
# Parse the webhook payload
|
|
try:
|
|
payload = json.loads(request_body.decode('utf-8'))
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Failed to parse webhook payload: {str(e)}")
|
|
raise HTTPException(status_code=400, detail="Invalid JSON payload")
|
|
|
|
shop_domain = payload.get('shop_domain')
|
|
customer = payload.get('customer', {})
|
|
customer_email = customer.get('email')
|
|
customer_phone = customer.get('phone')
|
|
orders_requested = payload.get('orders_requested', [])
|
|
|
|
logger.info(f"Received customer data request for shop: {shop_domain}, customer: {customer_email}")
|
|
|
|
# TODO: Implement data collection based on your data storage
|
|
# For now, we'll log the request and acknowledge receipt
|
|
# You should:
|
|
# 1. Collect all customer data you've stored (chat history, customer info, etc.)
|
|
# 2. Prepare it in a readable format (JSON, CSV, etc.)
|
|
# 3. Send it to the customer or make it available for download
|
|
# 4. Keep a record of the request for compliance
|
|
|
|
logger.info(f"Customer data request details:")
|
|
logger.info(f" - Shop: {shop_domain}")
|
|
logger.info(f" - Customer Email: {customer_email}")
|
|
logger.info(f" - Customer Phone: {customer_phone}")
|
|
logger.info(f" - Orders: {orders_requested}")
|
|
|
|
# In a production system, you would:
|
|
# 1. Query your chat_history table for this customer
|
|
# 2. Query any customer-specific data
|
|
# 3. Format and send the data to the customer
|
|
|
|
# Return 200 OK to acknowledge receipt
|
|
return {
|
|
"success": True,
|
|
"message": "Customer data request received and logged",
|
|
"shop_domain": shop_domain,
|
|
"customer_email": customer_email
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error processing customer data request webhook: {str(e)}")
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": "Error processing webhook"
|
|
}
|
|
|
|
@router.post("/webhooks/customers/redact")
|
|
async def shopify_customers_redact_webhook(
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
GDPR Compliance Webhook: Customer Data Erasure
|
|
|
|
This webhook is called when a customer requests their data to be deleted.
|
|
You must delete all customer data within a specified timeframe.
|
|
|
|
Shopify sends the following information:
|
|
- shop_id: The ID of the shop
|
|
- shop_domain: The shop's domain
|
|
- customer: Customer information including email, phone
|
|
- orders_to_redact: List of order IDs to redact
|
|
|
|
Documentation: https://shopify.dev/docs/apps/build/privacy-law-compliance
|
|
"""
|
|
try:
|
|
# Get the request body and headers
|
|
request_body = await request.body()
|
|
request_headers = request.headers
|
|
|
|
# Verify the webhook signature
|
|
if not ShopifyHelperService.verify_shopify_webhook(request_headers, request_body):
|
|
logger.warning("Invalid webhook signature for customers/redact")
|
|
raise HTTPException(status_code=401, detail="Invalid webhook signature")
|
|
|
|
# Parse the webhook payload
|
|
try:
|
|
payload = json.loads(request_body.decode('utf-8'))
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Failed to parse webhook payload: {str(e)}")
|
|
raise HTTPException(status_code=400, detail="Invalid JSON payload")
|
|
|
|
shop_domain = payload.get('shop_domain')
|
|
customer = payload.get('customer', {})
|
|
customer_email = customer.get('email')
|
|
customer_phone = customer.get('phone')
|
|
orders_to_redact = payload.get('orders_to_redact', [])
|
|
|
|
logger.info(f"Received customer redact request for shop: {shop_domain}, customer: {customer_email}")
|
|
|
|
# TODO: Implement data deletion based on your data storage
|
|
# For now, we'll log the request and acknowledge receipt
|
|
# You should:
|
|
# 1. Delete or anonymize all customer data (chat history, personal info, etc.)
|
|
# 2. Keep a minimal record for compliance (that the request was fulfilled)
|
|
# 3. Ensure the customer's data is no longer accessible
|
|
|
|
logger.info(f"Customer redact request details:")
|
|
logger.info(f" - Shop: {shop_domain}")
|
|
logger.info(f" - Customer Email: {customer_email}")
|
|
logger.info(f" - Customer Phone: {customer_phone}")
|
|
logger.info(f" - Orders to redact: {orders_to_redact}")
|
|
|
|
# In a production system, you would:
|
|
# 1. Find all chat_history records for this customer
|
|
# 2. Either delete them or anonymize the customer data
|
|
# 3. Remove any personally identifiable information (PII)
|
|
# 4. Keep a log that the request was fulfilled
|
|
|
|
# Example pseudocode:
|
|
# chat_repo = ChatHistoryRepository(db)
|
|
# if customer_email:
|
|
# chat_repo.delete_by_customer_email(customer_email, shop_domain)
|
|
# if customer_phone:
|
|
# chat_repo.delete_by_customer_phone(customer_phone, shop_domain)
|
|
|
|
# Return 200 OK to acknowledge receipt
|
|
return {
|
|
"success": True,
|
|
"message": "Customer data redaction request received and logged",
|
|
"shop_domain": shop_domain,
|
|
"customer_email": customer_email
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error processing customer redact webhook: {str(e)}")
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": "Error processing webhook"
|
|
}
|
|
|
|
@router.post("/webhooks/shop/redact")
|
|
async def shopify_shop_redact_webhook(
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
GDPR Compliance Webhook: Shop Data Erasure
|
|
|
|
This webhook is called 48 hours after a shop owner uninstalls your app.
|
|
You must delete all shop-related data.
|
|
|
|
Shopify sends the following information:
|
|
- shop_id: The ID of the shop
|
|
- shop_domain: The shop's domain
|
|
|
|
Documentation: https://shopify.dev/docs/apps/build/privacy-law-compliance
|
|
"""
|
|
try:
|
|
# Get the request body and headers
|
|
request_body = await request.body()
|
|
request_headers = request.headers
|
|
|
|
# Verify the webhook signature
|
|
if not ShopifyHelperService.verify_shopify_webhook(request_headers, request_body):
|
|
logger.warning("Invalid webhook signature for shop/redact")
|
|
raise HTTPException(status_code=401, detail="Invalid webhook signature")
|
|
|
|
# Parse the webhook payload
|
|
try:
|
|
payload = json.loads(request_body.decode('utf-8'))
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Failed to parse webhook payload: {str(e)}")
|
|
raise HTTPException(status_code=400, detail="Invalid JSON payload")
|
|
|
|
shop_domain = payload.get('shop_domain')
|
|
shop_id = payload.get('shop_id')
|
|
|
|
logger.info(f"Received shop redact request for shop: {shop_domain} (ID: {shop_id})")
|
|
|
|
# Initialize repositories
|
|
shop_repo = ShopifyShopRepository(db)
|
|
config_repo = AgentShopifyConfigRepository(db)
|
|
|
|
# Find the shop in our database
|
|
db_shop = shop_repo.get_shop_by_domain(shop_domain)
|
|
|
|
if not db_shop:
|
|
logger.warning(f"Shop not found in database: {shop_domain}")
|
|
# Return 200 anyway to acknowledge receipt
|
|
return {"success": True, "message": "Shop not found, no action needed"}
|
|
|
|
logger.info(f"Found shop in database: {db_shop.id}")
|
|
|
|
# Delete all agent configurations for this shop
|
|
configs = config_repo.get_configs_by_shop(str(db_shop.id))
|
|
deleted_configs = 0
|
|
|
|
for config in configs:
|
|
config_repo.delete_agent_shopify_config(config.agent_id)
|
|
deleted_configs += 1
|
|
logger.info(f"Deleted Shopify config for agent {config.agent_id}")
|
|
|
|
# TODO: Delete all shop-related data
|
|
# You should also:
|
|
# 1. Delete or anonymize all chat history related to this shop
|
|
# 2. Remove any customer data associated with this shop
|
|
# 3. Delete any cached product data
|
|
# 4. Remove any analytics data for this shop
|
|
|
|
# Example pseudocode:
|
|
# chat_repo = ChatHistoryRepository(db)
|
|
# chat_repo.delete_by_shop(shop_domain)
|
|
#
|
|
# customer_repo = CustomerRepository(db)
|
|
# customer_repo.delete_by_shop(shop_domain)
|
|
|
|
# Delete the shop record from the database
|
|
shop_repo.delete_shop(str(db_shop.id))
|
|
logger.info(f"Deleted shop record for {shop_domain}")
|
|
|
|
logger.info(f"Successfully redacted all data for shop {shop_domain}. Deleted {deleted_configs} config(s)")
|
|
|
|
# Return 200 OK to acknowledge receipt
|
|
return {
|
|
"success": True,
|
|
"message": f"Shop data redacted successfully for {shop_domain}",
|
|
"shop_domain": shop_domain,
|
|
"configs_deleted": deleted_configs
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error processing shop redact webhook: {str(e)}")
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": "Error processing webhook"
|
|
} |