kunthawat/ALwrity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Sprint 1 - Deep discovery, lead persistence, and dashboard nav

Browse Source 
- Add BacklinkOutreachScraper (Exa + DuckDuckGo deep scraping)
- Extend DB and Pydantic models for lead enrichment columns
- Add StorageService methods for lead CRUD with auto-migration
- Add backend endpoints: deep discover, campaign detail, lead management
- Extend frontend API client and store with discovery + lead actions
- Create BacklinkOutreachDashboard component with campaigns/discover/leads tabs
- Register route at /backlink-outreach under SEO feature flag
- Add nav entry under Enterprise & Advanced in tool categories
This commit is contained in:
ajaysi
2026-05-23 17:07:33 +05:30
parent 816d59a30a
commit 090d69761f
22 changed files with 3494 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
backend/routers/backlink_outreach.py
View File

@@ -1,8 +1,12 @@
"""Backlink outreach router."""
from fastapi import APIRouter, Query
from fastapi import APIRouter, Query, HTTPException
from services.backlink_outreach_models import BacklinkDiscoveryResponse, BacklinkKeywordInput, PolicyValidationRequest, PolicyValidationResponse
from services.backlink_outreach_models import (
BacklinkDiscoveryResponse, BacklinkKeywordInput, DeepKeywordInput,
LeadCreateRequest, LeadStatusUpdateRequest,
PolicyValidationRequest, PolicyValidationResponse,
)
from services.backlink_outreach_service import backlink_outreach_service
from services.backlink_outreach_storage import BacklinkOutreachStorageService
from pydantic import BaseModel, Field
@@ -31,6 +35,31 @@ async def discover_backlink_opportunities(payload: BacklinkKeywordInput):
return backlink_outreach_service.discover_opportunities(payload.keyword, payload.max_results)
@router.post("/discover/deep")
async def discover_deep_backlink_opportunities(payload: DeepKeywordInput):
"""Enhanced discovery using Exa neural search + DuckDuckGo with full-page scraping."""
result = await backlink_outreach_service.deep_discover(payload.keyword, payload.max_results)
if payload.campaign_id:
storage = BacklinkOutreachStorageService()
user_id = "default"
for opp in result.get("opportunities", []):
try:
storage.add_lead(
campaign_id=payload.campaign_id,
user_id=user_id,
url=opp["url"],
domain=opp["domain"],
page_title=opp.get("page_title", ""),
snippet=opp.get("snippet", ""),
email=opp.get("email"),
confidence_score=opp.get("confidence_score", 0.0),
discovery_source=opp.get("discovery_source", "duckduckgo"),
)
except Exception:
continue
return result
@router.post("/campaigns")
async def create_backlink_campaign(payload: BacklinkCampaignCreateRequest):
storage = BacklinkOutreachStorageService()
@@ -43,6 +72,57 @@ async def list_backlink_campaigns(user_id: str, workspace_id: str, limit: int =
return {"campaigns": storage.list_campaigns(user_id, workspace_id, limit)}
@router.get("/campaigns/{campaign_id}")
async def get_backlink_campaign(campaign_id: str, user_id: str = Query(...)):
"""Get campaign detail with leads."""
storage = BacklinkOutreachStorageService()
campaign = storage.get_campaign(campaign_id, user_id)
if not campaign:
raise HTTPException(status_code=404, detail="Campaign not found")
return campaign
@router.get("/campaigns/{campaign_id}/leads")
async def list_campaign_leads(
campaign_id: str, user_id: str = Query(...), status: str = Query(None)
):
"""List leads for a campaign, optionally filtered by status."""
storage = BacklinkOutreachStorageService()
leads = storage.list_leads(campaign_id, user_id, status=status or None)
return {"leads": leads, "total": len(leads)}
@router.post("/campaigns/{campaign_id}/leads")
async def add_campaign_lead(campaign_id: str, payload: LeadCreateRequest):
"""Add a single lead to a campaign."""
storage = BacklinkOutreachStorageService()
try:
lead = storage.add_lead(
campaign_id=payload.campaign_id,
user_id="default",
url=payload.url,
domain=payload.domain,
page_title=payload.page_title or "",
snippet=payload.snippet or "",
email=payload.email,
confidence_score=payload.confidence_score,
notes=payload.notes,
)
return lead
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@router.patch("/leads/{lead_id}/status")
async def update_lead_status(lead_id: str, payload: LeadStatusUpdateRequest):
"""Update lead status (discovered -> contacted -> replied -> placed)."""
storage = BacklinkOutreachStorageService()
lead = storage.update_lead_status(lead_id, "default", payload.status, payload.notes)
if not lead:
raise HTTPException(status_code=404, detail="Lead not found")
return lead
@router.post("/policy-validate", response_model=PolicyValidationResponse)
async def validate_outreach_policy(payload: PolicyValidationRequest):
return backlink_outreach_service.validate_send_policy(payload)

245
backend/routers/seo_tools.py
View File

@@ -29,6 +29,7 @@ from services.seo_tools.opengraph_service import OpenGraphService
from services.seo_tools.on_page_seo_service import OnPageSEOService
from services.seo_tools.technical_seo_service import TechnicalSEOService
from services.seo_tools.enterprise_seo_service import EnterpriseSEOService
from services.seo_tools.gsc_analyzer_service import GSCAnalyzerService
from services.seo_tools.content_strategy_service import ContentStrategyService
from services.database import get_session_for_user
from api.content_planning.services.content_strategy.onboarding import OnboardingDataIntegrationService
@@ -128,6 +129,28 @@ class CompetitiveSitemapBenchmarkingRunRequest(BaseModel):
max_competitors: int = Field(default=5, ge=1, le=10, description="Max competitors to analyze")
competitors: Optional[List[HttpUrl]] = Field(None, description="Optional explicit competitor URLs")
class EnterpriseAuditRequest(BaseModel):
"""Request model for complete enterprise SEO audit"""
website_url: HttpUrl = Field(..., description="Primary website URL to audit")
competitors: Optional[List[HttpUrl]] = Field(None, description="Competitor URLs for benchmarking (max 5)")
target_keywords: Optional[List[str]] = Field(None, description="Target keywords for analysis")
include_content_analysis: bool = Field(default=True, description="Include content strategy analysis")
include_competitive_analysis: bool = Field(default=True, description="Include competitive benchmarking")
generate_executive_report: bool = Field(default=True, description="Generate executive summary")
class GSCAnalysisRequest(BaseModel):
"""Request model for advanced GSC analysis"""
site_url: HttpUrl = Field(..., description="Website URL registered in Google Search Console")
date_range_days: int = Field(default=90, ge=7, le=365, description="Number of days to analyze")
include_opportunities: bool = Field(default=True, description="Include content opportunity analysis")
include_competitive: bool = Field(default=True, description="Include competitive positioning")
class ContentOpportunitiesRequest(BaseModel):
"""Request model for content opportunities report"""
site_url: HttpUrl = Field(..., description="Website URL registered in GSC")
min_impressions: int = Field(default=100, ge=10, description="Minimum impressions threshold")
date_range_days: int = Field(default=90, ge=7, le=365, description="Number of days to analyze")
# Exception Handler
async def handle_seo_tool_exception(func_name: str, error: Exception, request_data: Dict) -> ErrorResponse:
"""Handle exceptions from SEO tools with intelligent logging"""
@@ -836,3 +859,225 @@ async def get_tools_status() -> BaseResponse:
"timestamp": datetime.utcnow().isoformat()
}
)
# ==================== ENTERPRISE AUDIT ENDPOINTS ====================
@router.post("/enterprise/complete-audit", response_model=BaseResponse)
@log_api_call
async def execute_enterprise_audit(
request: EnterpriseAuditRequest,
background_tasks: BackgroundTasks,
current_user: dict = Depends(get_current_user)
) -> Union[BaseResponse, ErrorResponse]:
"""
Execute comprehensive enterprise SEO audit with full orchestration.
Combines multiple SEO analysis tools into an intelligent workflow:
- Technical SEO audit with issue severity classification
- On-page SEO analysis with keyword optimization
- PageSpeed Insights with Core Web Vitals analysis
- Sitemap analysis with trend detection
- Content strategy with competitive comparison
- Competitive benchmarking across specified competitors
- AI-powered insights and recommendations
Returns prioritized action items with implementation roadmap.
"""
start_time = datetime.utcnow()
try:
logger.info(f"Starting enterprise audit for {request.website_url}")
# Initialize service
enterprise_service = EnterpriseSEOService()
# Execute audit
audit_result = await enterprise_service.execute_complete_audit(
website_url=str(request.website_url),
competitors=[str(c) for c in request.competitors] if request.competitors else [],
target_keywords=request.target_keywords or [],
include_content_analysis=request.include_content_analysis,
include_competitive_analysis=request.include_competitive_analysis,
generate_executive_report=request.generate_executive_report
)
execution_time = (datetime.utcnow() - start_time).total_seconds()
return BaseResponse(
success=True,
message="Complete enterprise audit executed successfully",
execution_time=execution_time,
data=audit_result
)
except Exception as e:
logger.error(f"Enterprise audit failed: {str(e)}", exc_info=True)
return await handle_seo_tool_exception("execute_enterprise_audit", e, request.dict())
@router.post("/enterprise/quick-audit", response_model=BaseResponse)
@log_api_call
async def execute_quick_enterprise_audit(
website_url: HttpUrl,
current_user: dict = Depends(get_current_user)
) -> Union[BaseResponse, ErrorResponse]:
"""
Execute quick 5-minute enterprise audit focusing on critical issues.
Provides rapid assessment of most critical SEO problems:
- Technical SEO critical issues
- PageSpeed performance bottlenecks
- Top 3 actionable recommendations
- Estimated business impact
"""
start_time = datetime.utcnow()
try:
logger.info(f"Starting quick audit for {website_url}")
enterprise_service = EnterpriseSEOService()
audit_result = await enterprise_service.execute_quick_audit(str(website_url))
execution_time = (datetime.utcnow() - start_time).total_seconds()
return BaseResponse(
success=True,
message="Quick audit completed",
execution_time=execution_time,
data=audit_result
)
except Exception as e:
return await handle_seo_tool_exception("execute_quick_enterprise_audit", e, {"website_url": str(website_url)})
# ==================== ADVANCED GSC ANALYSIS ENDPOINTS ====================
@router.post("/gsc/analyze-search-performance", response_model=BaseResponse)
@log_api_call
async def analyze_gsc_search_performance(
request: GSCAnalysisRequest,
current_user: dict = Depends(get_current_user)
) -> Union[BaseResponse, ErrorResponse]:
"""
Advanced Google Search Console analysis with comprehensive insights.
Provides deep dive into search performance:
- Performance overview with aggregated metrics
- Keyword analysis with trend detection
- Page-level performance breakdown
- Content opportunity identification (15+ opportunities scored)
- Technical SEO signal analysis
- Competitive positioning assessment
- AI-powered strategic recommendations
Each analysis component includes:
- Current metrics and trends
- Performance scores (0-100)
- Actionable recommendations
- Implementation priority
"""
start_time = datetime.utcnow()
try:
logger.info(f"Starting GSC analysis for {request.site_url}")
user_id = str(current_user.get("id")) if current_user else None
gsc_service = GSCAnalyzerService()
analysis_result = await gsc_service.analyze_search_performance(
site_url=str(request.site_url),
date_range_days=request.date_range_days,
user_id=user_id
)
execution_time = (datetime.utcnow() - start_time).total_seconds()
return BaseResponse(
success=True,
message="GSC search performance analysis completed",
execution_time=execution_time,
data=analysis_result
)
except Exception as e:
logger.error(f"GSC analysis failed: {str(e)}", exc_info=True)
return await handle_seo_tool_exception("analyze_gsc_search_performance", e, request.dict())
@router.post("/gsc/content-opportunities", response_model=BaseResponse)
@log_api_call
async def get_content_opportunities_report(
request: ContentOpportunitiesRequest,
current_user: dict = Depends(get_current_user)
) -> Union[BaseResponse, ErrorResponse]:
"""
Generate detailed content opportunities report from GSC data.
Identifies high-priority content gaps and optimization opportunities:
- Queries with high volume but low CTR (meta/title optimization)
- Keywords ranking 4-10 (ready for ranking improvement)
- Long-tail keywords with expansion potential
- Competitive white space analysis
For each opportunity includes:
- Current position and metrics
- Estimated traffic gain
- Optimization strategy
- Implementation difficulty
- Phased roadmap (Phase 1, 2, 3)
"""
start_time = datetime.utcnow()
try:
logger.info(f"Generating content opportunities for {request.site_url}")
gsc_service = GSCAnalyzerService()
report = await gsc_service.get_content_opportunities_report(
site_url=str(request.site_url),
min_impressions=request.min_impressions,
date_range_days=request.date_range_days
)
execution_time = (datetime.utcnow() - start_time).total_seconds()
return BaseResponse(
success=True,
message="Content opportunities report generated",
execution_time=execution_time,
data=report
)
except Exception as e:
logger.error(f"Content opportunities report failed: {str(e)}", exc_info=True)
return await handle_seo_tool_exception("get_content_opportunities_report", e, request.dict())
@router.get("/enterprise/health", response_model=BaseResponse)
@log_api_call
async def check_enterprise_services_health() -> BaseResponse:
"""Health check for enterprise services"""
try:
enterprise_service = EnterpriseSEOService()
gsc_service = GSCAnalyzerService()
enterprise_health = await enterprise_service.health_check()
gsc_health = await gsc_service.health_check()
return BaseResponse(
success=True,
message="Enterprise services health check completed",
data={
"enterprise_seo_service": enterprise_health,
"gsc_analyzer_service": gsc_health,
"timestamp": datetime.utcnow().isoformat()
}
)
except Exception as e:
logger.error(f"Enterprise health check failed: {str(e)}")
return BaseResponse(
success=False,
message="Enterprise health check failed",
data={"error": str(e)}
)

15
backend/routers/wordpress.py
View File

@@ -14,7 +14,7 @@ from services.integrations.wordpress_publisher import WordPressPublisher
from middleware.auth_middleware import get_current_user
router = APIRouter(prefix="/wordpress", tags=["WordPress"])
router = APIRouter(prefix="/api/wordpress", tags=["WordPress"])
# Pydantic Models
@@ -87,10 +87,9 @@ async def get_wordpress_status(user: dict = Depends(get_current_user)):
logger.info(f"Checking WordPress status for user: {user_id}")
# Get user's WordPress sites
sites = wp_service.get_all_sites(user_id)
sites = wp_service.get_user_sites(user_id)
if sites:
# Convert to response format
site_responses = [
WordPressSiteResponse(
id=site['id'],
@@ -103,15 +102,13 @@ async def get_wordpress_status(user: dict = Depends(get_current_user)):
)
for site in sites
]
logger.info(f"Found {len(sites)} WordPress sites for user {user_id}")
return WordPressStatusResponse(
connected=True,
sites=site_responses,
total_sites=len(sites)
)
else:
logger.info(f"No WordPress sites found for user {user_id}")
return WordPressStatusResponse(
connected=False,
sites=[],
@@ -152,7 +149,7 @@ async def add_wordpress_site(
)
# Get the added site info
sites = wp_service.get_all_sites(user_id)
sites = wp_service.get_user_sites(user_id)
if sites:
latest_site = sites[0] # Most recent site
return WordPressSiteResponse(
@@ -184,7 +181,7 @@ async def get_wordpress_sites(user: dict = Depends(get_current_user)):
logger.info(f"Getting WordPress sites for user: {user_id}")
sites = wp_service.get_all_sites(user_id)
sites = wp_service.get_user_sites(user_id)
site_responses = [
WordPressSiteResponse(