app/api/endpoints/partner.py

@@ -15,8 +15,6 @@ from app.models.community_set import CommunitySet
 from app.models.order import ShippingOrderDB, OrderStatus
 from app.models.community import CommunityDB
 from app.models.address import AddressDB
-from app.models.user import UserRole
-from app.core.response import error_response
 router = APIRouter()
 
 @router.get("/summary", response_model=ResponseModel)
@@ -178,154 +176,4 @@ async def partner_community_list(
     return success_response(data={"items": results, "total": total_count})
 
 
-@router.get("/community/{community_id}", response_model=ResponseModel)
-async def partner_community_detail(
-    community_id: int,
-    db: Session = Depends(get_db),
-    current_user: UserDB = Depends(get_current_user)
-):
-    """获取合伙人小区详情"""
-    community = db.query(CommunityDB).filter(CommunityDB.id == community_id).first()
-    if not community:
-        return error_response(message="小区不存在")
 
-    community_sets = db.query(CommunitySet).filter(
-                    CommunitySet.community_set_mappings.any(
-                        CommunitySetMapping.community_id == community_id
-                    )
-                ).all()
-    
-    partner_ids = [sets.user_id for sets in community_sets]
-    # 获取Partner列表
-    partner_list = db.query(UserDB).filter(UserDB.userid.in_(partner_ids)).all()
-    
-    partner_names = ",".join([partner.nickname for partner in partner_list])
-
-    # 小区用户数
-    user_count = db.query(AddressDB).filter(
-        AddressDB.community_id == community_id,
-        AddressDB.is_default == True
-    ).count()
-    
-    # 小区订单总量
-    total_order_count = db.query(ShippingOrderDB).filter(
-        ShippingOrderDB.address_community_id == community_id,
-        ShippingOrderDB.status == OrderStatus.COMPLETED
-    ).count()
-    
-    
-    # 小区今日、昨日订单总量
-    today_start = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    today_end = datetime.now().replace(hour=23, minute=59, second=59, microsecond=999999)
-    yesterday_start = today_start - timedelta(days=1)
-    yesterday_end = today_end - timedelta(days=1)
-
-    today_order_count = db.query(ShippingOrderDB).filter(
-        ShippingOrderDB.address_community_id == community_id,
-        ShippingOrderDB.create_time >= today_start,
-        ShippingOrderDB.create_time <= today_end,
-        ShippingOrderDB.status == OrderStatus.COMPLETED
-    ).count()
-
-    yesterday_order_count = db.query(ShippingOrderDB).filter(
-        ShippingOrderDB.address_community_id == community_id,
-        ShippingOrderDB.create_time >= yesterday_start,
-        ShippingOrderDB.create_time <= yesterday_end,
-        ShippingOrderDB.status == OrderStatus.COMPLETED
-    ).count()
-
-    # 小区总营收
-    total_income = db.query(func.sum(ShippingOrderDB.original_amount + ShippingOrderDB.additional_fee_amount)).filter(
-        ShippingOrderDB.address_community_id == community_id,
-        ShippingOrderDB.status == OrderStatus.COMPLETED
-    ).scalar()
-
-    # 小区今日、昨日收益
-    today_income = db.query(func.sum(ShippingOrderDB.original_amount + ShippingOrderDB.additional_fee_amount)).filter(
-        ShippingOrderDB.address_community_id == community_id,
-        ShippingOrderDB.create_time >= today_start,
-        ShippingOrderDB.create_time <= today_end,
-        ShippingOrderDB.status == OrderStatus.COMPLETED
-    ).scalar()
-
-    yesterday_income = db.query(func.sum(ShippingOrderDB.original_amount + ShippingOrderDB.additional_fee_amount)).filter(
-        ShippingOrderDB.address_community_id == community_id,
-        ShippingOrderDB.create_time >= yesterday_start,
-        ShippingOrderDB.create_time <= yesterday_end,
-        ShippingOrderDB.status == OrderStatus.COMPLETED
-    ).scalar()
-
-    # 配送员列表, 只查询有配送员的小区
-    delivery_list = db.query(UserDB).filter(UserDB.community_id == community_id, UserDB.roles.contains(UserRole.DELIVERYMAN)).all()
-    
-    delivery_data = []
-    for delivery in delivery_list:
-        # 累计订单数，累计收益
-        total_order_count = db.query(ShippingOrderDB).filter(
-            ShippingOrderDB.address_community_id == community_id,
-            ShippingOrderDB.status == OrderStatus.COMPLETED,
-            ShippingOrderDB.deliveryman_user_id == delivery.userid
-        ).count()
-
-        total_income = db.query(func.sum(ShippingOrderDB.original_amount + ShippingOrderDB.additional_fee_amount)).filter(
-            ShippingOrderDB.address_community_id == community_id,
-            ShippingOrderDB.status == OrderStatus.COMPLETED,
-            ShippingOrderDB.deliveryman_user_id == delivery.userid
-        ).scalar()
-
-        # 今日订单数，昨日订单数
-        today_order_count = db.query(ShippingOrderDB).filter(
-            ShippingOrderDB.address_community_id == community_id,
-            ShippingOrderDB.create_time >= today_start,
-            ShippingOrderDB.create_time <= today_end,
-            ShippingOrderDB.status == OrderStatus.COMPLETED,
-            ShippingOrderDB.deliveryman_user_id == delivery.userid
-        ).count()
-
-        yesterday_order_count = db.query(ShippingOrderDB).filter(
-            ShippingOrderDB.address_community_id == community_id,
-            ShippingOrderDB.create_time >= yesterday_start,
-            ShippingOrderDB.create_time <= yesterday_end,
-            ShippingOrderDB.status == OrderStatus.COMPLETED,
-            ShippingOrderDB.deliveryman_user_id == delivery.userid
-        ).count()
-
-        # 今日收益，昨日收益
-        today_income = db.query(func.sum(ShippingOrderDB.original_amount + ShippingOrderDB.additional_fee_amount)).filter(
-            ShippingOrderDB.address_community_id == community_id,
-            ShippingOrderDB.create_time >= today_start,
-            ShippingOrderDB.create_time <= today_end,
-            ShippingOrderDB.status == OrderStatus.COMPLETED,
-            ShippingOrderDB.deliveryman_user_id == delivery.userid
-        ).scalar()
-
-        yesterday_income = db.query(func.sum(ShippingOrderDB.original_amount + ShippingOrderDB.additional_fee_amount)).filter(
-            ShippingOrderDB.address_community_id == community_id,
-            ShippingOrderDB.create_time >= yesterday_start,
-            ShippingOrderDB.create_time <= yesterday_end,
-            ShippingOrderDB.status == OrderStatus.COMPLETED,
-            ShippingOrderDB.deliveryman_user_id == delivery.userid
-        ).scalar()
-
-        delivery_data.append({
-            "delivery_id": delivery.userid,
-            "delivery_name": delivery.nickname,
-            "total_order_count": total_order_count,
-            "total_income": 0 if total_income is None else total_income,
-            "today_order_count": today_order_count,
-            "yesterday_order_count": yesterday_order_count,
-            "today_income": 0 if today_income is None else today_income,
-            "yesterday_income": 0 if yesterday_income is None else yesterday_income
-        })
-
-    return success_response(data={
-        "community_name": community.name,
-        "partner_names": partner_names,
-        "user_count": user_count,
-        "total_order_count": total_order_count, 
-        "yesterday_order_count": yesterday_order_count,
-        "total_income": 0 if total_income is None else total_income,
-        "today_income": 0 if today_income is None else today_income,
-        "yesterday_income": 0 if yesterday_income is None else yesterday_income,
-        "delivery_list": delivery_data
-    })

app/models/settlement.py

@@ -1,39 +0,0 @@
-from sqlalchemy import Column, Integer, String, DateTime, JSON, Date, ForeignKey
-from sqlalchemy.sql import func
-from pydantic import BaseModel, Field
-from typing import Optional, Dict, Any
-from datetime import date, datetime
-from .database import Base
-from .community import CommunityDB
-
-class SettlementHistoryDB(Base):
-    """结算历史记录表"""
-    __tablename__ = "settlement_history"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    settle_date = Column(Date, nullable=False, index=True, comment="结算日期")
-    community_id = Column(Integer, ForeignKey("communities.id"), nullable=False, index=True, comment="小区ID")
-    community_name = Column(String(100), nullable=False, comment="小区名称")
-    settle_details = Column(JSON, nullable=False, comment="结算详情，JSON格式")
-    create_time = Column(DateTime(timezone=True), server_default=func.now(), comment="创建时间")
-
-    class Config:
-        orm_mode = True
-
-# Pydantic 模型
-class SettlementHistoryCreate(BaseModel):
-    settle_date: date
-    community_id: int
-    community_name: str
-    settle_details: Dict[str, Any]
-
-class SettlementHistoryInfo(BaseModel):
-    id: int
-    settle_date: date
-    community_id: int
-    community_name: str
-    settle_details: Dict[str, Any]
-    create_time: datetime
-
-    class Config:
-        from_attributes = True 

app/tasks/daily_tasks.py

@@ -15,9 +15,8 @@ from app.models.user import UserDB, UserRole
 from app.models.community_set import CommunitySet
 from app.models.community_set_mapping import CommunitySetMapping
 from app.core.account import AccountManager
-from app.models.settlement import SettlementHistoryDB
+
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
 
 async def daily_community_order_statistics():
     """每日小区订单统计任务
@@ -53,7 +52,7 @@ async def daily_community_order_statistics():
                     JOIN 
                         communities c ON o.address_community_id = c.id
                     WHERE 
-                        o.completed_time BETWEEN :start_time AND :end_time
+                        o.create_time BETWEEN :start_time AND :end_time
                         AND o.status = 'COMPLETED'
                     GROUP BY 
                         c.id, c.name
@@ -226,7 +225,6 @@ async def daily_partner_settlement():
         try:
             # 获取昨日订单统计数据
             yesterday = (datetime.now() - timedelta(days=1)).date()
-            print(yesterday)
             yesterday_stats = db.query(DailyCommunityOrderStats).filter(
                 DailyCommunityOrderStats.stats_date == yesterday
             ).all()
@@ -245,27 +243,8 @@ async def daily_partner_settlement():
             total_original_amount = 0
             total_final_amount = 0
 
-            settlement_history = []
             for stat in yesterday_stats:
-
+                print(stat.community_name)
-                # 检查是否已存在该日期的结算记录
-                existing_settlement = db.query(SettlementHistoryDB).filter(
-                    SettlementHistoryDB.settle_date == yesterday,
-                    SettlementHistoryDB.community_id == stat.community_id,
-                ).first()
-
-                if existing_settlement:
-                    logger.info(f"小区 {stat.community_name} 已存在结算记录，跳过结算")
-                    continue
-                
-
-                # 结算明细
-                settle_details = {
-                    "total_order_amount": stat.total_original_amount,
-                    "total_pay_amount": stat.total_final_amount
-                }
-
-                print(f"日期：{stat.stats_date} 小区: {stat.community_name} 订单数: {stat.order_count} 订单金额: {stat.total_original_amount} 支付金额: {stat.total_final_amount}")
                 total_order_count += stat.order_count
                 total_original_amount += stat.total_original_amount
                 total_final_amount += stat.total_final_amount
@@ -294,93 +273,48 @@ async def daily_partner_settlement():
                 platform_profit_sharing = community.community_profit_sharing.platform_rate
 
                 # 计算运营商分成金额
-                partner_profit = stat.total_final_amount * (float(partner_profit_sharing)) / 100
+                per_partner_profit = stat.total_final_amount * (float(partner_profit_sharing) / len(partner_ids)) / 100
-                admin_profit = stat.total_final_amount * (float(admin_profit_sharing) / 100)
-                delivery_profit = stat.total_final_amount * (float(delivery_profit_sharing) / 100)
-                platform_profit = stat.total_final_amount * (float(platform_profit_sharing) / 100)
-                
-                # 如果没有运营商、服务商，则需要沉淀到平台
-                profit_sediment = {
-                    "partner_profit": partner_profit,
-                    "admin_profit": admin_profit
-                }
 
                 # 计算每个运营商的分成金额
                 for partner_id in partner_ids:
-                    per_partner_profit = partner_profit / len(partner_ids)
+                    partner_profit = per_partner_profit
-                    print(f"运营商 {partner_id} 分成金额: {per_partner_profit}")
+                    print(f"运营商 {partner_id} 分成金额: {partner_profit}")
-                    total_partner_profit += per_partner_profit
+                    total_partner_profit += partner_profit
 
-                    settle_details["partner_profit"] = {
-                        "user_id": partner_id,
-                        "profit": per_partner_profit
-                    }
                     # 更新运营商账户余额
-                    if per_partner_profit > 0:
+                    if partner_profit > 0:
                         account_manager = AccountManager(db)
-                        account_manager.change_balance(partner_id, per_partner_profit, f"{stat.community_name} 订单收益")
+                        account_manager.change_balance(partner_id, partner_profit, f"{stat.community_name} 订单收益")
-
-                    # 计算沉淀金额
-                    profit_sediment["partner_profit"] -= per_partner_profit
 
                 
                 # 计算服务商分成
+                admin_profit = stat.total_final_amount * (float(admin_profit_sharing) / 100)
                 print(f"服务商分成金额: {admin_profit}")
                 total_admin_profit += admin_profit
 
-                settle_details["admin_profit"] = {
-                    "user_id": community.admin_id,
-                    "profit": admin_profit
-                }
-
                 if admin_profit > 0 and community.admin_id and community.admin_id > 0:
                     account_manager = AccountManager(db)
                     account_manager.change_balance(community.admin_id, admin_profit, f"{stat.community_name} 订单收益")
-                else:
-                    # 计算沉淀金额
-                    profit_sediment["admin_profit"] -= admin_profit
 
                 # 计算配送员分成
+                delivery_profit = stat.total_final_amount * (float(delivery_profit_sharing) / 100)
                 print(f"配送员分成金额: {delivery_profit}")
                 total_delivery_profit += delivery_profit
 
-                settle_details["delivery_profit"] = {
+                # if delivery_profit > 0:
-                    "user_id": 0,
+                #     account_manager = AccountManager(db)
-                    "profit": delivery_profit
+                #     account_manager.change_balance(community.admin_id, delivery_profit, f"{stat.community_name} 订单收益")
-                }
-
 
                 # 计算平台分成
-                # 计算分成 + 沉淀金额
+                platform_profit = stat.total_final_amount * (float(platform_profit_sharing) / 100)
-                final_platform_profit = platform_profit + profit_sediment["partner_profit"] + profit_sediment["admin_profit"]
+                print(f"平台分成金额: {platform_profit}")
+                total_platform_profit += platform_profit
 
-                print(f"平台分成 + 沉淀金额: {final_platform_profit}")
+                if platform_profit > 0:
-                total_platform_profit += final_platform_profit
-
-                
-                settle_details["platform_profit"] = {
-                    "user_id": settings.PLATFORM_USER_ID,
-                    "profit": final_platform_profit
-                }
-
-                
-                if final_platform_profit > 0:
                     account_manager = AccountManager(db)
-                    account_manager.change_balance(settings.PLATFORM_USER_ID, final_platform_profit, f"{stat.community_name} 订单收益")
+                    account_manager.change_balance(settings.PLATFORM_USER_ID, platform_profit, f"{stat.community_name} 订单收益")
 
             
-                # 保存结算明细
-                settlement = SettlementHistoryDB(
-                    settle_date=yesterday,
-                    community_id=stat.community_id,
-                    community_name=stat.community_name,
-                    settle_details=settle_details
-                )
-                settlement_history.append(settlement)
-
-            db.add_all(settlement_history)
-            db.commit()
-
             # 生成分润报告
             message = f"""### {yesterday.strftime("%Y-%m-%d")} 分润报告
 
@@ -392,7 +326,7 @@ async def daily_partner_settlement():
 > - 支付总金额: {total_final_amount:.1f}
 
 ### 分润汇总
-> - 运营商分成: {total_partner_profit:.1f}
+> - 合伙人分成: {total_partner_profit:.1f}
 > - 服务商分成: {total_admin_profit:.1f}
 > - 配送员分成: {total_delivery_profit:.1f}
 > - 平台分成: {total_platform_profit:.1f}
@@ -400,14 +334,13 @@ async def daily_partner_settlement():
 """
             
             # 发送企业微信消息
-            try:
+            if total_partner_profit + total_admin_profit + total_delivery_profit + total_platform_profit > 0 and settings.URL_WECOMBOT_DAILY_REPORT:
-                wecom_bot = WecomBot(settings.URL_WECOMBOT_DAILY_REPORT)
+                try:
-                await wecom_bot.send_markdown(message)
+                    wecom_bot = WecomBot(settings.URL_WECOMBOT_DAILY_REPORT)
-                logger.info("每日合伙人结算报告已发送到企业微信")
+                    await wecom_bot.send_markdown(message)
-            except Exception as e:
+                    logger.info("每日合伙人结算报告已发送到企业微信")
-                logger.error(f"发送企业微信消息失败: {str(e)}")
+                except Exception as e:
-
+                    logger.error(f"发送企业微信消息失败: {str(e)}")
-                
         except Exception as e:
             db.rollback()
             logger.error(f"运行每日合伙人结算任务失败: {str(e)}")