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',
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`
			}
		});

		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',
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`
			}
		});

		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',
					pageSize: 100,
					pageNumber: 0
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`
			}
		});

		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',
					amount: 2000,
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`
			}
		});

		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 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,
	success?: boolean,
	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
			},
			success: false,
			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
				},
				success: true,
				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
			},
			success: false,
			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');

	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}`,
			}
		});

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

		if (response.status === 409) {
			const responseText = await response.text();
			if (responseText.includes('Not have money for payout')) {
				throw 'insufficient-funds-to-receive-payment'
			}

			if (responseText.includes('Not found payout method')) {
				throw 'not-found-payout-method'
			}
		}

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

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

		if (error) {
			let typedError: string;

			switch (error) {
				case 'Sum of pay is required':
					typedError = 'sum-of-pay-is-required';
					break;
				case 'Min sum for pay 1000':
					typedError = 'min-sum-for-payout-1000';
					break;
				case 'insufficient-funds-to-receive-payment':
					typedError = 'insufficient-funds-to-receive-payment';
					break;
				case 'not-found-payout-method':
					typedError = 'not-found-payout-method';
					break
				default:
					typedError = 'payment-error';
			}

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

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