Reward Rules

Copyfunction resolveConditionFieldValue({
  condition,
  context,
}: {
  condition: RewardCondition;
  context: RewardContext;
}): string | number | string[] | number[] | undefined {
  if (condition.attribute === "metadata") {
    const metaKey = condition.metadataField?.trim();
 
    if (!metaKey) {
      return undefined;
    }
 
    const entityMap = {
      partner: undefined,
      customer: undefined,
      lead: context.lead,
      sale: context.sale,
    } as const;
 
    return prepareMetadataFieldValue(
      entityMap[condition.entity]?.metadata?.[metaKey],
      condition,
    );
  }
 
  const entityMap = {
    partner: context.partner,
    customer: context.customer,
    lead: undefined,
    sale: context.sale,
  } as const;
 
  return entityMap[condition.entity]?.[condition.attribute];
}

Copyconst evaluateCondition = ({
  condition,
  fieldValue,
}: {
  condition: RewardCondition;
  fieldValue: string | number | string[] | number[];
}) => {
  // Equals
  if (condition.operator === "equals_to") {
    return fieldValue === condition.value;
  }
 
  // Not equals
  if (condition.operator === "not_equals") {
    return fieldValue !== condition.value;
  }
 
  // Starts with
  if (condition.operator === "starts_with") {
    if (
      typeof fieldValue !== "string" ||
      typeof condition.value !== "string" ||
      condition.value === ""
    ) {
      return false;
    }
 
    return fieldValue.startsWith(condition.value);
  }
 
  // Ends with
  if (condition.operator === "ends_with") {
    if (
      typeof fieldValue !== "string" ||
      typeof condition.value !== "string" ||
      condition.value === ""
    ) {
      return false;
    }
 
    return fieldValue.endsWith(condition.value);
  }
 
  // Contains
  if (condition.operator === "contains") {
    if (typeof fieldValue !== "string" || typeof condition.value !== "string") {
      return false;
    }
 
    const trimmedValue = condition.value.trim();
 
    if (trimmedValue === "") {
      return false;
    }
 
    return String(fieldValue).includes(trimmedValue);
  }
 
  // Not contains
  if (condition.operator === "not_contains") {
    if (typeof fieldValue !== "string" || typeof condition.value !== "string") {
      return false;
    }
 
    const trimmedValue = condition.value.trim();
 
    if (trimmedValue === "") {
      return false;
    }
 
    return !String(fieldValue).includes(trimmedValue);
  }
 
  // In
  if (condition.operator === "in") {
    if (!Array.isArray(condition.value)) {
      return false;
    }
 
    return (condition.value as (string | number)[]).includes(

Copy  if (matchingConditions.length === 0) {
    return null;
  }
 
  // Find the best matching condition (highest amount)
  return matchingConditions.sort(
    (a, b) =>
      getRewardAmount({
        type: b.type!,
        amountInCents: b.amountInCents,
        amountInPercentage: b.amountInPercentage,
      }) -
      getRewardAmount({
        type: a.type!,
        amountInCents: a.amountInCents,
        amountInPercentage: a.amountInPercentage,
      }),
  )[0];
};

Copylet matchedCondition: RewardConditions | null = null;
 
if (partnerReward.modifiers && context) {
  const modifiers = rewardConditionsArraySchema.safeParse(
    partnerReward.modifiers,
  );
 
  // Parse the conditions before evaluating them
  if (modifiers.success) {
    matchedCondition = evaluateRewardConditions({
      conditions: modifiers.data,
      context,
    });
 
    if (matchedCondition) {
      partnerReward = {
        ...partnerReward,
        // Override the reward amount, type and max duration with the matched condition
        type: matchedCondition.type || partnerReward.type,
        amountInCents:
          matchedCondition.amountInCents != null
            ? matchedCondition.amountInCents
            : null,
        amountInPercentage:
          matchedCondition.amountInPercentage != null
            ? new Prisma.Decimal(matchedCondition.amountInPercentage)
            : null,
        maxDuration:
          matchedCondition.maxDuration !== undefined
            ? matchedCondition.maxDuration
            : partnerReward.maxDuration,
      };
    }
  }
}

Copyexport const calculateSaleEarnings = ({
  reward,
  sale,
}: {
  reward: Pick<RewardProps, "type" | "amountInCents" | "amountInPercentage">;
  sale: Pick<Commission, "quantity" | "amount">;
}) => {
  if (!reward) {
    return 0;
  }
 
  const amount = getRewardAmount(reward);
 
  if (reward.type === "flat") {
    return sale.quantity * amount;
  } else if (reward.type === "percentage") {
    return Math.round((sale.amount * amount) / 100);
  }
 
  return 0;
};

Copy// If there are modifiers, we need to check if they match the primary reward
if (reward.modifiers) {
  const parsedModifiers = rewardConditionsArraySchema.safeParse(
    reward.modifiers,
  );
 
  if (parsedModifiers.success) {
    const modifiers = parsedModifiers.data;
 
    // if no type or maxDuration, it falls back to the primary reward type and maxDuration
    const matchPrimary = modifiers.every((m) => {
      const typeMatches =
        m.type === undefined ? true : m.type === reward.type;
      const durationMatches =
        m.maxDuration === undefined
          ? true
          : m.maxDuration === reward.maxDuration;
      return typeMatches && durationMatches;
    });
 
    // If the type AND maxDuration matches the primary, show a range
    if (matchPrimary) {
      const amount = getRewardAmount(reward);
 
      const min = Math.min(
        amount,
        ...modifiers.map((modifier) =>
          reward.type === "flat"
            ? modifier.amountInCents ?? Infinity
            : modifier.amountInPercentage ?? Infinity,
        ),
      );
 
      const max = Math.max(
        amount,
        ...modifiers.map((modifier) =>
          reward.type === "flat"
            ? modifier.amountInCents ?? 0
            : modifier.amountInPercentage ?? 0,
        ),
      );
 
      if (min !== max) {
        return `Up to ${
          reward.type === "percentage"
            ? `${max}%`
            : currencyFormatter(max, {
                trailingZeroDisplay: "stripIfInteger",
              })
        }`;
      }
    }

Copyfunction pickDisplayReward(reward: RewardProps | null | undefined) {
  if (!reward || getRewardAmount(reward) < 0) {
    return null;
  }
 
  return reward;
}
 
function getDisplayCustomRewards(enrollmentRewards: RewardProps[]) {
  return enrollmentRewards.filter(
    (reward) => reward.event === "custom" && getRewardAmount(reward) >= 0,
  );
}
 
export function getPartnerLinkDisplayRewards({
  clickReward,
  leadReward,
  saleReward,
  discount,
  enrollmentRewards = [],
}: {
  clickReward?: RewardProps | null;
  leadReward?: RewardProps | null;
  saleReward?: RewardProps | null;
  discount?: DiscountProps | null;
  enrollmentRewards?: RewardProps[];
}) {
  return {
    rewards: [
      pickDisplayReward(saleReward),
      pickDisplayReward(leadReward),
      pickDisplayReward(clickReward),
      ...getDisplayCustomRewards(enrollmentRewards),
    ].filter((reward): reward is RewardProps => reward != null),
    discount: discount ?? null,
  };
}

Copyif (
  customerId &&
  event !== "custom" &&
  reward &&
  reward.spendLimitAmount &&
  reward.spendLimitInterval
) {
  cappedEarnings = await clampEarningsToSpendLimit({
    reward,
    earnings,
    programId,
    partnerId,
    customerId,
    referenceDate: createdAt ?? new Date(),
  });
 
  // If spend limit clamped earnings to 0, skip commission creation
  if (cappedEarnings === 0) {
    return logAndReturn({
      commission: null,
      outputLog: `Partner ${partnerId} has reached spend limit (${currencyFormatter(reward.spendLimitAmount)} ${reward.spendLimitInterval === "allTime" ? "" : `per ${reward.spendLimitInterval}`}) for ${event} event, skipping commission creation...`,
    });
  }
}
 
// Custom reward jobs are queued from a snapshot of eligible enrollments.
// Re-check at write time so we don't pay a partner who was banned, deactivated,
// or moved off this reward before the workflow ran.
// Only jobs that pass rewardId (create-custom-commission) should be gated —
// manual commissions and bounty payouts also use event "custom" but have no rewardId.
const isCustomRewardCommission = event === "custom" && Boolean(rewardId);
const stillOnCustomReward = programEnrollment.customRewardId === rewardId;
 
if (
  isCustomRewardCommission &&
  (programEnrollment.status !== "approved" || !stillOnCustomReward)
) {
  return logAndReturn({
    commission: null,
    outputLog: `Partner ${partnerId} is no longer eligible for custom reward ${rewardId} (status: ${programEnrollment.status}), skipping commission creation...`,
  });
}

Copytype CreateReferralCommissionProps =
  | { sourceCommissionId: string; partnerId?: never; programId?: never } // Based on a source commission
  | { sourceCommissionId?: never; partnerId: string; programId: string }; // Based on partner approval and commission threshold
 
export const createReferralCommission = async (
  props: CreateReferralCommissionProps,
) => {
  const context = await resolveReferralContext(props);
 
  if (!context) {
    return null;
  }
 
  const { sourceCommission, programId, partnerId, referredByPartnerId } =
    context;
 
  if (partnerId && referredByPartnerId && partnerId === referredByPartnerId) {
    console.log(
      `Skipping referral commission creation for self-referral (partner ${partnerId}).`,
    );
    return null;
  }

Copyexport function BountyCriteriaManualSubmission() {
  const { watch, setValue } = useBountyFormContext();
 
  const [submissionRequirements, rewardType = "flat"] = watch([
    "submissionRequirements",
    "rewardType",
  ]);
 
  const requireImage = !!submissionRequirements?.image;
  const requireUrl = !!submissionRequirements?.url;
  const imageMax = submissionRequirements?.image?.max;
  const urlMax = submissionRequirements?.url?.max;
  const urlDomains = submissionRequirements?.url?.domains ?? [];