@open-loyalty/mcp-server 1.3.6 → 1.4.1

package/dist/workflows/vod-watching.js

@@ -1,326 +0,0 @@
-/**
- * VOD Watching Workflow
- *
- * Creates a campaign to reward fans for watching video content,
- * with achievements for total watch time using attribute aggregation.
- */
-import { campaignCreate, campaignList } from "../tools/campaign/handlers.js";
-import { achievementCreate, achievementList } from "../tools/achievement.js";
-import { badgeList } from "../tools/badge.js";
-import { formatOLDate, DEFAULTS } from "../prompts/fan-engagement-setup.js";
-// ============================================================================
-// Workflow Implementation
-// ============================================================================
-/**
- * Execute the VOD watching workflow
- */
-export async function executeVodWatchingWorkflow(config = {}) {
-    const result = {
-        success: false,
-        errors: [],
-        summary: "",
-    };
-    // Merge with defaults
-    const cfg = {
-        trackBy: config.trackBy ?? DEFAULTS.vodWatching.trackBy,
-        coinsPerUnit: config.coinsPerUnit ?? DEFAULTS.vodWatching.coinsPerUnit,
-        unitSize: config.unitSize ?? DEFAULTS.vodWatching.unitSize,
-        createAchievement: config.createAchievement ?? true,
-        achievementTarget: config.achievementTarget ?? DEFAULTS.vodWatching.achievementMinutes,
-        achievementBonus: config.achievementBonus ?? DEFAULTS.vodWatching.achievementBonus,
-        badgeName: config.badgeName ?? "Content Enthusiast",
-        seasonStart: config.seasonStart ?? DEFAULTS.seasonDates.start,
-        seasonEnd: config.seasonEnd ?? DEFAULTS.seasonDates.end,
-    };
-    try {
-        // Step 1: Create base VOD watching campaign
-        const watchCampaignResult = await createWatchCampaign(cfg);
-        if (watchCampaignResult.error) {
-            result.errors.push(watchCampaignResult.error);
-        }
-        else {
-            result.watchCampaignId = watchCampaignResult.campaignId;
-        }
-        // Step 2: Create achievement and bonus campaign if enabled
-        if (cfg.createAchievement) {
-            const badges = await getAvailableBadges();
-            const achievementResult = await createWatchAchievement(cfg, badges);
-            if (achievementResult.error) {
-                result.errors.push(achievementResult.error);
-            }
-            else {
-                result.achievementId = achievementResult.achievementId;
-                // Create bonus campaign for achievement
-                if (achievementResult.achievementId) {
-                    const bonusCampaignResult = await createAchievementBonusCampaign(achievementResult.achievementId, cfg);
-                    if (bonusCampaignResult.error) {
-                        result.errors.push(bonusCampaignResult.error);
-                    }
-                    else {
-                        result.bonusCampaignId = bonusCampaignResult.campaignId;
-                    }
-                }
-            }
-        }
-        // Step 3: Verify setup
-        const verification = await verifySetup(result);
-        if (verification.warnings.length > 0) {
-            result.errors.push(...verification.warnings);
-        }
-        // Determine success
-        result.success = result.watchCampaignId !== undefined && result.errors.length === 0;
-        // Build summary
-        result.summary = buildSummary(cfg, result);
-    }
-    catch (error) {
-        result.errors.push(`Workflow error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return result;
-}
-// ============================================================================
-// Helper Functions
-// ============================================================================
-async function createWatchCampaign(cfg) {
-    try {
-        const isMinutesBased = cfg.trackBy === "minutes";
-        // For minutes-based tracking, we use an expression to calculate points
-        // based on the minutes_watched attribute divided by unitSize
-        const pointsRule = isMinutesBased
-            ? {
-                expression: `Math.floor(event.minutes_watched / ${cfg.unitSize}) * ${cfg.coinsPerUnit}`,
-            }
-            : {
-                fixedValue: cfg.coinsPerUnit,
-            };
-        const description = isMinutesBased
-            ? `Earn ${cfg.coinsPerUnit} coins for every ${cfg.unitSize} minutes of video watched`
-            : `Earn ${cfg.coinsPerUnit} coins for each video viewed`;
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "custom_event",
-            event: "vod_watch",
-            translations: {
-                en: {
-                    name: "Video Content Reward",
-                    description,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    name: "Award coins for watching content",
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule,
-                        },
-                    ],
-                },
-            ],
-            active: true,
-        });
-        return { campaignId: response.campaignId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create VOD watch campaign: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function getAvailableBadges() {
-    try {
-        const response = await badgeList({});
-        const badgeMap = new Map();
-        for (const badge of response.badges) {
-            if (badge.name && badge.badgeTypeId) {
-                badgeMap.set(badge.name.toLowerCase(), badge.badgeTypeId);
-            }
-        }
-        return badgeMap;
-    }
-    catch {
-        return new Map();
-    }
-}
-async function createWatchAchievement(cfg, badges) {
-    try {
-        const badgeTypeId = cfg.badgeName
-            ? badges.get(cfg.badgeName.toLowerCase())
-            : undefined;
-        const isMinutesBased = cfg.trackBy === "minutes";
-        const targetLabel = isMinutesBased ? "minutes" : "videos";
-        /**
-         * For attribute-sum achievements, we use aggregation rule "sum" with
-         * the attribute to aggregate (e.g., "minutes_watched").
-         * The periodGoal is the total to reach.
-         */
-        const achievementPayload = {
-            translations: {
-                en: {
-                    name: `Watch ${cfg.achievementTarget} ${targetLabel}`,
-                    description: isMinutesBased
-                        ? `Watch ${cfg.achievementTarget} total minutes of video content`
-                        : `Watch ${cfg.achievementTarget} videos`,
-                },
-            },
-            active: true,
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    trigger: "custom_event",
-                    event: "vod_watch",
-                    completeRule: {
-                        periodGoal: cfg.achievementTarget,
-                    },
-                    // For minutes tracking, aggregate the minutes_watched attribute
-                    ...(isMinutesBased && {
-                        aggregation: {
-                            rule: "sum",
-                        },
-                    }),
-                },
-            ],
-        };
-        if (badgeTypeId) {
-            achievementPayload.badgeTypeId = badgeTypeId;
-        }
-        const response = await achievementCreate(achievementPayload);
-        return { achievementId: response.achievementId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create watch achievement: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function createAchievementBonusCampaign(achievementId, cfg) {
-    try {
-        const targetLabel = cfg.trackBy === "minutes" ? "minutes" : "videos";
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "achievement",
-            translations: {
-                en: {
-                    name: `Watch ${cfg.achievementTarget} ${targetLabel} Bonus`,
-                    description: `Bonus ${cfg.achievementBonus} coins for watching ${cfg.achievementTarget} ${targetLabel}`,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    name: `Bonus for watching ${cfg.achievementTarget} ${targetLabel}`,
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule: { fixedValue: cfg.achievementBonus },
-                        },
-                    ],
-                    conditions: [
-                        {
-                            operator: "is_equal",
-                            attribute: "achievement.achievementId",
-                            data: { value: achievementId },
-                        },
-                    ],
-                },
-            ],
-            active: true,
-        });
-        return { campaignId: response.campaignId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create bonus campaign: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function verifySetup(result) {
-    const warnings = [];
-    try {
-        if (result.watchCampaignId) {
-            const campaigns = await campaignList({ active: true });
-            const found = campaigns.campaigns.some((c) => c.campaignId === result.watchCampaignId);
-            if (!found) {
-                warnings.push("Watch campaign created but not found in active campaigns list");
-            }
-        }
-        if (result.achievementId) {
-            const achievements = await achievementList({ active: true });
-            const found = achievements.achievements.some((a) => a.achievementId === result.achievementId);
-            if (!found) {
-                warnings.push("Achievement created but not found in active achievements list");
-            }
-        }
-    }
-    catch (error) {
-        warnings.push(`Verification error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return { warnings };
-}
-function buildSummary(cfg, result) {
-    const lines = [];
-    const isMinutesBased = cfg.trackBy === "minutes";
-    const targetLabel = isMinutesBased ? "minutes" : "videos";
-    if (result.watchCampaignId) {
-        lines.push(`VOD watching campaign created!`);
-        lines.push(`\nTracking by: ${cfg.trackBy}`);
-        if (isMinutesBased) {
-            lines.push(`Reward: ${cfg.coinsPerUnit} coins per ${cfg.unitSize} minutes watched`);
-        }
-        else {
-            lines.push(`Reward: ${cfg.coinsPerUnit} coins per video viewed`);
-        }
-    }
-    if (result.achievementId) {
-        lines.push(`\nAchievement: Watch ${cfg.achievementTarget} ${targetLabel}`);
-        if (cfg.badgeName) {
-            lines.push(`Badge: ${cfg.badgeName}`);
-        }
-        if (result.bonusCampaignId) {
-            lines.push(`Completion bonus: ${cfg.achievementBonus} coins`);
-        }
-    }
-    lines.push(`\nSeason: ${cfg.seasonStart} to ${cfg.seasonEnd}`);
-    lines.push(`\nCustom event to trigger reward:`);
-    lines.push(`  Event: vod_watch`);
-    if (isMinutesBased) {
-        lines.push(`  Required attribute: minutes_watched (number)`);
-        lines.push(`\nExample event payload:`);
-        lines.push(`{`);
-        lines.push(`  "event": "vod_watch",`);
-        lines.push(`  "attributes": {`);
-        lines.push(`    "minutes_watched": 15`);
-        lines.push(`  }`);
-        lines.push(`}`);
-    }
-    else {
-        lines.push(`\nExample event payload:`);
-        lines.push(`{`);
-        lines.push(`  "event": "vod_watch"`);
-        lines.push(`}`);
-    }
-    if (result.errors.length > 0) {
-        lines.push(`\nWarnings/Errors:`);
-        for (const error of result.errors) {
-            lines.push(`- ${error}`);
-        }
-    }
-    return lines.join("\n");
-}
-// ============================================================================
-// Exports
-// ============================================================================
-export const vodWatchingWorkflow = {
-    id: "vod-watching",
-    name: "VOD Watching Campaign",
-    execute: executeVodWatchingWorkflow,
-};