686 lines
15 KiB
TypeScript
686 lines
15 KiB
TypeScript
'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');
|
|
} |