ifixkart-backend/app/services/ReviewModerationService.py

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)
)