Integrate Paylias as an Issuer

import { NextRequest, NextResponse } from 'next/server';

export async function POST(request: NextRequest) {
  try {
    // Parse the webhook payload
    const body = await request.json();

    // Log the webhook payload for debugging
    console.log('Payment created webhook received:', body);

    // Here you would typically:
    // 1. Validate the webhook signature
    // 2. Process the payment created event
    // 3. Update your database accordingly

    // For now, just return a successful response
    return NextResponse.json(
      { message: 'Payment created webhook processed successfully' },
      { status: 200 }
    );
  } catch (error) {
    console.error('Error processing payment created webhook:', error);
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}

import crypto from 'crypto';

export function verifyPayloadSignature(
  secret: string,
  payload: Buffer | string,
  signature: string
): boolean {
  const expected = crypto
    .createHmac('sha512', secret)
    .update(payload)
    .digest('hex');

  const sigBuf = Buffer.from(signature, 'hex');
  const expectedBuf = Buffer.from(expected, 'hex');

  if (sigBuf.length !== expectedBuf.length) return false;
  return crypto.timingSafeEqual(sigBuf, expectedBuf);
}

import { Task } from "../types/task";

class MemoryDatabase {
  private static instance: MemoryDatabase;

  private constructor() {}

  public static getInstance(): MemoryDatabase {
    if (!MemoryDatabase.instance) {
      MemoryDatabase.instance = new MemoryDatabase();
    }
    return MemoryDatabase.instance;
  }

  public getTasks(): Map<string, Task> {
    return taskStore;
  }

  public addTask(task: Task): void {
    taskStore.set(task.payment_id, task);
  }

  public getTask(paymentId: string): Task | undefined {
    return taskStore.get(paymentId);
  }

  public updateTask(paymentId: string, updates: Partial<Task>): Task | null {
    const existing = taskStore.get(paymentId);
    if (!existing) {
      return null;
    }
    const updated = { ...existing, ...updates };
    taskStore.set(paymentId, updated);
    return updated;
  }

  public deleteTask(paymentId: string): boolean {
    return taskStore.delete(paymentId);
  }

  public getAllTasks(): Task[] {
    return Array.from(taskStore.values());
  }

  public clear(): void {
    taskStore.clear();
  }
}

export default MemoryDatabase;

import { Task } from "../types/task";

// 1) Tell TypeScript about your new global...
declare global {
  var _TASK_STORE: Map<string, Task> | undefined;
}

// 2) Initialize it once (or reuse the existing one)
export const taskStore: Map<string, Task> =
  global._TASK_STORE ?? new Map<string, Task>();

// 3) Ensure it’s always on global
if (!global._TASK_STORE) {
  global._TASK_STORE = taskStore;
}

import { v4 as uuidv4 } from "uuid";
import { Task, TaskStatus } from "@/types/task";
import MemoryDatabase from "@/database/memory-db";

export class TaskRepository {
  private db: MemoryDatabase;

  constructor() {
    this.db = MemoryDatabase.getInstance();
  }

  public createTask(data: Omit<Task, "token" | "exception">): Task {
    const task: Task = {
      ...data,
      token: uuidv4(),
      status: TaskStatus.VERIFYING,
      exception: "",
    };
    this.db.addTask(task);
    return task;
  }

  public findByPaymentId(paymentId: string): Task | undefined {
    return this.db.getTask(paymentId);
  }

  public findByToken(token: string): Task | undefined {
    const tasks = this.db.getAllTasks();
    return tasks.find((t) => t.token === token);
  }

  public updateTask(
    paymentId: string,
    updates: Partial<Omit<Task, "payment_id" | "token">>,
  ): Task | null {
    return this.db.updateTask(paymentId, updates as Partial<Task>);
  }

  public getAllTasks(): Task[] {
    return this.db.getAllTasks();
  }

  public deleteTask(paymentId: string): boolean {
    return this.db.deleteTask(paymentId);
  }
}

export default TaskRepository;

// app/api/tasks/route.ts
import { NextResponse } from "next/server";
import { TaskRepository } from "@/repository/taskRepository.ts";
import { TaskStatus } from "@/types/task";

export async function GET() {
  const repository = new TaskRepository();
  const all = repository.getAllTasks();
  // filter out any tasks that have VERIFYING status
  const filtered = all.filter((task) => task.status !== TaskStatus.VERIFYING);
  // reverse the list so that the newest tasks show up on top.
  return NextResponse.json(filtered.reverse());
}

"use client";

import { useRouter } from "next/navigation";
import { useEffect, useState } from "react";
import { AlertTriangle } from "lucide-react";
import { Card, CardContent } from "@/components/ui/card";
import { Task } from "@/types/task";
import { TaskItem } from "@/components/Task";

export function TaskList({}) {
  const router = useRouter();
  const [tasks, setTasks] = useState<Task[]>([]);

  useEffect(() => {
    const interval = setInterval(async () => {
      try {
        const res = await fetch("http://localhost:3000/api/tasks", {
          method: "GET",
        });
        if (!res.ok) {
          throw new Error("Failed to fetch tasks");
        }
        const tasks = await res.json();
        setTasks(tasks);
      } catch (err) {
        console.error("Polling failed:", err);
      }
    }, 5000);

    return () => clearInterval(interval);
  }, [router]);

  if (tasks.length === 0) {
    return (
      <Card className="border border-orange-200 dark:border-orange-700 border-dashed">
        <CardContent className="flex flex-col items-center justify-center py-8">
          <AlertTriangle className="w-8 h-8 text-orange-500" />
          <p className="mt-4 text-sm text-muted-foreground text-center">
            No tasks found that require any action.
          </p>
        </CardContent>
      </Card>
    );
  }

  return (
    <div className="space-y-2 flex flex-col gap-2">
      {tasks.map((task) => (
        <TaskItem
          key={task.token}
          task={task}
          onClickAction={() =>
            router.push(`/update-task?taskId=${task.token}`)
          }
        />
      ))}
    </div>
  );
}

import Navbar from "@/components/NavBar";
import { TaskList } from "@/components/TaskList";

export default async function Home() {
  return (
    <div className="min-h-screen bg-gray-50">
      <Navbar title={"Safepay"} />
      <div className="max-w-2xl mx-auto">
        <TaskList />
      </div>
    </div>
  );
}

"use client";

import React, { useCallback, useEffect, useState } from "react";
import { useRouter, useSearchParams } from "next/navigation";
import { Loader2, CheckCircle, AlertTriangle } from "lucide-react";
import {
  Dialog,
  DialogContent,
  DialogHeader,
  DialogTitle,
  DialogDescription,
  DialogFooter,
} from "@/components/ui/dialog";
import { Button } from "@/components/ui/button";
import { Task, TaskStatus } from "@/types/task";

export function TaskModal({}) {
  const router = useRouter();
  const searchParams = useSearchParams();
  const taskId = searchParams.get("taskId");
  const [task, setTask] = useState<Task | null>(null);

  useEffect(() => {
    fetch(`/api/tasks/${taskId}`)
      .then((res) => res.json())
      .then((data: Task) => {
        if (data.hasOwnProperty("error")) {
          setTask(null);
          return;
        }
        setTask(data);
      });
  }, [taskId]);

  const renderIcon = () => {
    if (task?.status === TaskStatus.PENDING) {
      return <Loader2 className="animate-spin w-16 h-16 text-zinc-500" />;
    }
    if (task?.status === TaskStatus.REJECTED) {
      return <AlertTriangle className="w-16 h-16 text-red-500" />;
    }
    if (task?.status === TaskStatus.ACCEPTED) {
      return <CheckCircle className="w-16 h-16 text-green-500" />;
    }
    return null;
  };

  const renderLabel = () => {
    switch (task?.status) {
      case TaskStatus.PENDING:
        return "Task is pending";
      case TaskStatus.ACCEPTED:
        return "Task has been accepted";
      case TaskStatus.REJECTED:
        return "Task has been rejected";
      default:
        return "";
    }
  };

  const updateTask = useCallback(
    async (status: string) => {
      const response = await fetch(`/api/tasks/${taskId}`, {
        method: "PUT",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ status }),
      });
      if (!response.ok) {
        console.error("Failed to update task status");
        return;
      }
      router.back();
    },
    [taskId, router],
  );

  const isPending = task?.status === TaskStatus.PENDING;

  return (
    <Dialog open onOpenChange={() => router.back()}>
      <DialogContent title="Confirm">
        {task ? (
          <>
            <DialogHeader>
              <DialogTitle>Task Status</DialogTitle>
              <DialogDescription className="flex flex-col items-center space-y-4 pt-4">
                {renderIcon()}
                <span className="text-lg font-medium text-center">
                  {renderLabel()}
                </span>
              </DialogDescription>
            </DialogHeader>
            <DialogFooter>
              <div className="w-full grid grid-cols-2 gap-2">
                <Button
                  variant="destructive"
                  className="w-full"
                  onClick={() => updateTask(TaskStatus.REJECTED)}
                  disabled={!isPending}
                >
                  Reject
                </Button>
                <Button
                  className="w-full"
                  onClick={() => updateTask(TaskStatus.ACCEPTED)}
                  disabled={!isPending}
                >
                  Approve
                </Button>
              </div>
            </DialogFooter>
          </>
        ) : (
          <DialogHeader>
            <DialogTitle>No Task Found</DialogTitle>
          </DialogHeader>
        )}
      </DialogContent>
    </Dialog>
  );
}

export default TaskModal;