- Backend: FastAPI app with all models, services, schemas, routes - Admin Panel: Next.js dashboard with all modules (CRM, POS, repairs, warranties, billing, notifications, etc.) - Ecommerce: storefront (submodule) + product catalog - AI Agents: .agents/ skill library for Antigravity IDE - Docs: architecture, billing, notification gateway markdown - Submodules: Backend/OpenWA, Ecommerce/File 2/storefront
151 lines
5.6 KiB
Python
151 lines
5.6 KiB
Python
from datetime import datetime, timezone
|
|
from typing import List, Optional
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy import func
|
|
from fastapi import HTTPException, status
|
|
|
|
from app.models.ReviewModel import CustomerReview
|
|
from app.schemas.ReviewModeration import ReviewCreate, ReviewModerateAction, CSATMetricsResponse
|
|
from app.core.events.event_publisher import publish_event
|
|
|
|
PROFANITY_BLOCKLIST = {"scam", "cheat", "fraud", "fake", "spam", "abusive", "hate", "terrible", "worst"}
|
|
|
|
class ReviewModerationService:
|
|
def __init__(self, db: Session, tenant_id: str):
|
|
self.db = db
|
|
self.tenant_id = tenant_id
|
|
|
|
def submit_review(self, payload: ReviewCreate) -> CustomerReview:
|
|
# Check profanity blocklist
|
|
comment_lower = payload.comment.lower()
|
|
contains_blocked = any(word in comment_lower for word in PROFANITY_BLOCKLIST)
|
|
|
|
is_verified = bool(payload.order_id or payload.repair_ticket_id)
|
|
csat_score = float(payload.rating * 20.0)
|
|
|
|
if contains_blocked:
|
|
mod_status = "FLAGGED"
|
|
is_pub = False
|
|
mod_reason = "Auto-flagged by AI Moderation Engine: contains flagged terms."
|
|
else:
|
|
mod_status = "PENDING_MODERATION"
|
|
is_pub = False
|
|
mod_reason = None
|
|
|
|
review = CustomerReview(
|
|
tenant_id=self.tenant_id,
|
|
customer_id=payload.customer_id,
|
|
target_type=payload.target_type.upper(),
|
|
target_id=payload.target_id,
|
|
order_id=payload.order_id,
|
|
repair_ticket_id=payload.repair_ticket_id,
|
|
rating=payload.rating,
|
|
title=payload.title,
|
|
comment=payload.comment,
|
|
moderation_status=mod_status,
|
|
moderation_reason=mod_reason,
|
|
is_verified_buyer=is_verified,
|
|
is_published=is_pub,
|
|
csat_score=csat_score
|
|
)
|
|
self.db.add(review)
|
|
self.db.commit()
|
|
self.db.refresh(review)
|
|
|
|
publish_event(
|
|
stream_name="review_stream",
|
|
event_type="review.submitted",
|
|
payload={
|
|
"review_id": review.review_id,
|
|
"tenant_id": self.tenant_id,
|
|
"target_type": review.target_type,
|
|
"target_id": review.target_id,
|
|
"status": review.moderation_status
|
|
},
|
|
tenant_id=self.tenant_id
|
|
)
|
|
return review
|
|
|
|
def moderate_review(self, review_id: str, action: ReviewModerateAction, moderator_id: str) -> CustomerReview:
|
|
review = self.db.query(CustomerReview).filter(
|
|
CustomerReview.review_id == review_id,
|
|
CustomerReview.tenant_id == self.tenant_id
|
|
).first()
|
|
|
|
if not review:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Review not found")
|
|
|
|
review.moderation_status = action.status.upper()
|
|
review.moderation_reason = action.reason
|
|
review.is_published = (review.moderation_status == "APPROVED")
|
|
review.moderated_by = moderator_id
|
|
review.moderated_at = datetime.now(timezone.utc)
|
|
|
|
self.db.commit()
|
|
self.db.refresh(review)
|
|
|
|
publish_event(
|
|
stream_name="review_stream",
|
|
event_type="review.moderated",
|
|
payload={
|
|
"review_id": review.review_id,
|
|
"tenant_id": self.tenant_id,
|
|
"status": review.moderation_status,
|
|
"is_published": review.is_published
|
|
},
|
|
tenant_id=self.tenant_id
|
|
)
|
|
return review
|
|
|
|
def list_reviews(
|
|
self,
|
|
skip: int = 0,
|
|
limit: int = 50,
|
|
moderation_status: Optional[str] = None,
|
|
target_type: Optional[str] = None,
|
|
target_id: Optional[str] = None,
|
|
published_only: bool = False
|
|
) -> List[CustomerReview]:
|
|
q = self.db.query(CustomerReview).filter(CustomerReview.tenant_id == self.tenant_id)
|
|
if moderation_status:
|
|
q = q.filter(CustomerReview.moderation_status == moderation_status.upper())
|
|
if target_type:
|
|
q = q.filter(CustomerReview.target_type == target_type.upper())
|
|
if target_id:
|
|
q = q.filter(CustomerReview.target_id == target_id)
|
|
if published_only:
|
|
q = q.filter(CustomerReview.is_published == True)
|
|
|
|
return q.order_by(CustomerReview.created_at.desc()).offset(skip).limit(limit).all()
|
|
|
|
def get_csat_metrics(self, target_type: str, target_id: str) -> CSATMetricsResponse:
|
|
reviews = self.db.query(CustomerReview).filter(
|
|
CustomerReview.tenant_id == self.tenant_id,
|
|
CustomerReview.target_type == target_type.upper(),
|
|
CustomerReview.target_id == target_id,
|
|
CustomerReview.is_published == True
|
|
).all()
|
|
|
|
if not reviews:
|
|
return CSATMetricsResponse(
|
|
target_type=target_type,
|
|
target_id=target_id,
|
|
average_rating=0.0,
|
|
total_reviews=0,
|
|
verified_reviews_count=0,
|
|
csat_index_percentage=0.0
|
|
)
|
|
|
|
total_count = len(reviews)
|
|
avg_rating = sum(r.rating for r in reviews) / total_count
|
|
avg_csat = sum(r.csat_score for r in reviews) / total_count
|
|
verified_count = sum(1 for r in reviews if r.is_verified_buyer)
|
|
|
|
return CSATMetricsResponse(
|
|
target_type=target_type,
|
|
target_id=target_id,
|
|
average_rating=round(avg_rating, 2),
|
|
total_reviews=total_count,
|
|
verified_reviews_count=verified_count,
|
|
csat_index_percentage=round(avg_csat, 2)
|
|
)
|