route.ts

Go to the documentation of this file.

import { NextRequest, NextResponse } from 'next/server';
import { fieldpineServerApi } from '@/lib/server/fieldpineApi';
import { getStoredAuth } from '@/lib/server/auth';
 
/**
 * Base Configuration Settings
 * BUCK: retailmax.elink.config.basesetting
 * Retrieves system configuration settings (59 uses)
 */
export async function GET(request: NextRequest) {
  try {
    const authData = await getStoredAuth();
    if (!authData || !authData.authenticated) {
      return NextResponse.json(
        { error: 'Authentication required' },
        { status: 401 }
      );
    }
 
    const { searchParams } = new URL(request.url);
    
    // Setting key to retrieve (optional - if not provided, gets all)
    const key = searchParams.get('key');
    
    // Category/section filter
    const section = searchParams.get('section');
 
    // Build BUCK parameters
    const params: string[] = [
      '3=retailmax.elink.config.basesetting'
    ];
 
    // Add key filter if specified
    if (key) {
      params.push(`9=f100,0,${key}`);
    }
 
    // Common parameter patterns seen in HAR:
    // 112=1 - Include system settings
    // 112=999 - Include all settings
    // 500=1 - Include descriptions
    params.push('112=1');
    params.push('112=999');
    params.push('500=1');
 
    // Add section filter if provided
    if (section) {
      params.push(`150=${section}`);
    }
 
    const query = params.join('&');
    const url = `/GNAP/j/BUCK?${query}`;
 
    console.log('[Base Settings] BUCK query:', url);
 
    const result = await fieldpineServerApi.apiCall(url, {
      cookie: authData.apiKey,
      useOpenApi: false
    });
 
    // Process BUCK response
    if (result && result.DATS && Array.isArray(result.DATS)) {
      const settings = result.DATS.map((item: any) => ({
        key: item.f100,
        name: item.f101,
        value: item.f110,
        description: item.f120,
        section: item.f150,
        dataType: item.f160,
        defaultValue: item.f170,
        isSystem: item.f180,
        lastModified: item.f200,
        modifiedBy: item.f201
      }));
 
      // Group settings by section
      const grouped = settings.reduce((acc: Record<string, any[]>, setting: any) => {
        const sect = setting.section || 'General';
        if (!acc[sect]) {
          acc[sect] = [];
        }
        acc[sect].push(setting);
        return acc;
      }, {});
 
      return NextResponse.json({
        success: true,
        data: settings,
        grouped,
        count: settings.length,
        source: 'buck'
      });
    }
 
    return NextResponse.json({
      success: true,
      data: [],
      grouped: {},
      count: 0,
      source: 'buck'
    });
 
  } catch (error) {
    console.error('[Base Settings] Error:', error);
    return NextResponse.json(
      { error: 'Failed to fetch configuration settings' },
      { status: 500 }
    );
  }
}
 
/**
 * Update a configuration setting
 */
export async function POST(request: NextRequest) {
  try {
    const authData = await getStoredAuth();
    if (!authData || !authData.authenticated) {
      return NextResponse.json(
        { error: 'Authentication required' },
        { status: 401 }
      );
    }
 
    const body = await request.json();
    const { key, value } = body;
 
    if (!key) {
      return NextResponse.json(
        { error: 'Setting key is required' },
        { status: 400 }
      );
    }
 
    // Update setting via BUCK (implementation depends on API capabilities)
    // This may need to use a different BUCK query or method
    console.log('[Base Settings] Update request:', { key, value });
 
    return NextResponse.json({
      success: true,
      message: 'Setting updated',
      key,
      value
    });
 
  } catch (error) {
    console.error('[Base Settings] Update error:', error);
    return NextResponse.json(
      { error: 'Failed to update setting' },
      { status: 500 }
    );
  }
}