@myassis/gateway 1.0.0

package/dist/services/LocalTaskService.js

@@ -0,0 +1,223 @@
+/**
+ * Gateway 本地任务服务
+ * 提供本地任务的 CRUD 操作
+ *
+ * 使用 SQLite 数据库存储任务
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { TaskStore } from './task/TaskStore';
+import { getLogger, sharedTaskService, formatUTCForLog } from '@pocketclaw/shared';
+const logger = getLogger('LocalTaskService');
+class LocalTaskService {
+    store;
+    constructor() {
+        this.store = new TaskStore();
+    }
+    /**
+     * 创建本地任务
+     */
+    createTask(data) {
+        const now = Date.now();
+        const task = {
+            id: uuidv4(),
+            userId: data.userId,
+            title: data.title,
+            description: data.description,
+            taskType: data.taskType,
+            recurrenceRule: data.recurrenceRule,
+            intervalValue: data.intervalValue,
+            intervalUnit: data.intervalUnit,
+            scheduledAt: toTimestamp(data.scheduledAt) || now,
+            startTime: toTimestamp(data.startTime),
+            endTime: toTimestamp(data.endTime),
+            status: 'pending',
+            platformApply: data.platformApply,
+            pushToken: data.pushToken,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.store.insert(task);
+        logger.info('[LocalTaskService] 创建本地任务', {
+            taskId: task.id,
+            title: task.title,
+            platformApply: task.platformApply,
+        });
+        return task;
+    }
+    /**
+     * 获取本地任务
+     */
+    getTask(taskId) {
+        return this.store.findById(taskId);
+    }
+    /**
+     * 获取用户的所有本地任务
+     */
+    getUserTasks(userId) {
+        return this.store.findByUserId(userId);
+    }
+    /**
+     * 获取所有本地任务
+     */
+    getAllTasks() {
+        return this.store.findAll();
+    }
+    /**
+     * 更新本地任务
+     */
+    updateTask(taskId, data) {
+        const task = this.store.findById(taskId);
+        if (!task) {
+            logger.warn('[LocalTaskService] 任务不存在', { taskId });
+            return null;
+        }
+        // 更新字段
+        if (data.title !== undefined)
+            task.title = data.title;
+        if (data.description !== undefined)
+            task.description = data.description;
+        if (data.taskType !== undefined)
+            task.taskType = data.taskType;
+        if (data.recurrenceRule !== undefined)
+            task.recurrenceRule = data.recurrenceRule;
+        if (data.intervalValue !== undefined)
+            task.intervalValue = data.intervalValue;
+        if (data.intervalUnit !== undefined)
+            task.intervalUnit = data.intervalUnit;
+        if (data.scheduledAt !== undefined)
+            task.scheduledAt = toTimestamp(data.scheduledAt);
+        if (data.startTime !== undefined)
+            task.startTime = toTimestamp(data.startTime);
+        if (data.endTime !== undefined)
+            task.endTime = toTimestamp(data.endTime);
+        if (data.status !== undefined)
+            task.status = data.status;
+        if (data.platformApply !== undefined)
+            task.platformApply = data.platformApply;
+        if (data.pushToken !== undefined)
+            task.pushToken = data.pushToken;
+        task.updatedAt = Date.now();
+        this.store.update(task);
+        logger.info('[LocalTaskService] 更新本地任务', {
+            taskId: task.id,
+            updates: Object.keys(data),
+        });
+        return task;
+    }
+    /**
+     * 更新任务状态
+     */
+    async updateTaskStatus(taskId, status) {
+        const task = this.getTask(taskId);
+        if (!task) {
+            return;
+        }
+        if (['expired', 'completed', 'error'].includes(status)) {
+            await this.complete(task.id);
+        }
+        else {
+            this.store.updateStatus(taskId, status);
+        }
+        logger.info('[LocalTaskService] 更新任务状态', { taskId, status });
+    }
+    //完成任务
+    async complete(taskId) {
+        try {
+            const task = this.getTask(taskId);
+            if (!task) {
+                return { success: false, error: 'Task not found' };
+            }
+            const now = Date.now();
+            // 如果是重复任务，计算下次执行时间
+            if (task.taskType === 'recurring') {
+                const result = await sharedTaskService.calculateNextOccurrence(now, task.recurrenceRule, task.endTime, task.intervalValue, task.intervalUnit);
+                if (result) {
+                    const newTask = {
+                        ...task,
+                        id: task.id,
+                        scheduledAt: result,
+                        status: 'pending',
+                        createdAt: Date.now(),
+                        updatedAt: Date.now(),
+                    };
+                    this.store.update(newTask);
+                    logger.info(`Created recurring task instance`, {
+                        originalId: task.id,
+                        newId: newTask.id,
+                        nextScheduledAt: formatUTCForLog(result),
+                    });
+                }
+                else {
+                    this.store.updateStatus(task.id, 'completed');
+                }
+            }
+            // 一次性任务标记为完成
+            if (task.taskType === 'one_time') {
+                this.store.updateStatus(task.id, 'completed');
+                logger.info(`Task completed`, { taskId: task.id });
+            }
+            return { success: true };
+        }
+        catch (error) {
+            logger.error('[tasksService] Complete failed', { taskId, error });
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * 删除本地任务
+     */
+    deleteTask(taskId) {
+        const task = this.store.findById(taskId);
+        if (!task) {
+            logger.warn('[LocalTaskService] 任务不存在', { taskId });
+            return false;
+        }
+        this.store.delete(taskId);
+        logger.info('[LocalTaskService] 删除本地任务', { taskId });
+        return true;
+    }
+    /**
+     * 批量获取任务（用于列表）
+     */
+    listTasks(params) {
+        let tasks;
+        if (params?.userId && params?.status) {
+            tasks = this.store.findByUserAndStatus(params.userId, params.status);
+        }
+        else if (params?.userId) {
+            tasks = this.store.findByUserId(params.userId);
+        }
+        else if (params?.status) {
+            tasks = this.store.findByStatus(params.status);
+        }
+        else {
+            tasks = this.store.findAll();
+        }
+        const total = tasks.length;
+        // 排序（按执行时间倒序）
+        tasks.sort((a, b) => b.scheduledAt - a.scheduledAt);
+        // 分页
+        if (params?.page && params?.pageSize) {
+            const start = (params.page - 1) * params.pageSize;
+            tasks = tasks.slice(start, start + params.pageSize);
+        }
+        return { tasks, total };
+    }
+    /**
+     * 获取任务存储实例
+     */
+    getStore() {
+        return this.store;
+    }
+}
+export const localTaskService = new LocalTaskService();
+/**
+ * 将时间转换为时间戳
+ */
+function toTimestamp(time) {
+    if (!time)
+        return undefined;
+    if (typeof time === 'number')
+        return time;
+    return new Date(time).getTime();
+}

package/dist/services/NotificationService.js

@@ -0,0 +1,242 @@
+/**
+ * 通知服务
+ * 负责发送任务通知
+ * 优先级：WebSocket > HMS Push (华为) / Expo Push (其他)
+ */
+import { PushTokenStore } from './task/PushTokenStore';
+import { webSocketService } from './WebSocketService';
+import { hmsPushService } from './HMSPushService';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('NotificationService');
+const log = logger;
+// 全局 PushTokenStore 实例
+let pushTokenStore = null;
+function getPushTokenStore() {
+    if (!pushTokenStore) {
+        pushTokenStore = new PushTokenStore();
+    }
+    return pushTokenStore;
+}
+class NotificationService {
+    expoPushUrl = 'https://exp.host/--/api/v2/push/send';
+    /**
+     * 发送任务通知给指定用户
+     * 优先使用 WebSocket（实时推送），失败则降级到 Expo Push
+     */
+    async sendTaskNotification(task) {
+        // 1. 优先尝试 WebSocket 发送（用户在线时）
+        if (webSocketService.isUserOnline(task.userId)) {
+            const sent = webSocketService.sendTaskNotification(task);
+            if (sent) {
+                return true;
+            }
+        }
+        // 2. 降级到 Expo Push Notifications
+        return this.sendExpoPushNotification(task);
+    }
+    /**
+     * 通过 Expo Push Notifications 发送任务通知
+     */
+    async sendExpoPushNotification(task) {
+        const pushStore = getPushTokenStore();
+        const pushTokens = pushStore.getExpoTokens(task.userId);
+        if (pushTokens.length === 0) {
+            log.warn(`用户 ${task.userId} 没有注册 Push Token`);
+            return false;
+        }
+        const messages = pushTokens.map(token => ({
+            to: token,
+            title: `${task.title}`,
+            body: task.description || "",
+            data: {
+                taskId: task.id,
+                type: 'task_reminder',
+            },
+            sound: 'default',
+            priority: 'high',
+        }));
+        try {
+            const response = await fetch(this.expoPushUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                body: JSON.stringify(messages),
+            });
+            const result = await response.json();
+            // 检查发送结果
+            let successCount = 0;
+            for (const item of result.data) {
+                if (item.status === 'ok') {
+                    successCount++;
+                }
+                else {
+                    log.error(`推送失败: ${item.message}`, item.details);
+                    // 如果 token 无效，从内存中移除
+                    if (item.details?.error === 'DeviceNotRegistered') {
+                        const invalidToken = messages.find(m => m.to)?.to;
+                        if (invalidToken) {
+                            pushStore.delete(invalidToken);
+                        }
+                    }
+                }
+            }
+            return successCount > 0;
+        }
+        catch (error) {
+            log.error('推送异常:', error);
+            return false;
+        }
+    }
+    /**
+     * 发送测试通知
+     */
+    async sendTestNotification(pushToken, title, body) {
+        const message = {
+            to: pushToken,
+            title,
+            body,
+            data: { type: 'test' },
+            sound: 'default',
+        };
+        try {
+            const response = await fetch(this.expoPushUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                body: JSON.stringify([message]),
+            });
+            const result = await response.json();
+            return result.data[0]?.status === 'ok';
+        }
+        catch (error) {
+            log.error('测试推送异常:', error);
+            return false;
+        }
+    }
+    /**
+     * 批量发送通知给多个用户
+     */
+    async sendBatchNotifications(notifications) {
+        const allMessages = [];
+        for (const notification of notifications) {
+            const pushStore = getPushTokenStore();
+            const pushTokens = pushStore.getExpoTokens(String(notification.userId));
+            for (const token of pushTokens) {
+                allMessages.push({
+                    to: token,
+                    title: notification.title,
+                    body: notification.body,
+                    data: notification.data,
+                    sound: 'default',
+                    priority: 'high',
+                });
+            }
+        }
+        if (allMessages.length === 0) {
+            return;
+        }
+        try {
+            // Expo 限制每次最多发送 100 条消息
+            const batchSize = 100;
+            for (let i = 0; i < allMessages.length; i += batchSize) {
+                const batch = allMessages.slice(i, i + batchSize);
+                const response = await fetch(this.expoPushUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Accept': 'application/json',
+                    },
+                    body: JSON.stringify(batch),
+                });
+                const result = await response.json();
+                let successCount = 0;
+                for (const item of result.data) {
+                    if (item.status === 'ok')
+                        successCount++;
+                }
+            }
+        }
+        catch (error) {
+            log.error('批量推送异常:', error);
+        }
+    }
+    /**
+     * 发送 HMS Push 通知（华为设备专用）
+     */
+    async sendHMSPushNotification(hmsTokens, title, body, data) {
+        if (!hmsPushService.isAvailable()) {
+            log.warn('HMS Push 服务未配置');
+            return false;
+        }
+        const result = await hmsPushService.sendToMany(hmsTokens, {
+            title,
+            body,
+            data: {
+                ...data,
+                type: data?.type || 'task_reminder',
+            },
+        }, {
+            channelId: 'task_reminder',
+        });
+        return result.success;
+    }
+    /**
+     * 根据设备类型发送推送通知
+     * @param devices 设备列表
+     * @param title 标题
+     * @param body 正文
+     * @param data 自定义数据
+     */
+    async sendPushByDeviceType(devices, title, body, data) {
+        // 按 Push Provider 分组
+        const expoTokens = [];
+        const hmsTokens = [];
+        for (const device of devices) {
+            if (device.pushProvider === 'hms' && device.hmsPushToken) {
+                hmsTokens.push(device.hmsPushToken);
+            }
+            else if (device.pushToken) {
+                expoTokens.push(device.pushToken);
+            }
+        }
+        let expoCount = 0;
+        let hmsCount = 0;
+        // 发送 Expo Push
+        if (expoTokens.length > 0) {
+            const messages = expoTokens.map(token => ({
+                to: token,
+                title,
+                body,
+                data,
+                sound: 'default',
+                priority: 'high',
+            }));
+            try {
+                const response = await fetch(this.expoPushUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Accept': 'application/json',
+                    },
+                    body: JSON.stringify(messages),
+                });
+                const result = await response.json();
+                expoCount = result.data.filter(item => item.status === 'ok').length;
+            }
+            catch (error) {
+                log.error('Expo Push 发送失败:', error);
+            }
+        }
+        // 发送 HMS Push
+        if (hmsTokens.length > 0) {
+            const result = await this.sendHMSPushNotification(hmsTokens, title, body, data);
+            hmsCount = result ? hmsTokens.length : 0;
+        }
+        return { expoCount, hmsCount };
+    }
+}
+export const notificationService = new NotificationService();