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

'use server'

import { loginFormSchema, API_BASE_URL, getSignupFormSchema } from '@/app/actions/definitions';
import { createSession, deleteSession, getSessionData, updateSession } from '@/app/actions/session';
import { redirect } from 'next/navigation';
import { fetchINN } from '@/app/actions/action';
import { headers } from 'next/headers';

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

	try {
		await fetch(`${API_BASE_URL}/v1/api/auth/logout`, {
			method: 'POST',
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json',
				'Authorization': `Bearer ${token}`,
			}
		});
	} catch (error) {
		throw error;
	} finally {
		await deleteSession();
	}
}

export async function authorization(
	state: {
		previousState: {
			email: string;
		}
		error: Record<string, string>
	} | undefined,
	formData: FormData,
) {
	const email = formData.get('email') as string || '';
	const password = formData.get('password');

	/* для теста */
	if (email === 'test' && password === 'test') {
		await createSession('1111', 'test');
		redirect('/pages/dashboard');
	}
	/* для теста */

	const validatedFields = loginFormSchema.safeParse({
		email,
		password
	})

	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: {
				email
			},
			error: errors
		};
	}

	try {
		const { email, password } = validatedFields.data;
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20001,
				message_body: {
					email: email,
					password: password
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});
		if (response.ok) {
			let parsed = await response.json();
			if (parsed.message_code === 0) {
				await createSession(parsed.message_body.token, email);
			} else {
				throw (`${parsed.message_code}`);
			}
		} else {
			throw ('request-ended-with-an-error');
		}

	} catch (error) {
		const errors: Record<string, string> = {}

		switch (error) {
			case '2':
				errors['server'] = 'password-does-not-match'
				break;

			case '4':
				errors['server'] = 'email-not-found'
				break;

			default:
				errors['server'] = 'request-ended-with-an-error'
				break;
		}

		if (error) {
			return {
				previousState: {
					email,
					password
				},
				error: errors
			};
		}
		throw error;
	}

	redirect('/pages/dashboard');
}

export type FormState = {
	previousState: {
		fullName?: string | undefined;
		email?: string | undefined;
		password?: string | undefined;
		confirm_password?: string | undefined;
		phone?: string | undefined;
		companyName?: string | undefined;
		agree?: string | undefined;
		referralCode?: string | undefined;
		inn?: string | undefined;
	} | undefined,
	mailConfirm?: boolean,
	userId?: number,
	error: Record<string, string> | null
};

export async function registration(
	state: FormState | undefined,
	formData: FormData,
): Promise<FormState> {
	const headersList = await headers();
	const accountType = formData.get('accountType') as 'b2b' | 'b2c';

	/* вернуть в true когда проект выйдет из дева */
	const mail_verified = false;
	const fullName = formData.get('fullName') as string || '';
	const email = formData.get('email') as string || '';
	const password = formData.get('password') as string || '';
	const confirm_password = formData.get('confirm_password') as string || '';
	const phone = formData.get('phone') as string || '';
	const companyName = formData.get('companyName') as string || '';
	const agree = formData.get('agree') as string || '';
	const referralCode = formData.get('referralCode') as string || '';
	const inn = formData.get('inn') as string || '';


	const forwardedFor = headersList.get('x-forwarded-for');
	const realIp = headersList.get('x-real-ip');
	const ip = forwardedFor?.split(',')[0] || realIp || 'unknown';
	const userAgent = headersList.get('user-agent') || 'unknown';

	const SignupFormSchema = await getSignupFormSchema(accountType);

	const dataToValidate = {
		fullName,
		email,
		phone: phone.replace(/[-\(\)\s]/g, ''),
		password,
		confirm_password,
		agree,
		...(accountType === 'b2b' && { companyName, inn })
	};

	const validatedFields = await SignupFormSchema.safeParse(dataToValidate);

	console.log(`try to register ${accountType}`);

	let confirmedCompanyName: boolean = true;
	if (accountType === 'b2b') {
		try {
			const response = await fetchINN(inn);
			confirmedCompanyName = response?.companyName ? true : false;
		} catch (error) {
			confirmedCompanyName = false;
		}
	}

	if (!validatedFields.success || !confirmedCompanyName) {
		const errors: Record<string, string> = {}
		if (validatedFields?.error?.message) {
			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;
				}
			});
		}

		if (!confirmedCompanyName) {
			errors.inn = 'inn-invalid'
		}

		return {
			previousState: {
				fullName,
				email,
				password,
				confirm_password,
				phone,
				agree,
				...(referralCode !== '' && { referralCode }),
				...(accountType === 'b2b' && { companyName, inn })
			},
			error: errors
		};
	}

	try {
		const { fullName, email, password, phone } = validatedFields.data;
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20002,
				message_body: {
					fullName: fullName,
					email,
					phone: phone,
					password,
					accountType,
					mail_verified: mail_verified,
					ip: ip,
					user_agent: userAgent,
					...(accountType === 'b2b' && { companyName: companyName, inn: inn }),
					...(referralCode !== '' && { referralLink: referralCode })
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		console.log({
			fullName: fullName,
			email,
			phone: phone,
			password,
			accountType,
			ip: ip,
			user_agent: userAgent,
			...(accountType === 'b2b' && { companyName: companyName, inn: inn }),
			...(referralCode !== '' && { referralLink: referralCode })
		})

		if (response.ok) {
			let parsed = await response.json() as {
				message_desc: string,
				message_body: { token: string, userId: number, fieldErrors: string },
				message_code: number
			};

			if (parsed.message_code === 0) {
				console.log(`registration - ${accountType}`);
				console.log({
					fullName: fullName,
					email,
					phone: phone,
					password,
					accountType,
					...(referralCode !== '' && { referralLink: referralCode }),
					...(accountType === 'b2b' && { companyName: companyName, inn: inn })
				});

				if (mail_verified) {
					return {
						previousState: {
							fullName,
							email,
							password,
							confirm_password,
							phone,
							agree,
							...(referralCode !== '' && { referralLink: referralCode }),
							...(accountType === 'b2b' && { companyName: companyName, inn: inn })
						},
						mailConfirm: true,
						userId: parsed.message_body.userId,
						error: null
					};
				} else {
					await createSession(parsed.message_body.token, email as string);
				}

			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error: unknown) {
		const errors: Record<string, string> = {};
		if (error) {
			const typedError = error as any;

			switch (typedError.message_code) {
				case 1:
					if (typedError.message_desc === 'Refferal link is not exist') {
						errors['server'] = 'referral-link-is-not-exist'
						break;
					} else {
						errors['server'] = 'email-or-already-registered'
						break;
					}
				case 2:
					if (typedError.message_body?.fieldErrors) {
						typedError.message_body?.fieldErrors?.forEach((obj: {
							code: string,
							field: string
						}) => {
							if (errors[obj.field]) {
								errors[obj.field] = `${errors[obj.field]}&${obj.code.replaceAll('.', '-')}`;
							} else {
								errors[obj.field] = obj.code.replaceAll('.', '-');
							}
						});

					} else if (typedError.message_desc === 'Company already exists') {
						errors['inn'] = 'company-already-registered'
					} else {
						errors['server'] = 'unknown-error'
					}
					break;

				default:
					errors['server'] = 'request-ended-with-an-error'
					break;
			}

			return {
				previousState: {
					fullName,
					email,
					password,
					confirm_password,
					phone,
					companyName,
					agree,
					inn
				},
				mailConfirm: false,
				error: errors
			};
		}

		return {
			previousState: {
				fullName,
				email,
				password,
				confirm_password,
				phone,
				companyName,
				agree,
				inn
			},
			error: errors
		};
	}

	redirect('/pages/dashboard');
	/* console.log('/v2');
	redirect('/v2'); */
}

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

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

		if (response.ok) {
			const parsed = await response.json();
			if (parsed.message_code === 0) {
				await updateSession(parsed.message_body.token);
			}
		}
	} catch (error) {
		await deleteSession();
		throw error;
	}
}

export async function confirmEmail(userId: number, verifyToken: string) {
	console.log('confirmEmail');

	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			headers: {
				"Content-Type": "application/json",
				"Accept": "application/json",
			},
			body: JSON.stringify({
				version: 1,
				msg_id: 20009,
				message_body: {
					resend: 0,
					user_id: userId,
					verify_token: verifyToken
				}
			}),
		});

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

			if (parsed.message_code === 0) {
				await createSession(parsed.message_body.token, parsed.message_body.email as string);
			} else {
				return {
					success: false,
					error: 'entered-code-is-incorrect'
				};
			}
		} else {
			return {
				success: false,
				error: 'server-error'
			};
		}
	} catch (error) {
		return {
			success: false,
			error: 'network-error'
		};
	}

	redirect('/pages/dashboard');
}

export async function resendConfirmEmail(userId: number) {
	console.log('resendConfirmEmail');


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

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

			if (parsed.message_code === 0) {
				return {
					fine: true
				}
			}
		}
	} catch (error) {
		return {
			fine: false
		}
	}
}

export type FormStateConfirmPassword = {
	previousState: {
		email: string;
		password: string;
		confirm_password: string;
		verifyToken: string;
	},
	error: Record<string, string> | null
};

export async function resetPassword(
	state: any | undefined,
	formData: FormData,
) {
	const email = formData.get('email');
	console.log('resetPassword');

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

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

			} else {
				throw 'error';
			}
		}
	} catch (error) {
		return {
			error: error
		};
	}
	console.log('redirect')
	redirect(`/reset-password?email=${email}`);
}


export async function confirmPassword(
	state: FormStateConfirmPassword | undefined,
	formData: any,
): Promise<FormStateConfirmPassword | undefined> {
	const email = formData.get('email');
	const password = formData.get('password');
	const confirm_password = formData.get('confirm_password');
	const verifyToken = formData.get('verify-token');
	console.log('confirmPassword');

	const SignupFormSchema = await getSignupFormSchema('resetPassword');

	const dataToValidate = {
		password,
		confirm_password
	};

	const validatedFields = SignupFormSchema.safeParse(dataToValidate);

	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: {
				email,
				password,
				confirm_password,
				verifyToken
			},
			error: errors
		};
	}

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

		if (response.ok) {

			const parsed = await response.json();
			console.log(parsed);
			if (parsed.message_code === 0) {
				await createSession(parsed.message_body.authToken, email as string);
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}
	} catch (error: unknown) {
		const errors: Record<string, string> = {};

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

			switch (typedError.message_code) {
				case 1:
					errors['server'] = 'unknown-error'
					break

				case 2:
					if (typedError.message_desc === 'Token not found or time expired') {
						errors['server'] = 'token-not-found-or-time-expired'
					} else {
						errors['server'] = 'unknown-error'
					}
					break;

				default:
					errors['server'] = 'request-ended-with-an-error'
					break;
			}

			return {
				previousState: {
					email,
					password,
					confirm_password,
					verifyToken
				},
				error: errors
			};
		}

		return {
			previousState: {
				email,
				password,
				confirm_password,
				verifyToken
			},
			error: errors
		};
	}

	redirect('/pages/dashboard');
}