← back to jryan5150__heaton-web-directory-prod

Function bodies 115 total

main function · typescript · L10-L152 (143 LOC)

scripts/migrate-to-database.ts

async function main() {
  console.log('Starting database migration...\n')

  // 1. Migrate Employees
  console.log('📋 Migrating employees...')
  const employeesPath = path.join(process.cwd(), 'data', 'employees.json')
  const employeesData = JSON.parse(fs.readFileSync(employeesPath, 'utf-8'))

  let employeeCount = 0
  for (const emp of employeesData) {
    await prisma.employee.upsert({
      where: { id: emp.id },
      update: {
        firstName: emp.firstName,
        lastName: emp.lastName,
        email: emp.email || null,
        extension: emp.extension || null,
        phoneNumber: emp.phoneNumber || null,
        did: emp.did || null,
        location: emp.location || 'Unknown',
        team: emp.team || emp.department || 'General',
        title: emp.title || null,
        jobTitle: emp.jobTitle || null,
        department: emp.department || null,
        photoUrl: emp.photoUrl || null,
        avatarUrl: emp.avatarUrl || null,
      },
      create: {
        id: emp.id,

log function · typescript · L43-L46 (4 LOC)

scripts/nextiva-scraper.ts

function log(message: string): void {
  const timestamp = new Date().toISOString()
  console.log(`[${timestamp}] ${message}`)
}

logError function · typescript · L48-L51 (4 LOC)

scripts/nextiva-scraper.ts

function logError(message: string): void {
  const timestamp = new Date().toISOString()
  console.error(`[${timestamp}] ERROR: ${message}`)
}

validateEnv function · typescript · L53-L73 (21 LOC)

scripts/nextiva-scraper.ts

function validateEnv(): Record<(typeof REQUIRED_ENV_VARS)[number], string> {
  const missing: string[] = []
  const env: Record<string, string> = {}

  for (const key of REQUIRED_ENV_VARS) {
    const value = process.env[key]
    if (!value || value.trim().length === 0) {
      missing.push(key)
    } else {
      env[key] = value.trim()
    }
  }

  if (missing.length > 0) {
    throw new Error(
      `Missing required environment variables: ${missing.join(', ')}`
    )
  }

  return env as Record<(typeof REQUIRED_ENV_VARS)[number], string>
}

ensureScreenshotDir function · typescript · L75-L79 (5 LOC)

scripts/nextiva-scraper.ts

function ensureScreenshotDir(): void {
  if (!existsSync(SCREENSHOT_DIR)) {
    mkdirSync(SCREENSHOT_DIR, { recursive: true })
  }
}

takeScreenshot function · typescript · L81-L95 (15 LOC)

scripts/nextiva-scraper.ts

async function takeScreenshot(
  page: Page,
  name: string
): Promise<string | null> {
  try {
    ensureScreenshotDir()
    const filepath = join(SCREENSHOT_DIR, `${name}.png`)
    await page.screenshot({ path: filepath, fullPage: true })
    log(`Screenshot saved: ${filepath}`)
    return filepath
  } catch (err) {
    logError(`Failed to take screenshot "${name}": ${err}`)
    return null
  }
}

login function · typescript · L101-L203 (103 LOC)

scripts/nextiva-scraper.ts

async function login(
  page: Page,
  username: string,
  password: string
): Promise<void> {
  let lastError: Error | null = null

  for (let attempt = 1; attempt <= MAX_LOGIN_ATTEMPTS; attempt++) {
    log(`Login attempt ${attempt}/${MAX_LOGIN_ATTEMPTS}...`)

    try {
      await page.goto(LOGIN_URL, {
        waitUntil: 'networkidle',
        timeout: NAVIGATION_TIMEOUT_MS,
      })

      log('Login page loaded, filling credentials...')

      // Nextiva login form — wait for the email/username input
      // The login form may use different selectors; try common patterns
      const emailSelector = await page
        .waitForSelector(
          'input[type="email"], input[name="username"], input[name="email"], input#email, input#username',
          { timeout: LOGIN_TIMEOUT_MS }
        )

      if (!emailSelector) {
        throw new Error('Could not find email/username input field')
      }

      await emailSelector.fill(username)
      log('Username entered')

      // Some l

Citation: Repobility (2026). State of AI-Generated Code. https://repobility.com/research/

navigateToUsersPage function · typescript · L209-L276 (68 LOC)

scripts/nextiva-scraper.ts

async function navigateToUsersPage(page: Page): Promise<void> {
  log('Navigating to Users management page...')

  // Try direct URL navigation first (most Nextiva admin portals use this path)
  const usersUrls = [
    'https://admin.nextiva.com/users',
    'https://admin.nextiva.com/#/users',
    'https://admin.nextiva.com/management/users',
  ]

  for (const url of usersUrls) {
    try {
      await page.goto(url, {
        waitUntil: 'networkidle',
        timeout: NAVIGATION_TIMEOUT_MS,
      })

      // Check if we landed on a page with user-related content
      const hasUsersContent = await page
        .waitForSelector(
          'text=Users, text=User Management, [data-testid="users"], table',
          { timeout: 10_000 }
        )
        .catch(() => null)

      if (hasUsersContent) {
        log(`Users page loaded via direct URL: ${url}`)
        return
      }
    } catch {
      // Try next URL
    }
  }

  // Fallback: navigate via the sidebar/menu
  log('Direct URL n

exportUsersCSV function · typescript · L278-L358 (81 LOC)

scripts/nextiva-scraper.ts

async function exportUsersCSV(page: Page): Promise<string> {
  log('Looking for CSV export button...')

  // Common export button selectors for Nextiva admin
  const exportSelectors = [
    'button:has-text("Export")',
    'button:has-text("Download")',
    'button:has-text("Export CSV")',
    'button:has-text("Download CSV")',
    'a:has-text("Export")',
    'a:has-text("Download")',
    '[data-testid="export"]',
    '[data-testid="export-csv"]',
    '[aria-label="Export"]',
    '[aria-label="Download"]',
    'button >> svg', // Icon-only export buttons
  ]

  let exportButton = null

  for (const selector of exportSelectors) {
    try {
      exportButton = await page.waitForSelector(selector, {
        timeout: 5_000,
      })
      if (exportButton) {
        log(`Found export button with selector: ${selector}`)
        break
      }
    } catch {
      // Try next selector
    }
  }

  if (!exportButton) {
    await takeScreenshot(page, 'export-button-not-found')
    throw new Err

uploadCSV function · typescript · L364-L398 (35 LOC)

scripts/nextiva-scraper.ts

async function uploadCSV(
  csvContent: string,
  uploadUrl: string,
  syncSecret: string
): Promise<void> {
  log(`Uploading CSV to ${uploadUrl}...`)

  const response = await fetch(uploadUrl, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${syncSecret}`,
      'Content-Type': 'text/csv',
    },
    body: csvContent,
  })

  const responseText = await response.text()

  if (!response.ok) {
    logError(`Sync endpoint returned ${response.status}: ${responseText}`)
    throw new Error(
      `Sync upload failed with status ${response.status}: ${responseText}`
    )
  }

  // Try to parse as JSON for structured logging
  try {
    const result = JSON.parse(responseText)
    log(`Sync result: ${JSON.stringify(result, null, 2)}`)
  } catch {
    log(`Sync response: ${responseText}`)
  }

  log('CSV uploaded successfully')
}

main function · typescript · L404-L462 (59 LOC)

scripts/nextiva-scraper.ts

async function main(): Promise<void> {
  log('=== Nextiva CSV Sync — Starting ===')

  // Validate environment
  const env = validateEnv()
  log('Environment variables validated')

  let browser: Browser | null = null

  try {
    // Launch browser
    log('Launching Chromium (headless)...')
    browser = await chromium.launch({
      headless: true,
    })

    const context = await browser.newContext({
      acceptDownloads: true,
      viewport: { width: 1280, height: 720 },
      userAgent:
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    })

    const page = await context.newPage()

    // Set default timeouts
    page.setDefaultTimeout(NAVIGATION_TIMEOUT_MS)
    page.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT_MS)

    // Step 1: Login
    await login(page, env.NEXTIVA_USERNAME, env.NEXTIVA_PASSWORD)

    // Step 2: Navigate to Users page
    await navigateToUsersPage(page)

    // Step 3: Export CSV

main function · typescript · L16-L29 (14 LOC)

scripts/seed-allowed-ips.ts

async function main() {
  console.log('Seeding allowed IPs...')

  for (const entry of OFFICE_IPS) {
    await prisma.allowedIP.upsert({
      where: { ip: entry.ip },
      update: { location: entry.location, notes: entry.notes },
      create: { ...entry, addedBy: 'system-seed' },
    })
    console.log(`  ✓ ${entry.ip} (${entry.location})`)
  }

  console.log(`\nSeeded ${OFFICE_IPS.length} IPs.`)
}

getErrorMessage function · typescript · L9-L25 (17 LOC)

src/app/admin/login/page.tsx

function getErrorMessage(code: string | null): string {
  switch (code) {
    case 'AccessDenied':
      return 'Access denied. Your Microsoft account is not registered as an admin.'
    case 'NoSession':
      return 'Microsoft sign-in session expired. Please try again.'
    case 'NotRegistered':
      return 'Your account is not registered as an admin. Contact your administrator.'
    case 'CallbackError':
      return 'Something went wrong during sign-in. Please try again.'
    case 'OAuthSignin':
    case 'OAuthCallback':
      return 'Microsoft sign-in failed. Please try again.'
    default:
      return code ? 'Sign-in failed. Please try again.' : ''
  }
}

AdminLoginPage function · typescript · L31-L47 (17 LOC)

src/app/admin/login/page.tsx

export default function AdminLoginPage() {
  return (
    <Suspense fallback={
      <div style={{
        minHeight: '100vh',
        display: 'flex',
        alignItems: 'center',
        justifyContent: 'center',
        background: 'linear-gradient(135deg, #0a1f38 0%, #0f2b4c 50%, #163d6b 100%)',
      }}>
        <div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '14px' }}>Loading...</div>
      </div>
    }>
      <LoginContent />
    </Suspense>
  )
}

LoginContent function · typescript · L49-L372 (324 LOC)

src/app/admin/login/page.tsx

function LoginContent() {
  const router = useRouter()
  const searchParams = useSearchParams()
  const [email, setEmail] = useState('')
  const [password, setPassword] = useState('')
  const [error, setError] = useState(() => getErrorMessage(searchParams.get('error')))
  const [loading, setLoading] = useState(false)
  const [msLoading, setMsLoading] = useState(false)

  const handleMicrosoftSignIn = async () => {
    setError('')
    setMsLoading(true)
    try {
      await signIn('azure-ad', {
        callbackUrl: '/api/admin/microsoft-callback',
      })
    } catch {
      setError('Failed to initiate Microsoft sign-in.')
      setMsLoading(false)
    }
  }

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault()
    setError('')
    setLoading(true)

    try {
      const response = await fetch('/api/admin/login', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ email, password })
      })

Repobility — the code-quality scanner for AI-generated software · https://repobility.com

AdminPage function · typescript · L3-L5 (3 LOC)

src/app/admin/page.tsx

export default function AdminPage() {
  return <AdminDashboard />
}

GET function · typescript · L5-L18 (14 LOC)

src/app/api/admin/activity/route.ts

export async function GET() {
  try {
    const user = await getSessionFromCookie()
    if (!user) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    // Activity log not yet migrated to database — return empty for now
    return NextResponse.json([])
  } catch (error) {
    console.error('Error reading activity log:', error)
    return NextResponse.json({ error: 'Failed to fetch activity log' }, { status: 500 })
  }
}

GET function · typescript · L6-L32 (27 LOC)

src/app/api/admin/ips/route.ts

export async function GET() {
  try {
    const user = await getSessionFromCookie()

    if (!user) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    const allowedIPs = await prisma.allowedIP.findMany({
      orderBy: { addedAt: 'desc' }
    })

    const mapped = allowedIPs.map((record) => ({
      id: record.id,
      ip: record.ip,
      location: record.location,
      notes: record.notes,
      addedBy: record.addedBy,
      addedAt: record.addedAt.toISOString()
    }))

    return NextResponse.json(mapped)
  } catch (error) {
    console.error('Error fetching allowed IPs:', error)
    return NextResponse.json({ error: 'Failed to fetch allowed IPs' }, { status: 500 })
  }
}

POST function · typescript · L35-L100 (66 LOC)

src/app/api/admin/ips/route.ts

export async function POST(request: NextRequest) {
  try {
    const user = await getSessionFromCookie()

    if (!user) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    if (!isSuperAdmin(user)) {
      return NextResponse.json({ error: 'Forbidden - Superadmin only' }, { status: 403 })
    }

    const { ip, location, notes } = await request.json()

    if (!ip || !location) {
      return NextResponse.json({ error: 'Missing required fields (ip, location)' }, { status: 400 })
    }

    // Validate IPv4 format
    const parts = ip.split('.')
    if (parts.length !== 4) {
      return NextResponse.json({ error: 'Invalid IPv4 format' }, { status: 400 })
    }
    const isValidIPv4 = parts.every((part: string) => {
      const num = parseInt(part, 10)
      return !isNaN(num) && num >= 0 && num <= 255 && String(num) === part
    })
    if (!isValidIPv4) {
      return NextResponse.json({ error: 'Invalid IPv4 format' }, { status: 400 })
    }

    //

DELETE function · typescript · L103-L139 (37 LOC)

src/app/api/admin/ips/route.ts

export async function DELETE(request: NextRequest) {
  try {
    const user = await getSessionFromCookie()

    if (!user) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    if (!isSuperAdmin(user)) {
      return NextResponse.json({ error: 'Forbidden - Superadmin only' }, { status: 403 })
    }

    const { searchParams } = new URL(request.url)
    const id = searchParams.get('id')

    if (!id) {
      return NextResponse.json({ error: 'IP id is required as query parameter' }, { status: 400 })
    }

    const existing = await prisma.allowedIP.findUnique({
      where: { id }
    })

    if (!existing) {
      return NextResponse.json({ error: 'IP record not found' }, { status: 404 })
    }

    await prisma.allowedIP.delete({
      where: { id }
    })

    return NextResponse.json({ success: true })
  } catch (error) {
    console.error('Error deleting allowed IP:', error)
    return NextResponse.json({ error: 'Failed to delete allowed IP' }, {

POST function · typescript · L6-L75 (70 LOC)

src/app/api/admin/login/route.ts

export async function POST(request: NextRequest) {
  try {
    const { email, password } = await request.json()

    if (!email || !password) {
      return NextResponse.json(
        { error: 'Email and password are required' },
        { status: 400 }
      )
    }

    const user = await prisma.user.findFirst({
      where: {
        email: {
          equals: email,
          mode: 'insensitive'
        }
      }
    })

    if (!user) {
      return NextResponse.json(
        { error: 'Invalid email or password' },
        { status: 401 }
      )
    }

    // SSO-only users don't have a password -- they must use Microsoft sign-in
    if (!user.passwordHash) {
      return NextResponse.json(
        { error: 'This account uses Microsoft sign-in. Please use the "Sign in with Microsoft" button.' },
        { status: 401 }
      )
    }

    // Verify password
    const isValid = await verifyPassword(password, user.passwordHash)

    if (!isValid) {
      return NextResponse.json(

POST function · typescript · L4-L16 (13 LOC)

src/app/api/admin/logout/route.ts

export async function POST() {
  try {
    await clearSessionCookie()

    return NextResponse.json({ success: true })
  } catch (error) {
    console.error('Logout error:', error)
    return NextResponse.json(
      { error: 'Logout failed' },
      { status: 500 }
    )
  }
}

GET function · typescript · L13-L65 (53 LOC)

src/app/api/admin/microsoft-callback/route.ts

export async function GET(request: NextRequest) {
  try {
    // Get the next-auth session (contains Microsoft profile data)
    const session = await auth()

    if (!session?.user?.email) {
      const loginUrl = new URL('/admin/login', request.url)
      loginUrl.searchParams.set('error', 'NoSession')
      return NextResponse.redirect(loginUrl)
    }

    // Look up the user in our User table by email (case-insensitive)
    const dbUser = await prisma.user.findFirst({
      where: {
        email: {
          equals: session.user.email,
          mode: 'insensitive',
        },
      },
    })

    if (!dbUser) {
      const loginUrl = new URL('/admin/login', request.url)
      loginUrl.searchParams.set('error', 'NotRegistered')
      return NextResponse.redirect(loginUrl)
    }

    // Update microsoftId if not already set
    const microsoftId = session.microsoftId
    if (microsoftId && !dbUser.microsoftId) {
      await prisma.user.update({
        where: { id: dbUser.id },

Repobility · code-quality intelligence platform · https://repobility.com

GET function · typescript · L5-L138 (134 LOC)

src/app/api/admin/notify-approved/route.ts

export async function GET(request: NextRequest) {
  try {
    // Verify cron secret for Vercel cron jobs, or reject unauthenticated calls
    const authHeader = request.headers.get('authorization')
    const cronSecret = process.env.CRON_SECRET
    if (cronSecret && authHeader !== `Bearer ${cronSecret}`) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    const resend = new Resend(process.env.RESEND_API_KEY)
    // Read approved changes from database
    const approvedChanges = await prisma.pendingChange.findMany({
      where: { status: 'approved' }
    })

    if (approvedChanges.length === 0) {
      return NextResponse.json({
        success: true,
        message: 'No approved changes to notify about',
        sent: false
      })
    }

    // Count changes by type
    const changesByType = {
      add: approvedChanges.filter(c => c.type === 'add').length,
      edit: approvedChanges.filter(c => c.type === 'edit').length,
      delete: approved

mapToPendingChange function · typescript · L8-L34 (27 LOC)