Name: Payment Validator
Author: muhammadcaeed

Skills suchen.../

Payment Validator | Skills Pool

// WRONG - Never allow this
async updatePayment(id: string, data: UpdatePaymentDto) {
  const payment = await this.findById(id);
  if (payment.state === PaymentState.VERIFIED) {
    throw new ForbiddenException('Verified payments cannot be modified');
  }
}

// CORRECT - Calculate dynamically
function getLateStatus(payment: Payment): 'ON_TIME' | 'LATE' | 'PENDING' {
  if (payment.state !== PaymentState.VERIFIED) {
    return 'PENDING'; // Not yet verified
  }

  const verifiedAt = payment.verification.verifiedAt;
  const billingPeriodEnd = payment.billingPeriodEnd; // 22nd of month

  return verifiedAt <= billingPeriodEnd ? 'ON_TIME' : 'LATE';
}

// WRONG - Don't store this
payment.lateStatus = 'LATE'; // Never do this

// For UNPAID/SUBMITTED payments, show "overdue" if past billing period
function isOverdue(payment: Payment): boolean {
  if (payment.state === PaymentState.VERIFIED) return false;
  return new Date() > payment.billingPeriodEnd;
}

// Each submission is a new record, not an update
async createSubmission(data: CreateSubmissionDto): Promise<PaymentSubmission> {
  // Mark any existing active submission as superseded
  await this.markPreviousSubmissionsSuperseded(data.paymentId);

  // Create new submission with incremented version
  const latestVersion = await this.getLatestVersion(data.paymentId);
  return this.create({
    ...data,
    version: latestVersion + 1,
    state: SubmissionState.ACTIVE,
  });
}

// Moderators submitting for their OWN household auto-verify
if (user.role === UserRole.MODERATOR && payment.householdId === user.householdId) {
  // Auto-verify the payment
  await this.verifyPayment(payment.id, user.id);
}

// Moderators cannot verify payments from their own household (unless auto-verified)
if (verifier.householdId === payment.householdId) {
  throw new ForbiddenException('Cannot verify your own household payment');
}

// Always include communityId (multi-tenancy)
async findByHouseholdAndStates(
  householdId: string,
  communityId: string,
  states: PaymentState[],
): Promise<Payment[]> {
  return this.model.find({
    householdId: new Types.ObjectId(householdId),
    communityId: new Types.ObjectId(communityId),
    state: { $in: states },
  });
}

// Explicit transition methods, not generic update
async markAsSubmitted(paymentId: string, communityId: string): Promise<Payment> {
  return this.model.findOneAndUpdate(
    {
      _id: new Types.ObjectId(paymentId),
      communityId: new Types.ObjectId(communityId),
      state: PaymentState.UNPAID, // Enforce valid source state
    },
    { $set: { state: PaymentState.SUBMITTED } },
    { new: true },
  );
}

Payment State	Can Edit Submission?
SUBMITTED	Yes (creates new version)
REJECTED	Yes (creates new version)
VERIFIED	No (submission is locked)

Payment Validator

Aegis Payment Integrity Rules

When This Skill Applies

State Machine (Strict)

Valid Transitions

Payment Validator

Aegis Payment Integrity Rules

When This Skill Applies

State Machine (Strict)

Valid Transitions

Forbidden Transitions

Immutability Rules

VERIFIED Payments

Expected Amount

Late Status Calculation (Dynamic)

Overdue (For Display Only)

Submission Versioning (Append-Only)

Creating Submissions

Editing Rules

Verification Rules

Auto-Verification

Conflict Prevention

Repository Method Patterns

Finding Payments by State

State Transition Methods

Checklist Before Committing

Continuous Learning V2

Continuous Learning V2

Continuous Learning V2

Continuous Learning

Continuous Learning

Pytorch Patterns