Function bodies 169 total

POST function · javascript · L6-L21 (16 LOC)

src/app/api/articles/summarize/route.js

export async function POST(req) {
    try {
        const { content } = await req.json();

        // Use the utility function to summarize the article
        const summary = await summarizeArticle(content);

        return NextResponse.json({ summary });
    } catch (error) {
        console.error("Error calling OpenAI API:", error);
        return NextResponse.json(
            { message: "Failed to summarize article" },
            { status: 500 }
        );
    }
}

POST function · javascript · L6-L28 (23 LOC)

src/app/api/articles/unassign/route.js

export async function POST(request) {
    const adminCheck = requireAdmin(request);
    if (adminCheck instanceof NextResponse) return adminCheck;
    
    try {
        const { articleId, editorId } = await request.json();

        await query(
            `DELETE FROM article_assignments WHERE article_id = $1 AND editor_id = $2`,
            [articleId, editorId]
        );

        return NextResponse.json({
            message: "Article unassigned successfully",
        });
    } catch (error) {
        console.error("Error unassigning article:", error);
        return NextResponse.json(
            { message: "Error unassigning article" },
            { status: 500 }
        );
    }
}

POST function · javascript · L7-L41 (35 LOC)

src/app/api/auth/create-editor/route.js

export async function POST(request) {
  // 1) block non‑admins
  const guard = requireAdmin(request);
  if (guard instanceof NextResponse) return guard;

  // 2) pull the new user data + role
  const { firstName, lastName, email, password } = await request.json();
  if (!firstName || !lastName || !email || !password ) {
    return NextResponse.json({ message: "Missing fields" }, { status: 400 });
  }

  // 3) hash & insert
  const passwordHash = await bcrypt.hash(password, 10);
  const insertUser = await query(
    `INSERT INTO email_credentials
       (first_name, last_name, email, password_hash, role)
     VALUES ($1,$2,$3,$4,$5)
     RETURNING id, email`,
    [firstName, lastName, email.toLowerCase(), passwordHash, "editor"]
  );
  const userId = insertUser.rows[0].id;

  // 4) profile table
  await query(
    `INSERT INTO profile (user_id, name, email, photo, bio)
     VALUES ($1,$2,$3,$4,$5)`,
    [userId, `${firstName} ${lastName}`, email.toLowerCase(), null, null]
  );

  // 5)

POST function · javascript · L8-L92 (85 LOC)

src/app/api/auth/login/route.js

export async function POST(req) {
    try {
        let { email, password } = await req.json();

        // Get user from the database
        email = email.toLowerCase();                     // ← normalize input

        // Now compare against a lower‑cased column value
        const userResult = await query(
        `SELECT * 
            FROM email_credentials 
            WHERE LOWER(email) = $1`,
        [email]
        );


        if (userResult.rows.length === 0) {
            return NextResponse.json(
                { message: "Invalid credentials" },
                { status: 401 }
            );
        }

        const user = userResult.rows[0];
        const passwordMatch = await bcrypt.compare(
            password,
            user.password_hash
        );

        if (!passwordMatch) {
            return NextResponse.json(
                { message: "Invalid credentials" },
                { status: 401 }
            );
        }

        // Check if user is admin

POST function · javascript · L4-L23 (20 LOC)

src/app/api/auth/logout/route.js

export async function POST() {
    try {
        // Clear the auth cookie by setting it with an expired date
        const response = NextResponse.json({ message: "Logout successful" });

        // Set the cookie to expire immediately
        response.headers.set(
            "Set-Cookie",
            "auth=; Max-Age=0; path=/; HttpOnly; secure; SameSite=strict"
        );

        return response;
    } catch (error) {
        console.error("Logout error:", error);
        return NextResponse.json(
            { message: "Error during logout" },
            { status: 500 }
        );
    }
}

GET function · javascript · L5-L33 (29 LOC)

src/app/api/auth/session/route.js

export async function GET(req) {
    const token = req.cookies.get("auth")?.value; // Get the token from cookies

    if (!token) {
        return NextResponse.json({ isLoggedIn: false }, { status: 200 });
    }

    try {
        const decoded = verify(
            token,
            process.env.JWT_SECRET || "your-secret-key"
        ); // Verify the token

        return NextResponse.json(
            {
                isLoggedIn: true,
                email: decoded.email,
                userId: decoded.id,
                name: decoded.name,
                isAdmin: decoded.isAdmin,
                role: decoded.role,
            },
            { status: 200 }
        );
    } catch (error) {
        console.error("Session verification error:", error);
        return NextResponse.json({ isLoggedIn: false }, { status: 200 });
    }
}

POST function · javascript · L8-L76 (69 LOC)

src/app/api/auth/signup/route.js

export async function POST(req) {
    try {
        const { firstName, lastName, email, password } = await req.json();

        // Hash password
        const passwordHash = await bcrypt.hash(password, 10);

        // Insert user into the email_credentials table
        const result = await query(
            `INSERT INTO email_credentials (first_name, last_name, email, password_hash) 
            VALUES ($1, $2, $3, $4) 
            RETURNING id, email`,
            [firstName, lastName, email, passwordHash]
        );

        const userId = result.rows[0].id; // Get the ID of the newly created user
        const userEmail = result.rows[0].email; // Get the email of the newly created user

        // Create a blank profile for the user
        await query(
            `INSERT INTO profile (user_id, name, email, photo, bio) 
            VALUES ($1, $2, $3, $4, $5)`,
            [userId, `${firstName} ${lastName}`, userEmail, null, null] // Include email
        );

Repobility · open methodology · https://repobility.com/research/

POST function · javascript · L5-L52 (48 LOC)

src/app/api/auth/update-password/route.js

export async function POST(req) {
    try {
        const { currentPassword, newPassword, email } = await req.json();

        // Get user from the database (replace with session user info)
        const userResult = await query(
            "SELECT * FROM email_credentials WHERE email = $1",
            [email]
        );

        if (userResult.rows.length === 0) {
            return NextResponse.json(
                { message: "User not found" },
                { status: 404 }
            );
        }

        const user = userResult.rows[0];
        const passwordMatch = await bcrypt.compare(
            currentPassword,
            user.password_hash
        );

        if (!passwordMatch) {
            return NextResponse.json(
                { message: "Current password is incorrect" },
                { status: 401 }
            );
        }

        // Hash new password
        const newPasswordHash = await bcrypt.hash(newPassword, 10);

        // Update password in the da

GET function · javascript · L4-L62 (59 LOC)

src/app/api/clinical-trials/active/route.js

export async function GET() {
  try {
    const tenant = process.env.NEXT_PUBLIC_SITE_KEY;

    if (!tenant) {
      return NextResponse.json(
        { success: false, error: "Missing site tenant" },
        { status: 400 },
      );
    }

    const trials = await sql`
      SELECT
        nct_id,
        COALESCE(short_title_manual, short_title) AS short_title,
        COALESCE(ai_summary_manual, ai_summary)   AS ai_summary,
        tenant,
        overall_status,
        start_date,
        primary_completion_date,
        conditions,

        raw_data->'protocolSection'->'contactsLocationsModule'->'locations'->0->>'city'
          AS location_city,
        raw_data->'protocolSection'->'contactsLocationsModule'->'locations'->0->>'state'
          AS location_state,
        raw_data->'protocolSection'->'contactsLocationsModule'->'locations'->0->>'country'
          AS location_country,
          raw_data->'protocolSection'->'contactsLocationsModule'->'locations'
  AS locations,

GET function · javascript · L1-L40 (40 LOC)

src/app/api/clinical-trials/list/route.js

export async function GET(req) {
  const { searchParams } = new URL(req.url);

  const page = Number(searchParams.get("page") || 1);
  const limit = 6;
  const offset = (page - 1) * limit;
  const q = searchParams.get("q") || "";

  const tenant = process.env.NEXT_PUBLIC_SITE_KEY;
  if (!tenant) {
    return NextResponse.json(
      { success: false, error: "Missing tenant" },
      { status: 400 }
    );
  }

  const trials = await sql`
  SELECT
    nct_id,
    overall_status,
    COALESCE(ai_summary_manual, ai_summary) AS ai_summary
  FROM clinical_trials
  WHERE is_active = true
    AND tenant = ${tenant}
    AND (
      nct_id ILIKE ${"%" + q + "%"}
      OR COALESCE(ai_summary_manual, ai_summary) ILIKE ${"%" + q + "%"}
    )
  ORDER BY last_synced_at DESC
  LIMIT ${limit}
  OFFSET ${offset}
`;

  return NextResponse.json({
    success: true,
    trials,
    total: Number(total[0].count),
    page,
  });
}

GET function · javascript · L4-L65 (62 LOC)

src/app/api/clinical-trials/[nctId]/route.js

export async function GET(req, { params }) {
  const { nctId } = params;
  const tenant = process.env.NEXT_PUBLIC_SITE_KEY;

  if (!tenant) {
    return NextResponse.json(
      { success: false, error: "Missing site tenant" },
      { status: 400 }
    );
  }

  try {
    const result = await sql`
      SELECT
        nct_id,
        tenant,
        overall_status,
        start_date,
        primary_completion_date,
        completion_date,
        last_update_date,
        conditions,
        keywords,

        COALESCE(short_title_manual, short_title)               AS short_title,
        COALESCE(ai_summary_manual, ai_summary)                 AS ai_summary,
        COALESCE(ai_purpose_manual, ai_purpose)                 AS ai_purpose,
        COALESCE(ai_treatments_manual, ai_treatments)           AS ai_treatments,
        COALESCE(ai_design_manual, ai_design)                   AS ai_design,
        COALESCE(ai_eligibility_manual, ai_eligibility)         AS ai_eligibility,

generatePatientSummary function · javascript · L10-L33 (24 LOC)

src/app/api/clinical-trials/regenerate/[nctid]/route.js

async function generatePatientSummary(trial) {
  const protocol = trial.protocolSection;

  const prompt = `
Summarize this clinical trial for patients in simple language.

Title: ${protocol.identificationModule?.briefTitle}
Conditions: ${protocol.conditionsModule?.conditions?.join(", ")}
Eligibility: ${protocol.eligibilityModule?.eligibilityCriteria}
Locations: ${protocol.contactsLocationsModule?.locations
    ?.map((l) => `${l.city}, ${l.country}`)
    .join("; ")}

Summary:
`;

  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.3,
  });

  return response.choices[0].message.content.trim();
}

POST function · javascript · L35-L67 (33 LOC)

src/app/api/clinical-trials/regenerate/[nctid]/route.js

export async function POST(req, { params }) {
  const { nctId } = params;

  const rows = await sql`
    SELECT raw_data
    FROM clinical_trials
    WHERE nct_id = ${nctId}
    LIMIT 1
  `;

  if (!rows.length) {
    return NextResponse.json({ error: "Trial not found" }, { status: 404 });
  }

  const trial = rows[0].raw_data;
  const aiSummary = await generatePatientSummary(trial);

  const sourceHash = crypto
    .createHash("sha256")
    .update(JSON.stringify(trial))
    .digest("hex");

  await sql`
    UPDATE clinical_trials
    SET
      ai_summary = ${aiSummary},
      source_hash = ${sourceHash},
      ai_summary_updated_at = NOW()
    WHERE nct_id = ${nctId}
  `;

  return NextResponse.json({ success: true });
}

normalizeDate function · javascript · L49-L54 (6 LOC)