no-copy-frontend/src/app/actions/referralsActions.ts

'use server'

import { getSessionData } from '@/app/actions/session';
import { API_BASE_URL, bankCardFormSchema } from '@/app/actions/definitions';

export async function fetchReferralsLevels() {
	const token = await getSessionData('token');

	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 30003,
				message_body: {
					action: 'levels',
					token: token,
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json();

			if (parsed.message_code === 0) {
				return {
					referrals: parsed.message_body,
					error: null
				}
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error) {
		return {
			referrals: [],
			error: error
		}
	}
}

export async function fetchReferralUserStats() {
	const token = await getSessionData('token');

	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 30003,
				message_body: {
					action: 'userStats',
					token: token,
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json();

			if (parsed.message_code === 0) {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error) {
		return {
			error: error
		}
	}
}

export async function fetchReferralInvitees() {
	const token = await getSessionData('token');

	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 30003,
				message_body: {
					action: 'invitees',
					token: token,
					pageSize: 100,
					pageNumber: 0
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json();

			if (parsed.message_code === 0) {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error) {
		return {
			error: error
		}
	}
}

export async function referralRefill() {
	const token = await getSessionData('token');

	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 30003,
				message_body: {
					action: 'refill',
					token: token,
					amount: 2000,
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			console.log('referralRefill');
			console.log({
				action: 'refill',
				token: token,
				amount: 2000,
			})
			let parsed = await response.json();
			console.log(parsed);

			if (parsed.message_code === 0) {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error) {
		return {
			error: error
		}
	}
}

export interface PayoutMethods {
	cardNumber: string,
	id: number,
	type: string,
	displayName: string,
	maskedDetails: string,
	default: boolean,
	verified: boolean
}

export async function getPayoutMethods(): Promise<{
	methods: PayoutMethods[],
	error: string | null
}> {
	const token = await getSessionData('token');

	try {
		const response = await fetch(`${API_BASE_URL}/api/payouts/user/payout-methods`, {
			method: 'GET',
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`,
			}
		});

		if (response.ok) {
			const parsed = await response.json();

			return {
				methods: parsed,
				error: null
			};
		} else {
			throw 'error';
		}
	} catch (error) {
		return {
			methods: [],
			error: 'error'
		};
	}
}

export async function getUserPayments() {
	const token = await getSessionData('token');

	try {
		const response = await fetch(`${API_BASE_URL}/api/payouts/requests`, {
			method: 'GET',
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`,
			}
		});

		if (response.ok) {
			const parsed = await response.json();

			return {
				payments: parsed,
				error: null
			};
		} else {
			throw 'error';
		}
	} catch (error) {
		return {
			payments: [],
			error: 'error'
		};
	}
}

export type PayoutMethodFormState = {
	previousState: {
		bankCard?: string | undefined;
		paymentsType?: 'bank-card' | 'bank-transfer' | 'on-account-balance';
	} | undefined,
	error: Record<string, string | null> | null
};

export async function addPayoutMethod(
	state: PayoutMethodFormState | undefined,
	formData: FormData,
): Promise<PayoutMethodFormState> {
	const token = await getSessionData('token');
	console.log('addPayoutMethod');

	const bankCard = formData.get('bankCard') as string || '';
	const paymentsType = formData.get('paymentsType') as 'bank-card' | 'bank-transfer' | 'on-account-balance';

	const validatedFields = bankCardFormSchema.safeParse({
		bankCard
	});


	if (!validatedFields.success) {
		const errors: Record<string, string> = {}
		JSON.parse(validatedFields.error.message).forEach((obj: {
			message: string,
			path: string
		}) => {
			if (errors[obj.path[0]]) {
				errors[obj.path[0]] = `${errors[obj.path[0]]} ${obj.message}`;
			} else {
				errors[obj.path[0]] = obj.message;
			}
		});

		return {
			previousState: {
				bankCard
			},
			error: errors
		};
	}

	try {
		const { bankCard } = validatedFields.data;

		const response = await fetch(`${API_BASE_URL}/api/payouts/payout-method/card`, {
			method: 'POST',
			body: JSON.stringify({
				"cardNumber": bankCard.replaceAll(' ', '')
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`,
			}
		});

		console.log(response);

		if (response.ok) {
			const parsed = await response.json();
			console.log(parsed);

			return {
				previousState: {
					bankCard,
					paymentsType
				},
				error: null
			};
		} else {
			throw 'error-save';
		}
	} catch (error: unknown) {
		const errors: Record<string, string> = {};
		errors['server'] = 'error-save'

		if (error) {
			const typedError = error as any;
		}

		return {
			previousState: {
				bankCard,
				paymentsType
			},
			error: errors
		};
	}
}

export type PayoutRequest = {
	previousState: {
		amount?: string | undefined;
	} | undefined,
	error: string | null
};

export async function createPayoutRequest(
	state: PayoutRequest | undefined,
	formData: FormData,
): Promise<PayoutRequest> {
	const token = await getSessionData('token');
	const amount = formData.get('amount') as string || '';
	const payoutMethodId = formData.get('payoutMethodId') as string || '';
	console.log('createPayoutRequest');
	console.log(token);

	try {
		const response = await fetch(`${API_BASE_URL}/api/payouts/create-request`, {
			method: 'POST',
			body: JSON.stringify({
				"amount": amount,
				"payoutMethodId": payoutMethodId
			}),
			headers: {
				'Content-Type': 'application/json',
				'Authorization': `Bearer ${token}`,
			}
		});

		console.log(response);

		if (response.status === 400) {
			const responseText = await response.text();
			throw JSON.parse(responseText)?.message;
		}

		if (response.ok) {
			const parsed = await response.json();
			console.log(parsed);

			return {
				previousState: {
					amount
				},
				error: null
			};
		} else {
			throw 'error-request';
		}
	} catch (error: unknown) {

		if (error) {
			const typedError = error as string;

			return {
				previousState: {
					amount
				},
				error: typedError
			};
		}

		return {
			previousState: {
				amount
			},
			error: 'error-request'
		};
	}
}