hulai-admin-api/app/routers/about.py

from __future__ import annotations
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session

from app.database import get_db
from app.auth import get_current_user
from app.models.about import (
    AboutStory, AboutSubsidiary, AboutCertification, AboutTrademark,
    AboutCopyright, AboutGuarantee, AboutXiaohongshu, AboutTeam,
    AboutCulture, AboutCultureValue,
    AboutFounderDetail, AboutFounder, AboutMilestone,
    AboutServicePrinciple, AboutDifferentiation,
    AboutServiceJourney, AboutServiceMoment, AboutStats,
)
from app.schemas.about import (
    StorySchema, SubsidiarySchema, CertificationSchema, TrademarkSchema,
    CopyrightSchema, GuaranteeSchema, XiaohongshuSchema, TeamSchema,
    CultureSchema, FounderDetailSchema, FounderSchema, MilestoneSchema,
    ServicePrincipleSchema, DifferentiationSchema,
    ServiceJourneySchema, ServiceMomentSchema, AboutStatsSchema,
)

router = APIRouter(prefix="/api/about", tags=["关于我们"], dependencies=[Depends(get_current_user)])


# --- Story ---
@router.get("/story", response_model=StorySchema)
def get_story(db: Session = Depends(get_db)):
    story = db.query(AboutStory).first()
    if not story:
        return StorySchema()
    return StorySchema(
        title=story.title, content=story.content, founding_moment=story.founding_moment,
        totem_description=story.totem_description, totem_tagline=story.totem_tagline,
    )


@router.put("/story")
def update_story(req: StorySchema, db: Session = Depends(get_db)):
    story = db.query(AboutStory).first()
    if not story:
        story = AboutStory()
        db.add(story)
    story.title = req.title
    story.content = req.content
    story.founding_moment = req.founding_moment
    story.totem_description = req.totem_description
    story.totem_tagline = req.totem_tagline
    db.commit()
    return {"message": "更新成功"}


# --- Subsidiaries ---
@router.get("/subsidiaries", response_model=list[SubsidiarySchema])
def get_subsidiaries(db: Session = Depends(get_db)):
    items = db.query(AboutSubsidiary).order_by(AboutSubsidiary.sort_order).all()
    return [SubsidiarySchema(name=s.name, role=s.role, established=s.established) for s in items]


@router.put("/subsidiaries")
def update_subsidiaries(req: list[SubsidiarySchema], db: Session = Depends(get_db)):
    db.query(AboutSubsidiary).delete()
    for i, s in enumerate(req):
        db.add(AboutSubsidiary(name=s.name, role=s.role, established=s.established, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Certifications ---
@router.get("/certifications", response_model=list[CertificationSchema])
def get_certifications(db: Session = Depends(get_db)):
    items = db.query(AboutCertification).order_by(AboutCertification.sort_order).all()
    return [CertificationSchema(title=c.title, detail=c.detail) for c in items]


@router.put("/certifications")
def update_certifications(req: list[CertificationSchema], db: Session = Depends(get_db)):
    db.query(AboutCertification).delete()
    for i, c in enumerate(req):
        db.add(AboutCertification(title=c.title, detail=c.detail, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Trademark ---
@router.get("/trademark", response_model=TrademarkSchema)
def get_trademark(db: Session = Depends(get_db)):
    tm = db.query(AboutTrademark).first()
    if not tm:
        return TrademarkSchema()
    return TrademarkSchema(name=tm.name, scope=tm.scope, holder=tm.holder, description=tm.description)


@router.put("/trademark")
def update_trademark(req: TrademarkSchema, db: Session = Depends(get_db)):
    tm = db.query(AboutTrademark).first()
    if not tm:
        tm = AboutTrademark()
        db.add(tm)
    tm.name = req.name
    tm.scope = req.scope
    tm.holder = req.holder
    tm.description = req.description
    db.commit()
    return {"message": "更新成功"}


# --- Copyrights ---
@router.get("/copyrights", response_model=list[CopyrightSchema])
def get_copyrights(db: Session = Depends(get_db)):
    items = db.query(AboutCopyright).order_by(AboutCopyright.sort_order).all()
    return [CopyrightSchema(name=c.name, reg_no=c.reg_no, category=c.category, holder=c.holder, date=c.date, description=c.description) for c in items]


@router.put("/copyrights")
def update_copyrights(req: list[CopyrightSchema], db: Session = Depends(get_db)):
    db.query(AboutCopyright).delete()
    for i, c in enumerate(req):
        db.add(AboutCopyright(name=c.name, reg_no=c.reg_no, category=c.category, holder=c.holder, date=c.date, description=c.description, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Guarantees ---
@router.get("/guarantees", response_model=list[GuaranteeSchema])
def get_guarantees(db: Session = Depends(get_db)):
    items = db.query(AboutGuarantee).order_by(AboutGuarantee.sort_order).all()
    return [GuaranteeSchema(title=g.title, detail=g.detail) for g in items]


@router.put("/guarantees")
def update_guarantees(req: list[GuaranteeSchema], db: Session = Depends(get_db)):
    db.query(AboutGuarantee).delete()
    for i, g in enumerate(req):
        db.add(AboutGuarantee(title=g.title, detail=g.detail, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Xiaohongshu ---
@router.get("/xiaohongshu", response_model=XiaohongshuSchema)
def get_xiaohongshu(db: Session = Depends(get_db)):
    xhs = db.query(AboutXiaohongshu).first()
    if not xhs:
        return XiaohongshuSchema()
    return XiaohongshuSchema(
        account=xhs.account, verified=xhs.verified, verified_type=xhs.verified_type,
        followers=xhs.followers, likes=xhs.likes, awards=xhs.awards or [],
        tagline=xhs.tagline, tags=xhs.tags or [], description=xhs.description,
    )


@router.put("/xiaohongshu")
def update_xiaohongshu(req: XiaohongshuSchema, db: Session = Depends(get_db)):
    xhs = db.query(AboutXiaohongshu).first()
    if not xhs:
        xhs = AboutXiaohongshu()
        db.add(xhs)
    for key, val in req.model_dump().items():
        setattr(xhs, key, val)
    db.commit()
    return {"message": "更新成功"}


# --- Team ---
@router.get("/team", response_model=TeamSchema)
def get_team(db: Session = Depends(get_db)):
    team = db.query(AboutTeam).first()
    if not team:
        return TeamSchema()
    return TeamSchema(summary=team.summary)


@router.put("/team")
def update_team(req: TeamSchema, db: Session = Depends(get_db)):
    team = db.query(AboutTeam).first()
    if not team:
        team = AboutTeam()
        db.add(team)
    team.summary = req.summary
    db.commit()
    return {"message": "更新成功"}


# --- Culture ---
@router.get("/culture", response_model=CultureSchema)
def get_culture(db: Session = Depends(get_db)):
    culture = db.query(AboutCulture).first()
    if not culture:
        return CultureSchema()
    return CultureSchema(
        core=culture.core,
        transparency=culture.transparency,
        trust=culture.trust,
        grief_award_name=culture.grief_award_name,
        grief_award_description=culture.grief_award_description,
        values=[{"name": v.name, "expression": v.expression} for v in culture.values],
    )


@router.put("/culture")
def update_culture(req: CultureSchema, db: Session = Depends(get_db)):
    culture = db.query(AboutCulture).first()
    if not culture:
        culture = AboutCulture()
        db.add(culture)
        db.flush()
    culture.core = req.core
    culture.transparency = req.transparency
    culture.trust = req.trust
    culture.grief_award_name = req.grief_award_name
    culture.grief_award_description = req.grief_award_description

    db.query(AboutCultureValue).filter_by(culture_id=culture.id).delete()
    for i, v in enumerate(req.values):
        db.add(AboutCultureValue(culture_id=culture.id, name=v.name, expression=v.expression, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Founder Detail (单个创始人详细) ---
@router.get("/founder-detail", response_model=FounderDetailSchema)
def get_founder_detail(db: Session = Depends(get_db)):
    fd = db.query(AboutFounderDetail).first()
    if not fd:
        return FounderDetailSchema()
    return FounderDetailSchema(
        name=fd.name, title=fd.title, brand_founded=fd.brand_founded,
        years_in_hulunbuir=fd.years_in_hulunbuir, background=fd.background,
        expertise=fd.expertise or [], media_presence=fd.media_presence or [],
    )


@router.put("/founder-detail")
def update_founder_detail(req: FounderDetailSchema, db: Session = Depends(get_db)):
    fd = db.query(AboutFounderDetail).first()
    if not fd:
        fd = AboutFounderDetail()
        db.add(fd)
    fd.name = req.name
    fd.title = req.title
    fd.brand_founded = req.brand_founded
    fd.years_in_hulunbuir = req.years_in_hulunbuir
    fd.background = req.background
    fd.expertise = req.expertise
    fd.media_presence = req.media_presence
    db.commit()
    return {"message": "更新成功"}


# --- Founders (三位创始人简介列表) ---
@router.get("/founders", response_model=list[FounderSchema])
def get_founders(db: Session = Depends(get_db)):
    items = db.query(AboutFounder).order_by(AboutFounder.sort_order).all()
    return [FounderSchema(name=f.name, title=f.title, story=f.story) for f in items]


@router.put("/founders")
def update_founders(req: list[FounderSchema], db: Session = Depends(get_db)):
    db.query(AboutFounder).delete()
    for i, f in enumerate(req):
        db.add(AboutFounder(name=f.name, title=f.title, story=f.story, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Milestones ---
@router.get("/milestones", response_model=list[MilestoneSchema])
def get_milestones(db: Session = Depends(get_db)):
    items = db.query(AboutMilestone).order_by(AboutMilestone.sort_order).all()
    return [MilestoneSchema(year=m.year, event=m.event) for m in items]


@router.put("/milestones")
def update_milestones(req: list[MilestoneSchema], db: Session = Depends(get_db)):
    db.query(AboutMilestone).delete()
    for i, m in enumerate(req):
        db.add(AboutMilestone(year=m.year, event=m.event, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Service Principles ---
@router.get("/service-principles", response_model=list[ServicePrincipleSchema])
def get_service_principles(db: Session = Depends(get_db)):
    items = db.query(AboutServicePrinciple).order_by(AboutServicePrinciple.sort_order).all()
    return [ServicePrincipleSchema(text=p.text) for p in items]


@router.put("/service-principles")
def update_service_principles(req: list[ServicePrincipleSchema], db: Session = Depends(get_db)):
    db.query(AboutServicePrinciple).delete()
    for i, p in enumerate(req):
        db.add(AboutServicePrinciple(text=p.text, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Differentiation ---
@router.get("/differentiation", response_model=list[DifferentiationSchema])
def get_differentiation(db: Session = Depends(get_db)):
    items = db.query(AboutDifferentiation).order_by(AboutDifferentiation.sort_order).all()
    return [DifferentiationSchema(name=d.name, detail=d.detail) for d in items]


@router.put("/differentiation")
def update_differentiation(req: list[DifferentiationSchema], db: Session = Depends(get_db)):
    db.query(AboutDifferentiation).delete()
    for i, d in enumerate(req):
        db.add(AboutDifferentiation(name=d.name, detail=d.detail, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Service Journey ---
@router.get("/service-journey", response_model=ServiceJourneySchema)
def get_service_journey(db: Session = Depends(get_db)):
    sj = db.query(AboutServiceJourney).first()
    if not sj:
        return ServiceJourneySchema()
    return ServiceJourneySchema(
        title=sj.title,
        subtitle=sj.subtitle,
        moments=[ServiceMomentSchema(step=m.step, name=m.name, detail=m.detail) for m in sj.moments],
    )


@router.put("/service-journey")
def update_service_journey(req: ServiceJourneySchema, db: Session = Depends(get_db)):
    sj = db.query(AboutServiceJourney).first()
    if not sj:
        sj = AboutServiceJourney()
        db.add(sj)
        db.flush()
    sj.title = req.title
    sj.subtitle = req.subtitle
    db.query(AboutServiceMoment).filter_by(journey_id=sj.id).delete()
    for i, m in enumerate(req.moments):
        db.add(AboutServiceMoment(journey_id=sj.id, step=m.step, name=m.name, detail=m.detail, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


# --- Stats ---
@router.get("/stats", response_model=AboutStatsSchema)
def get_stats(db: Session = Depends(get_db)):
    s = db.query(AboutStats).first()
    if not s:
        return AboutStatsSchema()
    return AboutStatsSchema(data=s.data or {})


@router.put("/stats")
def update_stats(req: AboutStatsSchema, db: Session = Depends(get_db)):
    s = db.query(AboutStats).first()
    if not s:
        s = AboutStats()
        db.add(s)
    s.data = req.data
    db.commit()
    return {"message": "更新成功"}