All files / src/app/api/admin/support/articles route.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
export const dynamic = "force-dynamic";

/**
 * Admin Support Articles API
 * GET /api/admin/support/articles - List all articles
 * POST /api/admin/support/articles - Create article
 */

import { NextRequest, NextResponse } from 'next/server';
import { requireAdminRole, handleAuthError } from '@/lib/auth';
import { prisma } from '@/lib/prisma';
import { CreateArticleSchema, ArticleFilterSchema } from '@/lib/validation/support-schemas';
import { handleError } from '@/lib/error-handler';
import { logger } from '@/lib/logging';

export async function GET(request: NextRequest) {
  try {
    await requireAdminRole();

    // Parse query parameters
    const { searchParams } = new URL(request.url);
    const queryParams = {
      category: searchParams.get('category') || undefined,
      isPublished: searchParams.get('isPublished') || undefined,
      search: searchParams.get('search') || undefined,
      page: searchParams.get('page') || '1',
      limit: searchParams.get('limit') || '20'};

    const filterResult = ArticleFilterSchema.safeParse(queryParams);
    if (!filterResult.success) {
      return NextResponse.json(
        {
          success: false,
          error: 'Invalid query parameters',
          details: filterResult.error.flatten().fieldErrors},
        { status: 400 }
      );
    }

    const filters = filterResult.data;

    // Build where clause
    const where: Record<string, unknown> = {};

    if (filters.category) {
      where.category = filters.category;
    }

    if (filters.isPublished !== undefined) {
      where.isPublished = filters.isPublished;
    }

    if (filters.search) {
      where.OR = [
        { title: { contains: filters.search } },
        { content: { contains: filters.search } },
        { summary: { contains: filters.search } },
        { keywords: { contains: filters.search } },
      ];
    }

    // Get total count
    const total = await prisma.supportArticle.count({ where });

    // Get articles
    const articles = await prisma.supportArticle.findMany({
      where,
      orderBy: [{ updatedAt: 'desc' }],
      skip: (filters.page - 1) * filters.limit,
      take: filters.limit});

    return NextResponse.json({
      success: true,
      data: articles,
      pagination: {
        page: filters.page,
        limit: filters.limit,
        total,
        totalPages: Math.ceil(total / filters.limit)}});
  } catch (error) {
    const authResponse = handleAuthError(error as Error);
    if (authResponse) return authResponse;

    logger.error('Error fetching admin articles', error instanceof Error ? error : new Error(String(error)), { category: 'ADMIN_SUPPORT' });
    return handleError(error);
  }
}

export async function POST(request: NextRequest) {
  try {
    await requireAdminRole();

    // Validate input
    const body = await request.json();
    const validationResult = CreateArticleSchema.safeParse(body);
    if (!validationResult.success) {
      return NextResponse.json(
        {
          success: false,
          error: 'Validation failed',
          details: validationResult.error.flatten().fieldErrors},
        { status: 400 }
      );
    }

    const data = validationResult.data;

    // Check if slug is unique
    const existingArticle = await prisma.supportArticle.findUnique({
      where: { slug: data.slug }});

    if (existingArticle) {
      return NextResponse.json(
        { success: false, error: 'An article with this slug already exists' },
        { status: 409 }
      );
    }

    // Create the article
    const article = await prisma.supportArticle.create({
      data: {
        title: data.title,
        slug: data.slug,
        content: data.content,
        summary: data.summary,
        category: data.category,
        keywords: data.keywords,
        isPublished: data.isPublished || false,
        publishedAt: data.isPublished ? new Date() : null}});

    logger.info('Support article created', {
      category: 'ADMIN_SUPPORT',
      articleId: article.id,
      slug: article.slug,
      isPublished: article.isPublished});

    return NextResponse.json(
      {
        success: true,
        data: article,
        message: 'Article created successfully'},
      { status: 201 }
    );
  } catch (error) {
    const authResponse = handleAuthError(error as Error);
    if (authResponse) return authResponse;

    logger.error('Error creating admin article', error instanceof Error ? error : new Error(String(error)), { category: 'ADMIN_SUPPORT' });
    return handleError(error);
  }
}