家政小程序接单派单系统全链路开发实践:从用户下单到服务人员履约

简介: 本文详解家政服务(月嫂/保姆)接单派单系统设计,针对其长周期、预约制、高匹配精度等特性,提出档期预检、技能/区域多维匹配、智能排序、超时重试及人工兜底等核心方案,并附Python实现代码,覆盖订单校验、调度派单、消息推送与超时处理全链路。

家政社区服务1.jpg 家政社区服务2.jpg 家政社区服务3.jpg

一、业务场景与技术挑战

保姆、月嫂类家政服务与普通即时服务(如外卖、打车)有本质区别:服务周期长(数天到数月)、预约制为主、匹配精度要求高、档期冲突敏感。这些特点决定了其接单派单系统不能简单套用"抢单"或"最近司机优先"的逻辑,而需要一套专门设计的调度方案。

本文从小程序端的用户下单流程出发,完整梳理后端接单派单系统的设计思路,覆盖以下核心环节:

  • 用户端下单与需求描述
  • 服务端订单受理与校验
  • 服务人员匹配与智能派单
  • 服务人员端接单/拒单处理
  • 派单超时与兜底重试机制

二、整体流程设计

用户下单流程

用户在小程序端完成下单操作,需要采集的关键信息包括:

  • 服务类型:月嫂、住家保姆、白班保姆、育儿嫂等。
  • 服务地址:通过小程序的地图选点或地址输入获取经纬度,用于后续区域匹配。
  • 服务时间:开始日期和预计结束日期(月嫂通常26天或42天为一期),用于档期校验。
  • 特殊需求:如"需要会做月子餐""需要有催乳经验""家中有宠物"等,转化为技能标签用于匹配。
  • 预算范围:用户可接受的月费区间,用于过滤价格不匹配的服务人员。

小程序端提交后,后端首先进行订单校验:检查服务时间是否合理(不能早于当前时间)、地址是否在平台服务范围内、是否存在重复订单等。校验通过后订单进入待派单状态。

派单调度流程

订单进入待派单队列后,调度器按以下步骤执行:

  1. 档期预检:查询目标服务时间段内档期空闲的服务人员,排除已被预定的候选人。
  2. 技能匹配:根据订单中的服务类型和特殊需求标签,筛选具备对应技能的服务人员。
  3. 区域匹配:根据服务地址的GeoHash网格,优先匹配同网格或相邻网格的服务人员。
  4. 综合排序:对通过前三步筛选的候选人按评分、经验、负载等维度加权打分,选出Top候选。
  5. 派单推送:向排名第一的服务人员推送派单消息(小程序订阅消息或模板消息),同时设置接单超时时间(如30分钟)。

接单与兜底机制

服务人员收到派单推送后,有三种操作:

  • 接单:订单状态变为"已接单",锁定该服务人员的档期,通知用户。
  • 拒单:记录拒单原因,调度器自动派单给下一位候选人。
  • 超时未响应:等同于拒单处理,自动流转至下一位。

当所有候选人都拒单或超时后,订单进入人工调度队列,由运营人员手动协调安排。


三、核心代码实现

订单受理与派单调度器

以下代码实现了订单受理校验、档期预检、多维匹配和派单推送的完整调度链路。

from dataclasses import dataclass, field
from typing import Optional
from enum import Enum
from datetime import datetime, timedelta
from collections import defaultdict


class OrderStatus(Enum):
    PENDING = "pending"           # 待派单
    DISPATCHED = "dispatched"     # 已派单待响应
    ACCEPTED = "accepted"         # 已接单
    REJECTED = "rejected"         # 被拒单
    EXPIRED = "expired"           # 派单超时
    MANUAL = "manual"             # 转人工调度
    COMPLETED = "completed"       # 服务完成


@dataclass
class ServiceOrder:
    """家政服务订单"""
    order_id: str
    user_id: str
    service_type: str                    # 月嫂/保姆/育儿嫂
    service_address: str
    latitude: float
    longitude: float
    grid_id: str                         # 服务地址对应的GeoHash网格
    start_date: str
    end_date: str
    required_skills: list = field(default_factory=list)
    budget_min: float = 0.0
    budget_max: float = 0.0
    special_notes: str = ""
    status: OrderStatus = OrderStatus.PENDING
    assigned_worker_id: Optional[str] = None
    dispatch_history: list = field(default_factory=list)


@dataclass
class WorkerSlot:
    """服务人员档期记录"""
    worker_id: str
    start_date: str
    end_date: str
    order_id: str


class DispatchScheduler:
    """家政订单派单调度器"""

    def __init__(self):
        self.orders = {}                          # order_id -> ServiceOrder
        self.worker_schedules = defaultdict(list) # worker_id -> [WorkerSlot]
        self.worker_pool = {}                     # worker_id -> WorkerProfile
        self.grid_workers = defaultdict(list)     # grid_id -> [worker_id]
        self.skill_workers = defaultdict(list)    # skill_tag -> [worker_id]
        self.dispatch_timeout_minutes = 30

    def submit_order(self, order: ServiceOrder) -> ServiceOrder:
        """受理订单,执行基础校验"""
        # 校验服务开始时间不能早于当前时间
        start_dt = datetime.strptime(order.start_date, "%Y-%m-%d")
        if start_dt < datetime.now():
            raise ValueError("服务开始时间不能早于当前时间")

        # 校验服务周期合理性(最长不超过180天)
        end_dt = datetime.strptime(order.end_date, "%Y-%m-%d")
        if (end_dt - start_dt).days > 180:
            raise ValueError("单次服务周期不能超过180天")

        # 校验预算区间
        if order.budget_min > order.budget_max:
            raise ValueError("预算下限不能大于上限")

        order.status = OrderStatus.PENDING
        self.orders[order.order_id] = order
        return order

    def is_worker_available(self, worker_id: str,
                            start_date: str, end_date: str) -> bool:
        """检查服务人员在指定时间段内档期是否空闲"""
        slots = self.worker_schedules.get(worker_id, [])
        new_start = datetime.strptime(start_date, "%Y-%m-%d")
        new_end = datetime.strptime(end_date, "%Y-%m-%d")

        for slot in slots:
            slot_start = datetime.strptime(slot.start_date, "%Y-%m-%d")
            slot_end = datetime.strptime(slot.end_date, "%Y-%m-%d")
            # 判断时间段是否重叠
            if new_start <= slot_end and new_end >= slot_start:
                return False
        return True

    def find_candidates(self, order: ServiceOrder) -> list:
        """根据订单需求筛选候选服务人员"""
        # 技能交集
        if order.required_skills:
            skill_sets = [
                set(self.skill_workers.get(s, []))
                for s in order.required_skills
            ]
            skill_matched = set.intersection(*skill_sets) if skill_sets else set()
        else:
            skill_matched = set(self.worker_pool.keys())

        # 区域匹配
        grid_candidates = set(self.grid_workers.get(order.grid_id, []))

        # 取交集
        candidates_ids = skill_matched & grid_candidates

        # 档期校验 + 可用性过滤
        available = []
        for wid in candidates_ids:
            worker = self.worker_pool.get(wid)
            if not worker:
                continue
            if not self.is_worker_available(wid, order.start_date, order.end_date):
                continue
            available.append(worker)

        # 按评分和经验排序
        available.sort(
            key=lambda w: (-getattr(w, 'rating', 0),
                           -getattr(w, 'years_of_experience', 0)),
        )
        return available

    def dispatch_order(self, order_id: str) -> Optional[str]:
        """执行派单,返回被派单的服务人员ID"""
        order = self.orders.get(order_id)
        if not order:
            raise ValueError(f"订单 {order_id} 不存在")

        candidates = self.find_candidates(order)
        if not candidates:
            order.status = OrderStatus.MANUAL
            return None

        # 取排名第一的候选人进行派单
        top_worker = candidates[0]
        order.assigned_worker_id = top_worker.worker_id
        order.status = OrderStatus.DISPATCHED
        order.dispatch_history.append({
            "worker_id": top_worker.worker_id,
            "dispatched_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "result": "pending"
        })

        # 锁定档期(预占)
        slot = WorkerSlot(
            worker_id=top_worker.worker_id,
            start_date=order.start_date,
            end_date=order.end_date,
            order_id=order.order_id
        )
        self.worker_schedules[top_worker.worker_id].append(slot)

        return top_worker.worker_id

    def handle_response(self, order_id: str, worker_id: str,
                        accepted: bool) -> ServiceOrder:
        """处理服务人员的接单/拒单响应"""
        order = self.orders.get(order_id)
        if not order:
            raise ValueError(f"订单 {order_id} 不存在")

        if accepted:
            order.status = OrderStatus.ACCEPTED
            if order.dispatch_history:
                order.dispatch_history[-1]["result"] = "accepted"
        else:
            order.status = OrderStatus.REJECTED
            if order.dispatch_history:
                order.dispatch_history[-1]["result"] = "rejected"

            # 释放预占的档期
            self.worker_schedules[worker_id] = [
                s for s in self.worker_schedules[worker_id]
                if s.order_id != order_id
            ]

            # 自动派单给下一位候选人
            remaining = [
                c for c in self.find_candidates(order)
                if c.worker_id != worker_id
            ]
            if remaining:
                next_worker = remaining[0]
                order.assigned_worker_id = next_worker.worker_id
                order.status = OrderStatus.DISPATCHED
                order.dispatch_history.append({
                    "worker_id": next_worker.worker_id,
                    "dispatched_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                    "result": "pending"
                })
                slot = WorkerSlot(
                    worker_id=next_worker.worker_id,
                    start_date=order.start_date,
                    end_date=order.end_date,
                    order_id=order.order_id
                )
                self.worker_schedules[next_worker.worker_id].append(slot)
            else:
                order.status = OrderStatus.MANUAL

        return order

小程序端消息推送与超时处理服务

以下代码实现了派单消息推送(对接小程序订阅消息)和超时自动流转的处理逻辑。

from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime, timedelta
from collections import defaultdict


@dataclass
class PushMessage:
    """小程序订阅消息体"""
    worker_id: str
    order_id: str
    template_id: str              # 小程序消息模板ID
    page_path: str                # 点击跳转的小程序页面路径
    data: dict = field(default_factory=dict)
    sent_at: Optional[str] = None
    is_sent: bool = False


@dataclass
class TimeoutTask:
    """派单超时检测任务"""
    order_id: str
    worker_id: str
    dispatched_at: datetime
    timeout_at: datetime


class MiniProgramPushService:
    """小程序消息推送服务"""

    def __init__(self):
        self.pending_messages = []       # 待发送消息队列
        self.sent_messages = {}          # order_id -> PushMessage
        self.timeout_tasks = {}          # order_id -> TimeoutTask
        self.default_timeout_minutes = 30

    def create_push_message(self, order, worker_id: str) -> PushMessage:
        """构建派单推送消息"""
        message = PushMessage(
            worker_id=worker_id,
            order_id=order.order_id,
            template_id="TEMPLATE_ORDER_DISPATCH",
            page_path=f"/pages/order/detail?order_id={order.order_id}",
            data={
                "service_type": {"value": order.service_type},
                "service_date": {"value": f"{order.start_date} 至 {order.end_date}"},
                "service_address": {"value": order.service_address},
                "remark": {"value": order.special_notes or "无特殊要求"}
            }
        )
        return message

    def send_dispatch_message(self, message: PushMessage) -> bool:
        """
        发送小程序订阅消息
        实际项目中此处调用微信API: POST https://api.weixin.qq.com/cgi-bin/message/subscribe/send
        """
        try:
            # 模拟发送逻辑
            message.sent_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            message.is_sent = True
            self.sent_messages[message.order_id] = message

            # 创建超时检测任务
            timeout_at = datetime.now() + timedelta(minutes=self.default_timeout_minutes)
            task = TimeoutTask(
                order_id=message.order_id,
                worker_id=message.worker_id,
                dispatched_at=datetime.now(),
                timeout_at=timeout_at
            )
            self.timeout_tasks[message.order_id] = task
            return True

        except Exception:
            message.is_sent = False
            return False

    def check_expired_dispatches(self) -> list:
        """
        定时任务调用:检查超时的派单,返回需要自动拒单的订单列表
        建议通过定时任务每1分钟执行一次
        """
        now = datetime.now()
        expired = []
        for order_id, task in list(self.timeout_tasks.items()):
            if now >= task.timeout_at:
                expired.append({
                    "order_id": order_id,
                    "worker_id": task.worker_id,
                    "dispatched_at": task.dispatched_at.strftime("%Y-%m-%d %H:%M:%S"),
                    "timeout_at": task.timeout_at.strftime("%Y-%m-%d %H:%M:%S")
                })
                # 移除已处理的超时任务
                del self.timeout_tasks[order_id]
        return expired

    def cancel_timeout_task(self, order_id: str):
        """服务人员主动响应后,取消超时检测任务"""
        self.timeout_tasks.pop(order_id, None)

    def get_dispatch_stats(self) -> dict:
        """获取派单统计信息,用于运营后台监控"""
        total_sent = len(self.sent_messages)
        total_expired = 0
        for msg in self.sent_messages.values():
            if msg.order_id not in self.timeout_tasks and not msg.is_sent:
                total_expired += 1

        return {
            "total_dispatched": total_sent,
            "pending_response": len(self.timeout_tasks),
            "avg_response_time": "N/A"  # 实际项目中可统计接单平均耗时
        }

四、关键设计要点

关于档期预占与释放:派单时即预占服务人员的档期,防止同一时间段被多个订单抢占。如果服务人员拒单或超时未响应,必须及时释放预占的档期,否则会造成档期"幽灵占用",影响后续订单的匹配。上述代码在拒单处理中已包含释放逻辑。

关于派单顺序策略:上述实现采用"一次派一人"的串行模式,即先派给排名第一的候选人,拒单后再派第二位。实际项目中也可以采用"同时派多人、先到先得"的并行模式,但需要处理好并发竞争问题(如多人同时接单时的互斥锁)。

关于小程序消息推送的限制:微信小程序订阅消息需要用户主动订阅后才能推送,且每次订阅只能推送一次。建议在用户下单成功后引导其订阅"订单状态变更"消息,在服务人员端引导其订阅"新订单派单"消息。推送失败时需要降级为短信或站内信通知。

关于超时时间的设定:不同服务类型的合理超时时间不同。日常保洁类订单时效性高,超时时间可以设为15分钟;月嫂类订单服务周期长、决策成本高,超时时间可以放宽到1~2小时。建议将超时时间作为品类配置的一部分,而非全局固定值。

关于派单历史追溯:每次派单操作都应记录到dispatch_history中,包括派单时间、被派人、响应结果等。这不仅便于运营排查问题,也为后续的派单策略优化提供数据支撑(如分析哪些服务人员的拒单率偏高,是否需要调整其接单范围)。


以上是家政小程序接单派单系统的全链路设计思路与核心代码实现。整体流程为"用户下单 → 订单校验 → 多维匹配 → 串行派单 → 接单/拒单/超时 → 兜底重试或转人工",覆盖了从前端到后端的完整开发要点,适合作为家政类小程序项目的技术方案参考。

相关文章
|
18天前
|
Linux 开发工具 iOS开发
Codex保姆级教程(下载+安装+登录+使用,含所有版本,2026最新)
Codex是OpenAI推出的开源AI编程智能体,本地运行,可理解整个代码库,支持自然语言指令改代码、执行命令、跑测试、修Bug,兼容Win/macOS/Linux。(239字)
7731 57
|
3天前
|
弹性计算 人工智能 API
Codex超详细入门指南(下载·安装·登录·上手,全版本覆盖,2026最新版)
建议收藏本教程,2026 全年各版本更新随时回来查阅。如果你在搭建过程中遇到任何问题,欢迎结合 阿里云工单系统 提交技术支持请求,或在 阿里云开发者社区 搜索 Codex 相关话题交流。 祝你编码愉快,效率翻倍!
1454 0
|
5天前
|
JSON 前端开发 API
阿里云最新Qwen4-Max大模型介绍:模型定位、特征、能力、适用场景解析
2026 年 11 月 11 日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问 AI 平台 Token Plan,并同步接入千问办公、Qoder 等入口。该版本聚焦知识理解、世界感知、编程与 Agentic 四项升级,主打复杂编程、专业办公、前端设计与专业软件操作。预览期至 11 月 25 日 24:00,到期后模型标识下线;限时 2 折、新用户再享 5 折,最低 1 折可体验。
|
18天前
|
JavaScript API iOS开发
DeepSeek Harness下载、安装、配置一篇搞定(2026整理,送常用插件)
DeepSeek Harness(DSH)是DeepSeek于2026年开源的MIT协议AI Agent框架,支持插件化组装模型、工具、沙箱与UI,兼容主流大模型。本文提供免Node.js的桌面端安装包(Win/macOS),含详细图文教程及热门插件推荐。
5677 68
|
6天前
|
云安全 人工智能 安全
|
13天前
|
Linux 开发工具 iOS开发
2026最新codex下载安装保姆级使用教程(下载+安装+登录+使用,含所有历史版本)
本文详解OpenAI Codex国内快速上手指南:提供Win/macOS/Linux全平台免安装包、npm/Homebrew等多方式安装、账号/API Key双登录、简体中文切换,覆盖下载、安装、汉化、使用及高频避坑(如微软商店失败、npm超时等),10分钟即可跑通。
2907 9
|
5天前
|
人工智能 前端开发 API
阿里云Qwen4-Max 大模型详解:定位、特征、能力、适用场景与相对Qwen3-Max差异解析
2026年11月11日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问AI平台Token Plan并接入千问办公、Qoder等入口。该版本聚焦知识理解、世界感知、编程与Agentic四项升级,主打复杂编程、专业办公、前端设计与专业软件操作等真实任务。预览期为11月11日10:00至11月25日24:00,仅支持Token Plan调用,到期后模型标识下线;限时2折、新用户再享5折,最低1折可体验。
|
3天前
|
Linux Go 开发工具
手机上跑 DeepSeek 智能体:开源安卓客户端 DSH Go 安装与使用指南
DSH Go 是一款开源安卓客户端,将 DeepSeek Harness 智能体引擎装进手机:免 Root、免 Termux,一键安装即用;支持本机运行(内置 Ubuntu+Node.js)或远程接管电脑会话;具备插话打断、过程折叠、屏幕操控、端到端加密分享等特色功能,真正实现智能体“口袋化”。
1906 0
|
10天前
|
人工智能 安全 API
DeepSeek Harness下载、安装、配置一篇搞定(2026整理,送常用插件)
DeepSeek Harness(dsh)是DeepSeek AI于2026年开源的轻量级Agent运行框架,基于Cordis内核,践行“一切皆插件”理念。支持Web/桌面双端,开箱即用;内置多模型接入、丰富插件生态(超3.5万),适配编程、办公、创作等场景。(239字)
1869 1