Skip to content

Job application tracker and AI-powered job search assistant. Helps job seekers manage their search journey with AI resume review, job matching, task logging, and application analytics, all while keeping your data private.

18.6 KB
Raw Blame
"use server";
import prisma from "@/lib/db";
import { handleError } from "@/lib/utils";
import { requireUser } from "./shared";
import { createFirstStage } from "@/lib/jobs/createJobRecord";
import { generateMockActivities } from "@/lib/mock.utils";
import {
  mockActivityTypes,
  MOCK_DATA_IDENTIFIER,
} from "@/lib/data/mockActivities";
import {
  mockCompanies,
  mockLocations,
  mockJobTitles,
  mockResumePeople,
  MOCK_VALUE_PREFIX,
} from "@/lib/data/mockProfileData";
import { subYears, subDays } from "date-fns";
import { getRandomInt } from "@/lib/mock.utils";
import {
  mockJobDescriptions,
  mockJobTypes,
  STATUS_WEIGHTS,
} from "@/lib/data/mockJobsData";
import { SALARY_RANGES } from "@/lib/data/salaryRangeData";

export const generateMockActivitiesAction = async (): Promise<any> => {
  try {
    const user = await requireUser();

    // Check if dev mode is enabled
    if (process.env.NODE_ENV !== "development") {
      throw new Error(
        "Mock data generation is only available in development mode",
      );
    }

    // Check which activity types already exist
    const existingTypes = await prisma.activityType.findMany({
      where: {
        value: {
          in: mockActivityTypes.map((t) => t.value),
        },
      },
    });

    const existingValues = new Set(existingTypes.map((t) => t.value));

    // Create only the activity types that don't exist
    const typesToCreate = mockActivityTypes.filter(
      (t) => !existingValues.has(t.value),
    );

    if (typesToCreate.length > 0) {
      await prisma.activityType.createMany({
        data: typesToCreate.map((t) => ({
          label: t.label,
          value: t.value,
          createdBy: user.id,
        })),
      });
    }

    // Get all activity type IDs (both existing and newly created)
    const activityTypes = await prisma.activityType.findMany({
      where: {
        value: {
          in: mockActivityTypes.map((t) => t.value),
        },
      },
    });

    // Generate mock activities
    const mockActivities = generateMockActivities(user.id, 10, 25);

    // Create a map of activity type values to IDs
    const typeMap = new Map(activityTypes.map((t) => [t.value, t.id]));

    // Create activities in the database
    const createdActivities = await Promise.all(
      mockActivities.map((activity) => {
        const typeValue = activity.activityType as string;
        const typeId = typeMap.get(typeValue);

        if (!typeId) {
          throw new Error(`Activity type not found for ${typeValue}`);
        }

        return prisma.activity.create({
          data: {
            activityName: activity.activityName,
            activityTypeId: typeId,
            userId: user.id,
            startTime: activity.startTime,
            endTime: activity.endTime,
            duration: activity.duration,
            description: activity.description,
          },
        });
      }),
    );

    return {
      success: true,
      message: `Generated ${createdActivities.length} mock activities`,
      data: createdActivities,
    };
  } catch (error) {
    const msg = "Failed to generate mock activities";
    return handleError(error, msg);
  }
};

export const clearMockActivitiesAction = async (): Promise<any> => {
  try {
    const user = await requireUser();

    // Check if dev mode is enabled
    if (process.env.NODE_ENV !== "development") {
      throw new Error(
        "Mock data clearing is only available in development mode",
      );
    }

    // Find and delete only mock activities (those with [MOCK_DATA] in description)
    const mockActivities = await prisma.activity.findMany({
      where: {
        userId: user.id,
        description: {
          contains: MOCK_DATA_IDENTIFIER,
        },
      },
    });

    // Delete the activities
    const deleteResult = await prisma.activity.deleteMany({
      where: {
        id: {
          in: mockActivities.map((a) => a.id),
        },
      },
    });

    return {
      success: true,
      message: `Deleted ${deleteResult.count} mock activities`,
      deletedCount: deleteResult.count,
    };
  } catch (error) {
    const msg = "Failed to clear mock activities";
    return handleError(error, msg);
  }
};

export const generateMockProfileDataAction = async (): Promise<any> => {
  try {
    const user = await requireUser();

    if (process.env.NODE_ENV !== "development") {
      throw new Error(
        "Mock data generation is only available in development mode",
      );
    }

    // 1. Upsert companies
    await Promise.all(
      mockCompanies.map((c) =>
        prisma.company.upsert({
          where: { value_createdBy: { value: c.value, createdBy: user.id } },
          update: {},
          create: { label: c.label, value: c.value, createdBy: user.id },
        }),
      ),
    );

    const companies = await prisma.company.findMany({
      where: {
        value: { in: mockCompanies.map((c) => c.value) },
        createdBy: user.id,
      },
    });
    const companyMap = new Map(companies.map((c) => [c.value, c.id]));

    // 2. Upsert locations
    await Promise.all(
      mockLocations.map((l) =>
        prisma.location.upsert({
          where: { value_createdBy: { value: l.value, createdBy: user.id } },
          update: {},
          create: {
            label: l.label,
            value: l.value,
            stateProv: l.stateProv,
            country: l.country,
            createdBy: user.id,
          },
        }),
      ),
    );

    const locations = await prisma.location.findMany({
      where: {
        value: { in: mockLocations.map((l) => l.value) },
        createdBy: user.id,
      },
    });
    const locationMap = new Map(locations.map((l) => [l.value, l.id]));

    // 3. Upsert job titles
    await Promise.all(
      mockJobTitles.map((jt) =>
        prisma.jobTitle.upsert({
          where: { value_createdBy: { value: jt.value, createdBy: user.id } },
          update: {},
          create: { label: jt.label, value: jt.value, createdBy: user.id },
        }),
      ),
    );

    const jobTitles = await prisma.jobTitle.findMany({
      where: {
        value: { in: mockJobTitles.map((jt) => jt.value) },
        createdBy: user.id,
      },
    });
    const jobTitleMap = new Map(jobTitles.map((jt) => [jt.value, jt.id]));

    // 4. Find or create profile for the user
    let profile = await prisma.profile.findFirst({
      where: { userId: user.id },
    });
    if (!profile) {
      profile = await prisma.profile.create({ data: { userId: user.id } });
    }

    // 5. Create resumes, skipping any that already exist
    let created = 0;
    let skipped = 0;

    for (const person of mockResumePeople) {
      const existing = await prisma.resume.findFirst({
        where: { profileId: profile.id, title: person.resumeTitle },
      });
      if (existing) {
        skipped++;
        continue;
      }

      const resume = await prisma.resume.create({
        data: { profileId: profile.id, title: person.resumeTitle },
      });

      // Contact info
      await prisma.contactInfo.create({
        data: {
          resumeId: resume.id,
          firstName: person.firstName,
          lastName: person.lastName,
          headline: person.headline,
          email: person.email,
          phone: person.phone,
          address: person.address,
        },
      });

      // Summary section
      const summary = await prisma.summary.create({
        data: { content: person.summary },
      });
      await prisma.resumeSection.create({
        data: {
          resumeId: resume.id,
          sectionTitle: "Summary",
          sectionType: "summary",
          summaryId: summary.id,
        },
      });

      // Work experience section
      const workSection = await prisma.resumeSection.create({
        data: {
          resumeId: resume.id,
          sectionTitle: "Work Experience",
          sectionType: "experience",
        },
      });

      for (const entry of person.workHistory) {
        const companyId = companyMap.get(entry.company)!;
        const jobTitleId = jobTitleMap.get(entry.jobTitleValue)!;
        const locationId = locationMap.get(entry.location)!;
        const startDate = subYears(new Date(), entry.startYearsAgo);
        const endDate =
          entry.endYearsAgo === null
            ? null
            : subYears(new Date(), entry.endYearsAgo);

        await prisma.workExperience.create({
          data: {
            companyId,
            jobTitleId,
            locationId,
            startDate,
            endDate,
            description: entry.description,
            resumeSectionId: workSection.id,
          },
        });
      }

      // Education section
      const educationSection = await prisma.resumeSection.create({
        data: {
          resumeId: resume.id,
          sectionTitle: "Education",
          sectionType: "education",
        },
      });

      await prisma.education.create({
        data: {
          institution: person.education.institution,
          degree: person.education.degree,
          fieldOfStudy: person.education.fieldOfStudy,
          startDate: new Date(`${person.education.startYear}-09-01`),
          endDate: new Date(`${person.education.endYear}-05-01`),
          locationId: locationMap.get(person.education.location)!,
          resumeSectionId: educationSection.id,
        },
      });

      created++;
    }

    return {
      success: true,
      message: `Generated ${created} resumes (${skipped} already existed). Created ${mockCompanies.length} companies, ${mockLocations.length} locations, ${mockJobTitles.length} job titles.`,
    };
  } catch (error) {
    return handleError(error, "Failed to generate mock profile data");
  }
};

export const clearMockProfileDataAction = async (): Promise<any> => {
  try {
    const user = await requireUser();

    if (process.env.NODE_ENV !== "development") {
      throw new Error(
        "Mock data clearing is only available in development mode",
      );
    }

    // Find mock resumes belonging to the user
    const mockResumes = await prisma.resume.findMany({
      where: {
        title: { contains: "[MOCK_DATA]" },
        profile: { userId: user.id },
      },
      include: {
        ResumeSections: { select: { id: true, summaryId: true } },
      },
    });

    const resumeIds = mockResumes.map((r) => r.id);
    const sectionIds = mockResumes.flatMap((r) =>
      r.ResumeSections.map((s) => s.id),
    );
    const summaryIds = mockResumes
      .flatMap((r) => r.ResumeSections)
      .filter((s) => s.summaryId)
      .map((s) => s.summaryId!);

    // Delete child records first to satisfy FK constraints
    await prisma.workExperience.deleteMany({
      where: { resumeSectionId: { in: sectionIds } },
    });
    await prisma.education.deleteMany({
      where: { resumeSectionId: { in: sectionIds } },
    });
    await prisma.licenseOrCertification.deleteMany({
      where: { resumeSectionId: { in: sectionIds } },
    });
    await prisma.otherSection.deleteMany({
      where: { resumeSectionId: { in: sectionIds } },
    });
    await prisma.resumeSection.deleteMany({
      where: { id: { in: sectionIds } },
    });
    if (summaryIds.length > 0) {
      await prisma.summary.deleteMany({ where: { id: { in: summaryIds } } });
    }
    await prisma.contactInfo.deleteMany({
      where: { resumeId: { in: resumeIds } },
    });
    await prisma.resume.deleteMany({ where: { id: { in: resumeIds } } });

    // Remove mock companies, locations, job titles (best-effort)
    const [deletedCompanies, deletedLocations, deletedJobTitles] =
      await Promise.allSettled([
        prisma.company.deleteMany({
          where: {
            value: { startsWith: MOCK_VALUE_PREFIX },
            createdBy: user.id,
          },
        }),
        prisma.location.deleteMany({
          where: {
            value: { startsWith: MOCK_VALUE_PREFIX },
            createdBy: user.id,
          },
        }),
        prisma.jobTitle.deleteMany({
          where: {
            value: { startsWith: MOCK_VALUE_PREFIX },
            createdBy: user.id,
          },
        }),
      ]);

    const companiesCount =
      deletedCompanies.status === "fulfilled"
        ? deletedCompanies.value.count
        : 0;
    const locationsCount =
      deletedLocations.status === "fulfilled"
        ? deletedLocations.value.count
        : 0;
    const titlesCount =
      deletedJobTitles.status === "fulfilled"
        ? deletedJobTitles.value.count
        : 0;

    return {
      success: true,
      message: `Deleted ${resumeIds.length} resumes, ${companiesCount} companies, ${locationsCount} locations, ${titlesCount} job titles.`,
    };
  } catch (error) {
    return handleError(error, "Failed to clear mock profile data");
  }
};

function pickWeightedStatus(statusMap: Map<string, string>): string {
  const roll = Math.random() * 100;
  let cumulative = 0;
  for (const { value, weight } of STATUS_WEIGHTS) {
    cumulative += weight;
    if (roll < cumulative) {
      const id = statusMap.get(value);
      if (id) return id;
    }
  }
  return statusMap.values().next().value!;
}

export const generateMockJobsAction = async (): Promise<any> => {
  try {
    const user = await requireUser();

    if (process.env.NODE_ENV !== "development") {
      throw new Error(
        "Mock data generation is only available in development mode",
      );
    }

    // Check for mock profile data
    const mockCompanyCount = await prisma.company.count({
      where: { value: { startsWith: MOCK_VALUE_PREFIX }, createdBy: user.id },
    });
    if (mockCompanyCount === 0) {
      return {
        success: false,
        message:
          "Please generate mock profile data first (companies, locations, job titles, and resumes are required).",
      };
    }

    // Fetch mock reference data
    const [companies, locations, jobTitles, statuses, resumes, jobSources] =
      await Promise.all([
        prisma.company.findMany({
          where: {
            value: { startsWith: MOCK_VALUE_PREFIX },
            createdBy: user.id,
          },
        }),
        prisma.location.findMany({
          where: {
            value: { startsWith: MOCK_VALUE_PREFIX },
            createdBy: user.id,
          },
        }),
        prisma.jobTitle.findMany({
          where: {
            value: { startsWith: MOCK_VALUE_PREFIX },
            createdBy: user.id,
          },
        }),
        prisma.jobStatus.findMany(),
        prisma.resume.findMany({
          where: {
            title: { contains: "[MOCK_DATA]" },
            profile: { userId: user.id },
          },
        }),
        prisma.jobSource.findMany({
          where: { createdBy: user.id },
        }),
      ]);

    if (statuses.length === 0) {
      return { success: false, message: "No job statuses found in database." };
    }

    if (jobSources.length === 0) {
      return { success: false, message: "No job sources found. Please add at least one job source first." };
    }

    const statusMap = new Map(statuses.map((s) => [s.value, s.id]));
    const totalJobs = getRandomInt(30, 40);
    const now = new Date();
    const mockWorkplaceTypes = ["REMOTE", "HYBRID", "ONSITE", null];

    const jobsData = Array.from({ length: totalJobs }, () => {
      const company = companies[getRandomInt(0, companies.length - 1)];
      const jobTitle = jobTitles[getRandomInt(0, jobTitles.length - 1)];
      const location = locations[getRandomInt(0, locations.length - 1)];
      const jobSource = jobSources[getRandomInt(0, jobSources.length - 1)];
      const statusId = pickWeightedStatus(statusMap);
      const statusValue =
        statuses.find((s) => s.id === statusId)?.value ?? "draft";

      const daysAgo = getRandomInt(0, 30);
      const createdAt = subDays(now, daysAgo);

      const isApplied = ["applied", "interview", "offer", "rejected"].includes(
        statusValue,
      );
      const appliedDate = isApplied
        ? subDays(now, Math.max(0, daysAgo - getRandomInt(0, 2)))
        : null;

      const description =
        mockJobDescriptions[getRandomInt(0, mockJobDescriptions.length - 1)];
      const salaryRange =
        SALARY_RANGES[getRandomInt(0, SALARY_RANGES.length - 1)].value;
      const dueDate = subDays(now, daysAgo - getRandomInt(7, 21));
      const jobType = mockJobTypes[getRandomInt(0, mockJobTypes.length - 1)];
      const workplaceType =
        mockWorkplaceTypes[getRandomInt(0, mockWorkplaceTypes.length - 1)];

      // ~80% of jobs link to a resume
      const resume =
        resumes.length > 0 && Math.random() < 0.8
          ? resumes[getRandomInt(0, resumes.length - 1)]
          : null;

      return {
        userId: user.id,
        companyId: company.id,
        jobTitleId: jobTitle.id,
        locationId: location.id,
        statusId,
        createdAt,
        applied: isApplied,
        appliedDate,
        description: `${description} ${MOCK_DATA_IDENTIFIER}`,
        jobType,
        workplaceType,
        salaryRange,
        dueDate,
        jobSourceId: jobSource.id,
        resumeId: resume?.id ?? null,
      };
    });

    // A loop rather than createMany: createMany returns only a count, so it
    // cannot feed createFirstStage the new ids. Dev-only, tens of rows.
    let count = 0;
    for (const data of jobsData) {
      const job = await prisma.job.create({ data });
      await createFirstStage(prisma, job.id, data.statusId, user.id, data.createdAt);
      count += 1;
    }

    return {
      success: true,
      message: `Generated ${count} mock jobs across the last 30 days.`,
    };
  } catch (error) {
    return handleError(error, "Failed to generate mock jobs");
  }
};

export const clearMockJobsAction = async (): Promise<any> => {
  try {
    const user = await requireUser();

    if (process.env.NODE_ENV !== "development") {
      throw new Error(
        "Mock data clearing is only available in development mode",
      );
    }

    // Find mock jobs
    const mockJobs = await prisma.job.findMany({
      where: {
        userId: user.id,
        description: { contains: MOCK_DATA_IDENTIFIER },
      },
      select: { id: true },
    });

    const jobIds = mockJobs.map((j) => j.id);

    if (jobIds.length === 0) {
      return { success: true, message: "No mock jobs found to delete." };
    }

    // Delete related records first (FK constraints)
    await prisma.note.deleteMany({ where: { jobId: { in: jobIds } } });

    // Disconnect tags (M2M)
    await Promise.all(
      jobIds.map((id) =>
        prisma.job.update({
          where: { id },
          data: { tags: { set: [] } },
        }),
      ),
    );

    const deleteResult = await prisma.job.deleteMany({
      where: { id: { in: jobIds } },
    });

    return {
      success: true,
      message: `Deleted ${deleteResult.count} mock jobs.`,
    };
  } catch (error) {
    return handleError(error, "Failed to clear mock jobs");
  }
};