132 lines
4.3 KiB
TypeScript
132 lines
4.3 KiB
TypeScript
import { Hono } from "hono";
|
|
import { HTTPException } from "hono/http-exception";
|
|
import db from "../../drizzle";
|
|
import { respondents } from "../../drizzle/schema/respondents";
|
|
import { users } from "../../drizzle/schema/users";
|
|
import { rolesSchema } from "../../drizzle/schema/roles";
|
|
import { rolesToUsers } from "../../drizzle/schema/rolesToUsers";
|
|
import { hashPassword } from "../../utils/passwordUtils";
|
|
import requestValidator from "../../utils/requestValidator";
|
|
import authInfo from "../../middlewares/authInfo";
|
|
import { or, eq } from "drizzle-orm";
|
|
import { z } from "zod";
|
|
import HonoEnv from "../../types/HonoEnv";
|
|
import { notFound } from "../../errors/DashboardError";
|
|
|
|
const registerFormSchema = z.object({
|
|
name: z.string().min(1).max(255),
|
|
username: z.string().min(1).max(255),
|
|
email: z.string().email(),
|
|
password: z.string().min(6),
|
|
companyName: z.string().min(1).max(255),
|
|
position: z.string().min(1).max(255),
|
|
workExperience: z.string().min(1).max(255),
|
|
address: z.string().min(1),
|
|
phoneNumber: z.string().min(1).max(13),
|
|
isEnabled: z.string().default("false"),
|
|
});
|
|
|
|
const respondentsRoute = new Hono<HonoEnv>()
|
|
.use(authInfo)
|
|
//post user
|
|
.post("/", requestValidator("json", registerFormSchema), async (c) => {
|
|
const formData = c.req.valid("json");
|
|
|
|
// Check if the provided email or username is already exists in database
|
|
const conditions = [];
|
|
if (formData.email) {
|
|
conditions.push(eq(users.email, formData.email));
|
|
}
|
|
conditions.push(eq(users.username, formData.username));
|
|
|
|
const existingUser = await db
|
|
.select()
|
|
.from(users)
|
|
.where(
|
|
or(
|
|
eq(users.email, formData.email),
|
|
eq(users.username, formData.username)
|
|
)
|
|
);
|
|
|
|
const existingRespondent = await db
|
|
.select()
|
|
.from(respondents)
|
|
.where(eq(respondents.phoneNumber, formData.phoneNumber));
|
|
|
|
if (existingUser.length > 0) {
|
|
throw new HTTPException(400, {
|
|
message: "Email or username has been registered",
|
|
});
|
|
}
|
|
|
|
if (existingRespondent.length > 0) {
|
|
throw new HTTPException(400, {
|
|
message: "Phone number has been registered",
|
|
});
|
|
}
|
|
|
|
// Hash the password
|
|
const hashedPassword = await hashPassword(formData.password);
|
|
|
|
// Start a transaction
|
|
const result = await db.transaction(async (trx) => {
|
|
// Create user
|
|
const [newUser] = await trx
|
|
.insert(users)
|
|
.values({
|
|
name: formData.name,
|
|
username: formData.username,
|
|
email: formData.email,
|
|
password: hashedPassword,
|
|
isEnabled: formData.isEnabled?.toLowerCase() === "true" || true,
|
|
})
|
|
.returning()
|
|
.catch(() => {
|
|
throw new HTTPException(500, { message: "Error creating user" });
|
|
});
|
|
|
|
// Create respondent
|
|
await trx
|
|
.insert(respondents)
|
|
.values({
|
|
companyName: formData.companyName,
|
|
position: formData.position,
|
|
workExperience: formData.workExperience,
|
|
address: formData.address,
|
|
phoneNumber: formData.phoneNumber,
|
|
userId: newUser.id,
|
|
})
|
|
.catch(() => {
|
|
throw new HTTPException(500, {
|
|
message: "Error creating respondent",
|
|
});
|
|
});
|
|
|
|
// Automatically assign "user" role to the new user
|
|
const [role] = await trx
|
|
.select()
|
|
.from(rolesSchema)
|
|
.where(eq(rolesSchema.code, "user"))
|
|
.limit(1);
|
|
|
|
if (!role) throw notFound();
|
|
|
|
await trx.insert(rolesToUsers).values({
|
|
userId: newUser.id,
|
|
roleId: role.id,
|
|
});
|
|
|
|
return newUser;
|
|
});
|
|
|
|
return c.json(
|
|
{
|
|
message: "User created successfully",
|
|
},
|
|
201
|
|
);
|
|
});
|
|
|
|
export default respondentsRoute;
|