Merge pull request #46 from GlebkaF/fast-create-preset

Fast create preset

Author: GlebkaF

.github/workflows/nextjs.yml

@@ -86,6 +86,7 @@ jobs:
 
   # Deployment job
   deploy:
+    if: github.ref == 'refs/heads/main'
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}

TODO.md

@@ -11,7 +11,6 @@
 ## Мысли вслух
 
 - Надо сделать контракты между этапами генерации более строгой типизации
-- Надо сделать рантайм проверку на тип Chain
 
 ## ЗАметки
 
@@ -26,3 +25,11 @@
 Оставить тут коммент:
 https://www.youtube.com/watch?v=IBe7XMhCKWQ
 https://www.youtube.com/watch?v=hB4DUgAb0QA
+
+На гитарист ру написать
+в группе в ФБ написать
+
+## Новые страницы
+
+- Разводящая артистов
+- хлебные крошки

app/admin/preset/create/[id]/page.tsx

@@ -0,0 +1,97 @@
+import { Metadata } from "next";
+import { generationDb } from "../../../../../lib/jsondb";
+import artistsRaw from "../../../../../data/artists.json";
+import { PresetCreateForm } from "components/PresetCreateForm";
+
+interface PresetCreatePageProps {
+  params: {
+    id: string;
+  };
+}
+
+// Исключаем этот API роут из статической генерации
+export function generateStaticParams() {
+  return [{ id: "this-is-a-dummy-id-for-static-build" }];
+}
+
+export const metadata: Metadata = {
+  title: "Создать пресет | Guitar Chain Generator",
+  description: "Создание нового пресета на основе генерации",
+};
+
+async function getGenerationData(generationId: string | undefined) {
+  if (!generationId) {
+    return { generation: null, error: "ID генерации не указан" };
+  }
+
+  try {
+    const generation = await generationDb.getGenerationById(generationId);
+    if (!generation) {
+      return { generation: null, error: "Генерация не найдена" };
+    }
+    return { generation, error: null };
+  } catch (error) {
+    console.error("Error fetching generation:", error);
+    return { generation: null, error: "Ошибка при загрузке генерации" };
+  }
+}
+
+export default async function PresetCreatePage({
+  params,
+}: PresetCreatePageProps) {
+  const { generation, error } = await getGenerationData(params.id);
+
+  if (error || !generation) {
+    return (
+      <div className="min-h-screen bg-gray-100 py-8">
+        <div className="max-w-4xl mx-auto px-4">
+          <div className="text-center">
+            <h1 className="text-2xl font-bold text-gray-900 mb-4">Ошибка</h1>
+            <p className="text-gray-600 mb-8">
+              {error || "Генерация не найдена"}
+            </p>
+            <a
+              href="/admin"
+              className="inline-flex items-center px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors"
+            >
+              ← Назад к каталогу
+            </a>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="min-h-screen bg-gray-100">
+      <header className="bg-white shadow-sm border-b">
+        <div className="max-w-6xl mx-auto px-4 py-4">
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-2">
+              <a
+                href="/admin"
+                className="inline-flex items-center px-3 py-2 text-sm bg-gray-100 hover:bg-gray-200 rounded-lg transition-colors"
+              >
+                ← Назад к каталогу
+              </a>
+              <a
+                href={`/admin/generation/${generation.id}`}
+                className="inline-flex items-center px-3 py-2 text-sm bg-gray-100 hover:bg-gray-200 rounded-lg transition-colors"
+              >
+                ← К генерации
+              </a>
+            </div>
+            <h1 className="text-xl font-bold text-gray-900">Создать пресет</h1>
+            <div className="text-sm text-gray-500">
+              Из генерации {generation.id}
+            </div>
+          </div>
+        </div>
+      </header>
+
+      <main className="max-w-4xl mx-auto px-4 py-8">
+        <PresetCreateForm generation={generation} artists={artistsRaw} />
+      </main>
+    </div>
+  );
+}

app/api/preset/create/route.ts

@@ -0,0 +1,262 @@
+import { NextRequest, NextResponse } from "next/server";
+import fs from "fs/promises";
+import path from "path";
+import { generationDb } from "../../../../lib/jsondb";
+import { validatePresetWithArtist } from "../../../../lib/public/schemas/preset";
+import { validateArtist } from "../../../../lib/public/schemas/artist";
+import { createSlug } from "../../../../lib/utils/create-slug";
+import { createPresetSlugBase } from "lib/utils/urls";
+import { Preset } from "lib/public/interface";
+
+interface CreatePresetRequest {
+  generationId: string;
+  artistId?: number | null;
+  newArtist?: {
+    title: string;
+    description: string;
+  } | null;
+  song: string;
+  part: string;
+  imageUrl?: string | null;
+  tabsUrl?: string;
+  pickup: {
+    type: string;
+    tone: number;
+    position: string;
+  };
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body: CreatePresetRequest = await request.json();
+
+    // Валидация входных данных
+    if (!body.generationId) {
+      return NextResponse.json(
+        { error: "Generation ID is required" },
+        { status: 400 },
+      );
+    }
+    if (!body.song || !body.song.trim()) {
+      return NextResponse.json(
+        { error: "Song name is required" },
+        { status: 400 },
+      );
+    }
+    if (!body.part || !body.part.trim()) {
+      return NextResponse.json(
+        { error: "Song part is required" },
+        { status: 400 },
+      );
+    }
+    if (
+      !body.artistId &&
+      (!body.newArtist || !body.newArtist.title || !body.newArtist.title.trim())
+    ) {
+      return NextResponse.json(
+        { error: "Artist ID or new artist data is required" },
+        { status: 400 },
+      );
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!body.pickup?.type?.trim()) {
+      return NextResponse.json(
+        { error: "Pickup type is required" },
+        { status: 400 },
+      );
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!body.pickup?.tone || body.pickup.tone < 1 || body.pickup.tone > 10) {
+      return NextResponse.json(
+        { error: "Pickup tone must be between 1 and 10" },
+        { status: 400 },
+      );
+    }
+
+    // Получаем генерацию
+    const generation = await generationDb.getGenerationById(body.generationId);
+    if (!generation) {
+      return NextResponse.json(
+        { error: "Generation not found" },
+        { status: 404 },
+      );
+    }
+
+    // Получаем последнюю версию chain
+    if (generation.versions.length === 0) {
+      return NextResponse.json(
+        { error: "Generation has no versions" },
+        { status: 400 },
+      );
+    }
+    const latestVersion = generation.versions[generation.versions.length - 1];
+    if (!latestVersion) {
+      return NextResponse.json(
+        { error: "Latest version not found" },
+        { status: 400 },
+      );
+    }
+    const latestChain = latestVersion.chain;
+
+    // Читаем существующие данные
+    const presetsPath = path.join(process.cwd(), "data", "presets.json");
+    const artistsPath = path.join(process.cwd(), "data", "artists.json");
+
+    const [presetsData, artistsData] = await Promise.all([
+      fs.readFile(presetsPath, "utf-8").then((data) => JSON.parse(data)),
+      fs.readFile(artistsPath, "utf-8").then((data) => JSON.parse(data)),
+    ]);
+
+    let artist;
+    let artistId: number;
+
+    // Обрабатываем артиста
+    if (body.newArtist) {
+      // Создаем нового артиста
+      const maxId = Math.max(
+        ...(artistsData as Array<{ id: number }>).map((a) => a.id),
+        0,
+      );
+      artistId = maxId + 1;
+
+      artist = {
+        id: artistId,
+        title: body.newArtist.title.trim(),
+        slug: createSlug(body.newArtist.title.trim()),
+        description:
+          body.newArtist.description.trim() ||
+          `Описание для ${body.newArtist.title.trim()}`,
+      };
+
+      // Валидируем нового артиста
+      validateArtist(artist);
+
+      // Добавляем в массив артистов
+      artistsData.push(artist);
+    } else {
+      // Используем существующего артиста
+      artistId = body.artistId as number;
+      artist = (
+        artistsData as Array<{
+          id: number;
+          title: string;
+          slug: string;
+          description: string;
+        }>
+      ).find((a) => a.id === artistId);
+      if (!artist) {
+        return NextResponse.json(
+          { error: "Artist not found" },
+          { status: 404 },
+        );
+      }
+    }
+
+    const presetId = generation.id;
+
+    const song = body.song.trim();
+    const part = body.part.trim();
+    const slug = createPresetSlugBase(song, part);
+
+    // Проверяем уникальность комбинации slug + artistId
+    const existingPreset = (
+      presetsData as Array<{
+        slug: string;
+        origin: { artistId: number };
+      }>
+    ).find(
+      (preset) => preset.slug === slug && preset.origin.artistId === artistId,
+    );
+
+    if (existingPreset) {
+      return NextResponse.json(
+        {
+          error: `Preset with slug "${slug}" for artist ID ${String(artistId)} already exists`,
+          details: {
+            slug,
+            artistId,
+            artistTitle: artist.title,
+          },
+        },
+        { status: 409 },
+      );
+    }
+
+    // Создаем объект пресета
+    const preset = {
+      id: presetId,
+      origin: {
+        artistId: artistId,
+        song: song,
+        part: part,
+        imageUrl: body.imageUrl?.trim() || null,
+      },
+      description: generation.proDescription.sound_description,
+      chain: latestChain,
+      pickup: {
+        type: body.pickup.type.trim(),
+        tone: body.pickup.tone,
+        position: body.pickup.position,
+      },
+      slug: slug,
+      tabsUrl: body.tabsUrl?.trim() || undefined,
+    };
+
+    // Создаем объект для валидации с полным артистом
+    const presetWithArtist: Preset = {
+      id: preset.id,
+      origin: {
+        artist: artist,
+        song: preset.origin.song,
+        part: preset.origin.part,
+        imageUrl: preset.origin.imageUrl,
+      },
+      description: preset.description,
+      chain: preset.chain,
+      // @ts-expect-error this is fine
+      pickup: preset.pickup,
+      slug: preset.slug,
+      tabsUrl: preset.tabsUrl,
+    };
+
+    // Валидируем пресет
+    validatePresetWithArtist(presetWithArtist);
+
+    // Добавляем пресет в массив
+    presetsData.push(preset);
+
+    // Сохраняем файлы
+    await Promise.all([
+      fs.writeFile(presetsPath, JSON.stringify(presetsData, null, 2), "utf-8"),
+      fs.writeFile(artistsPath, JSON.stringify(artistsData, null, 2), "utf-8"),
+    ]);
+
+    console.log(`✅ Пресет создан: ${presetId} для артиста ${artist.title}`);
+
+    return NextResponse.json({
+      success: true,
+      presetId: presetId,
+      presetSlug: slug,
+      artistSlug: artist.slug,
+      message: "Preset created successfully",
+    });
+  } catch (error) {
+    console.error("Error creating preset:", error);
+
+    if (error instanceof Error) {
+      // Если это ошибка валидации Zod
+      if (error.message.includes("validation")) {
+        return NextResponse.json(
+          { error: `Validation error: ${error.message}` },
+          { status: 400 },
+        );
+      }
+      return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 },
+    );
+  }
+}