1 Commits

Author SHA1 Message Date
Donat 8e5bd9bb54 Merge pull request 'kartya inspect' (#85) from gege into main
Reviewed-on: #85
2025-11-02 15:26:22 +00:00
3 changed files with 23 additions and 1037 deletions
-96
View File
@@ -1,96 +0,0 @@
# ⚡ Gyors Összefoglaló - Felesleges Adatok Tisztítás
## 🎯 Mi a probléma?
A frontend **10 felesleges mezőt** küld a backendnek minden kártya mentésekor.
## 📊 Számok
- **Felesleges deck mezők:** 1 db (`description`)
- **Felesleges kártya mezők:** 9 db
- **Payload csökkenés:** ~32-60%
- **Implementációs idő:** ~3-4 óra
## ✅ Használt mezők (BACKEND)
```javascript
{
name: "Pakli neve",
type: 2, // 0=LUCK, 1=JOKER, 2=QUESTION
ctype: 1, // 0=PUBLIC, 1=PRIVATE, 2=ORGANIZATION
cards: [
{
text: "Kérdés szövege",
type: 0, // CardType enum (0-4)
answer: "..." // TÍPUS-SPECIFIKUS formátum!
}
]
}
```
## ❌ Felesleges mezők (TÖRLENDŐ)
### Deck:
- `description` - nincs a backend sémában
### Kártya:
- `id` (frontend generált) - backend UUID-t használ
- `question` - duplikáció (`text` használandó)
- `statement` - duplikáció (`text` használandó)
- `options` - `answer` array-ben kell lennie
- `correctAnswer` - `answer` array-ben kell lennie
- `leftItems`, `rightItems`, `correctPairs` - `answer` array-ben kell lennie
- `acceptedAnswers` - `answer` array-ként kell lennie
- `hint` - nincs implementálva
## 🔄 Helyes answer formátumok
| Típus | answer formátum |
|-------|----------------|
| QUIZ (0) | `[{answer: "A", text: "...", correct: true}, ...]` |
| PAIRING (1) | `[{left: "...", right: "..."}, ...]` |
| OWN_ANSWER (2) | `["answer1", "answer2", ...]` |
| TRUE_FALSE (3) | `true` vagy `false` |
| CLOSER (4) | `{correct: 123, percent: 10}` |
## 🛠️ Következő lépések
1. ✅ Olvasd el: `FRONTEND_TO_BACKEND_DATA_CLEANUP.md`
2. 🔧 Implementáld: `cardBackendConverter.js` utility
3. 🔄 Módosítsd: `DeckCreator.jsx` mentés logikát
4. ✅ Teszteld: minden kártyatípust
## 📁 Kapcsolódó fájlok
- **Részletes dokumentáció:** `FRONTEND_TO_BACKEND_DATA_CLEANUP.md`
- **Módosítandó frontend:** `src/pages/DeckCreator/DeckCreator.jsx`
- **Backend referencia:** `SerpentRace_Backend/src/Application/Services/CardProcessingService.ts`
---
**Gyors példa:**
```javascript
// ❌ ROSSZ (jelenleg)
{
text: "Kérdés",
question: "Kérdés", // Duplikáció
options: ["A", "B", "C"], // Felesleges
correctAnswer: 0 // Felesleges
}
// ✅ JÓ (célállapot)
{
text: "Kérdés",
type: 0,
answer: [
{answer: "A", text: "A", correct: true},
{answer: "B", text: "B", correct: false},
{answer: "C", text: "C", correct: false}
]
}
```
---
📖 **Teljes dokumentáció:** Lásd `FRONTEND_TO_BACKEND_DATA_CLEANUP.md`
@@ -1,750 +0,0 @@
# Frontend → Backend Felesleges Adatok Dokumentáció
## 📋 Összefoglaló
Ez a dokumentum tartalmazza azokat a mezőket és adatokat, amiket a frontend küld a backendnek, de **nem szükségesek** vagy **nem használtak** a backend oldalon.
**🎯 Fő probléma:** A frontend sok felesleges mezőt küld, ahelyett hogy egyetlen `answer` mezőt használna típus-specifikus formátumban.
**💾 Adatmegtakarítás:** ~40-60% payload csökkentés várható a tisztítás után!
---
## 📊 Gyors Összefoglaló Táblázat
| Mező | Használat | Cselekvés |
|------|-----------|-----------|
| `name` | ✅ Használt | Megtartani |
| `type` | ✅ Használt | Megtartani |
| `ctype` | ✅ Használt | Megtartani |
| `cards` | ✅ Használt | Megtartani |
| `description` | ❌ **Nincs a DB-ben** | **TÖRÖLNI** |
| | | |
| **Kártya mezők:** | | |
| `card.text` | ✅ Használt | Megtartani |
| `card.type` | ✅ Használt | Megtartani |
| `card.answer` | ✅ Használt | Megtartani (típus-specifikus!) |
| `card.consequence` | ✅ Használt (LUCK) | Megtartani |
| | | |
| `card.id` (frontend) | ❌ Nem releváns | **NE KÜLDJÜK** |
| `card.question` | ❌ Duplikáció | **TÖRÖLNI** (text-be) |
| `card.statement` | ❌ Duplikáció | **TÖRÖLNI** (text-be) |
| `card.options` | ❌ Felesleges | **KONVERTÁLNI** (answer-be) |
| `card.correctAnswer` | ❌ Felesleges | **KONVERTÁLNI** (answer-be) |
| `card.leftItems` | ❌ Felesleges | **KONVERTÁLNI** (answer-be) |
| `card.rightItems` | ❌ Felesleges | **KONVERTÁLNI** (answer-be) |
| `card.correctPairs` | ❌ Felesleges | **KONVERTÁLNI** (answer-be) |
| `card.acceptedAnswers` | ❌ Felesleges | **KONVERTÁLNI** (answer-be) |
| `card.hint` | ❌ Nincs implementálva | **TÖRÖLNI** |
---
## 🎯 Deck Létrehozás/Frissítés (createDeck / updateDeck)
### Backend által HASZNÁLT mezők:
```typescript
// CreateDeckCommand / UpdateDeckCommand
{
name: string, // ✅ HASZNÁLT - Pakli neve
type: number, // ✅ HASZNÁLT - 0=LUCK, 1=JOKER, 2=QUESTION
userid: string, // ✅ HASZNÁLT - Automatikusan hozzáadódik az authRequired middleware-ből
cards: any[], // ✅ HASZNÁLT - Kártyák tömbje
ctype?: number, // ✅ HASZNÁLT - 0=PUBLIC, 1=PRIVATE, 2=ORGANIZATION
state?: number, // ✅ HASZNÁLT - De csak admin állíthatja (0=ACTIVE, 1=SOFT_DELETE)
authLevel: number // ✅ HASZNÁLT - Automatikusan jön az auth middleware-ből
}
```
### Frontend által KÜLDÖTT de FELESLEGES mezők:
#### 1. **`description` mező** - ❌ NEM HASZNÁLT
**Helyek:** `DeckCreator.jsx` (line ~100-110, ~170)
```javascript
// FELESLEGES - Backend nem tárolja, nem használja
const payload = {
name: deck.name?.trim() || "Névtelen pakli",
type: typeMapping[deck.type] ?? 2,
ctype: ctypeMapping[deck.privacy] ?? 1,
cards: cleanedCards
// description: deck.description // ❌ Ez NINCS a backend sémában!
}
```
**Megjegyzés a kódban (line ~171):**
```javascript
// Note: description field is not sent to backend as it's not supported yet
```
**Javaslat:**
- Ha a `description` soha nem lesz használva → töröljük a frontend state-ből
- Ha később implementálni fogjuk → adjuk hozzá a backend DeckAggregate entitáshoz először
---
## 📇 Kártya Mezők (cards array)
### Backend Card Interface:
```typescript
export interface Card {
text: string; // ✅ KÖTELEZŐ
type?: CardType; // ✅ OPCIONÁLIS - 0=QUIZ, 1=PAIRING, 2=OWN_ANSWER, 3=TRUE_FALSE, 4=CLOSER
answer?: string | null; // ✅ OPCIONÁLIS
consequence?: Consequence | null; // ✅ OPCIONÁLIS (csak LUCK kártyáknál)
}
```
### Frontend által KÜLDÖTT de ESETLEG FELESLEGES kártya mezők:
#### A. **Duplikált mezők** (ugyanaz az adat több néven):
```javascript
// DeckCreator.jsx - cleanedCards mapping (line ~130-165)
// 1. TEXT mező duplikáció - ⚠️ REDUNDÁNS
cleanedCard.text = card.text || card.question || card.statement || ""
if (card.question !== undefined) cleanedCard.question = card.question // ❌ Felesleges?
if (card.statement !== undefined) cleanedCard.statement = card.statement // ❌ Felesleges?
// Backend csak a `text` mezőt használja!
// A `question` és `statement` valószínűleg NEM SZÜKSÉGESEK
```
**Megjegyzés:** A backend `Card` interfészben **nincs** `question` vagy `statement` mező, csak `text`.
#### B. **QUESTION típusú kártyák extra mezői** - ⚠️ ELLENŐRIZENDŐ
```javascript
// Ezek a mezők a DeckCreator.jsx-ben kerülnek hozzáadásra (line ~145-155)
if (card.question !== undefined) cleanedCard.question = card.question
if (card.statement !== undefined) cleanedCard.statement = card.statement
if (card.options !== undefined) cleanedCard.options = card.options
if (card.correctAnswer !== undefined) cleanedCard.correctAnswer = card.correctAnswer
if (card.leftItems !== undefined) cleanedCard.leftItems = card.leftItems
if (card.rightItems !== undefined) cleanedCard.rightItems = card.rightItems
if (card.correctPairs !== undefined) cleanedCard.correctPairs = card.correctPairs
if (card.acceptedAnswers !== undefined) cleanedCard.acceptedAnswers = card.acceptedAnswers
if (card.hint !== undefined) cleanedCard.hint = card.hint
```
**Backend Card interfész ezeket NEM tartalmazza:**
-`question` - Nincs a Card interface-ben
-`statement` - Nincs a Card interface-ben
-`options` - Nincs a Card interface-ben
-`correctAnswer` - Nincs a Card interface-ben
-`leftItems` - Nincs a Card interface-ben
-`rightItems` - Nincs a Card interface-ben
-`correctPairs` - Nincs a Card interface-ben
-`acceptedAnswers` - Nincs a Card interface-ben
-`hint` - Nincs a Card interface-ben
**KRITIKUS KÉRDÉS:**
- Ezek a mezők **JSON-ként tárolódnak** a `cards` mezőben?
- A backend TypeORM `@Column({ type: 'json' })` deklaráció miatt bármit el tud tárolni
- De a **Card interface** szerint csak `text`, `type`, `answer`, `consequence` mezőket használ
**Két lehetséges eset:**
1. **Ha a backend JSON mezőként tárolja de nem használja ezeket:**
- ❌ FELESLEGESEK - Adatbázis helyet pazarolnak
- Javaslat: Tisztítsuk meg a frontend-et, ne küldje őket
2. **Ha a backend valahol mégis használja (pl. game logic-ban):**
- ✅ SZÜKSÉGESEK - De akkor frissíteni kell a Card interface-t
---
## 🎮 Consequence mező - ✅ RENDBEN (de típus ellenőrzés szükséges)
```javascript
// DeckCreator.jsx (line ~160-162)
if (deck.type === 'LUCK' && card.consequence) {
cleanedCard.consequence = card.consequence
}
```
**Backend Consequence interface:**
```typescript
export interface Consequence {
type: ConsequenceType; // 0-5 közötti szám
value?: number;
}
```
**Javaslat:** Ellenőrizni kell hogy a frontend mindig valid `ConsequenceType` enum értéket küld-e (0-5).
---
## 🔍 Részletes Backend vs Frontend Mapping
### Deck Level
| Frontend Mező | Backend Mező | Használat | Megjegyzés |
|--------------|-------------|----------|-----------|
| `deck.id` | `id` | ✅ Használt | UUID |
| `deck.name` | `name` | ✅ Használt | string (max 255) |
| `deck.type` | `type` | ✅ Használt | 0/1/2 (enum) |
| `deck.privacy` | `ctype` | ✅ Használt | 0/1/2 (enum) |
| `deck.description` | - | ❌ **NEM LÉTEZIK** | **FELESLEGES** |
| `deck.cards` | `cards` | ✅ Használt | JSON array |
| `deck.creationdate` | `creationdate` | ✅ Használt | Date (readonly) |
| `deck.updatedate` | `updateDate` | ✅ Használt | Date (readonly) |
### Card Level (QUESTION típusú kártyák)
| Frontend Mező | Backend Card Interface | Használat | Megjegyzés |
|--------------|----------------------|----------|-----------|
| `card.id` | - | ❌ **Lokális azonosító** | Csak frontend-en, backenden nem releváns |
| `card.text` | `text` | ✅ Használt | Fő szöveg |
| `card.question` | - | ❓ **Ellenőrizendő** | Lehet felesleges (text duplikáció?) |
| `card.statement` | - | ❓ **Ellenőrizendő** | Lehet felesleges (text duplikáció?) |
| `card.type` / `card.subType` | `type` | ✅ Használt | CardType enum (0-4) |
| `card.answer` | `answer` | ✅ Használt | String vagy null |
| `card.options` | - | ❓ **Ellenőrizendő** | Nincs a Card interface-ben |
| `card.correctAnswer` | - | ❓ **Ellenőrizendő** | Nincs a Card interface-ben |
| `card.leftItems` | - | ❓ **Ellenőrizendő** | Nincs a Card interface-ben |
| `card.rightItems` | - | ❓ **Ellenőrizendő** | Nincs a Card interface-ben |
| `card.correctPairs` | - | ❓ **Ellenőrizendő** | Nincs a Card interface-ben |
| `card.acceptedAnswers` | - | ❓ **Ellenőrizendő** | Nincs a Card interface-ben |
| `card.hint` | - | ❓ **Ellenőrizendő** | Nincs a Card interface-ben |
| `card.consequence` | `consequence` | ✅ Használt | Csak LUCK típusnál |
---
## ⚠️ BACKEND GAME LOGIC VIZSGÁLAT - ✅ KÉSZ
### 1. Kártya mezők tényleges használata - ELLENŐRIZVE ✅
**Ellenőrzött fájlok:**
-`SerpentRace_Backend/src/Application/Services/CardProcessingService.ts`
-`SerpentRace_Backend/src/Application/Services/CardDrawingService.ts`
**EREDMÉNY: A backend CSAK az `answer` mezőt használja!**
**Backend Card használat:**
```typescript
export interface Card {
text: string; // ✅ Kérdés szövege
type?: CardType; // ✅ Kártya típus (0-4)
answer?: string | null; // ✅ EGYETLEN valid mező a válaszokhoz!
consequence?: Consequence | null; // ✅ Csak LUCK kártyákhoz
}
```
**Fontos:** A backend `answer` mező **típus-specifikus formátumú**:
1. **QUIZ (type: 0)**`answer` = `QuizOption[]` array:
```typescript
answer: [
{ answer: "A", text: "First option", correct: false },
{ answer: "B", text: "Second option", correct: true },
...
]
```
2. **SENTENCE_PAIRING (type: 1)** → `answer` = Párosítás array:
```typescript
answer: [
{ left: "Apple", right: "Red" },
{ left: "Banana", right: "Yellow" }
]
```
3. **OWN_ANSWER (type: 2)** → `answer` = String vagy String array:
```typescript
answer: ["correct answer 1", "correct answer 2"]
```
4. **TRUE_FALSE (type: 3)** → `answer` = Boolean:
```typescript
answer: true // vagy false
```
5. **CLOSER (type: 4)** → `answer` = Object:
```typescript
answer: { correct: 42, percent: 10 }
```
**KÖVETKEZTETÉS:**
- ❌ **A frontend által küldött `options`, `correctAnswer`, `acceptedAnswers`, `leftItems`, `rightItems`, `correctPairs` mezők MIND FELESLEGESEK!**
- ✅ **Csak az `answer` mezőt kellene küldeni, megfelelő formátumban!**
### 2. Card Type Mapping
**Frontend:**
```javascript
const cardTypeMapping = {
'quiz': 0, // QUIZ
'pairing': 1, // SENTENCE_PAIRING
'text': 2, // OWN_ANSWER
'truefalse': 3, // TRUE_FALSE
'closer': 4 // CLOSER
}
```
**Backend CardType enum:**
```typescript
export enum CardType {
QUIZ = 0,
SENTENCE_PAIRING = 1,
OWN_ANSWER = 2,
TRUE_FALSE = 3,
CLOSER = 4
}
```
✅ **Ez HELYES** - A mapping megfelelő
### 3. Frontend kártya ID kezelés
```javascript
// DeckCreator.jsx (line ~242)
const updatedCard = {
...cardData,
id: isCreatingCard ? Date.now() : cardData.id
}
// Line ~129
if (card.id) {
cleanedCard.id = card.id
}
```
**Probléma:** A frontend `Date.now()` timestamp ID-kat generál, de a backend UUID-kat használ.
**Javaslat:**
- ❌ NE küldjük a frontend-generált `id`-t a backendnek
- A backend a create során generál UUID-t
- Update-nél a backend már ismeri az ID-t (URL parameter-ből jön)
---
## 📝 JAVASOLT TISZTÍTÁSOK
### Prioritás 1: BIZTOS FELESLEGESEK
1. **`description` mező törlése**
- Fájl: `DeckCreator.jsx`
- Sorok: ~20, ~40-45, ~100-105
- Töröljük a state-ből és ne küldjük a backendnek
2. **Frontend-generált kártya `id` ne menjen a backendre**
- Fájl: `DeckCreator.jsx`
- Sor: ~129
- Kommenteljük ki vagy töröljük: `if (card.id) cleanedCard.id = card.id`
### Prioritás 2: BIZONYÍTOTTAN FELESLEGESEK ✅
3. **Duplikált text mezők (`question`, `statement`)** - ❌ FELESLEGES
- A backend **csak `text`-et használ**
- Töröljük: `question` és `statement` mezők küldését
4. **QUESTION kártya részletes mezők - MIND FELESLEGESEK ❌**
- A backend GameService **NEM használja** ezeket:
- ❌ `options` - Felesleges (backend: `answer` array használ)
- ❌ `correctAnswer` - Felesleges (backend: `answer` array-ben `correct: true`)
- ❌ `leftItems` / `rightItems` / `correctPairs` - Felesleges (backend: `answer` array-ben `{left, right}` párok)
- ❌ `acceptedAnswers` - Felesleges (backend: `answer` string array)
- ❌ `hint` - Nincs implementálva a backenden
**HELYETTE:** Konvertáljuk ezeket megfelelő `answer` formátumra!
---
## 🔄 HELYES KONVERZIÓ - Példák
### Jelenlegi (FELESLEGES mezőkkel):
```javascript
// ❌ ROSSZ - Felesleges mezők küldése
const cleanedCard = {
text: "Mi a főváros?",
type: 0, // QUIZ
question: "Mi a főváros?", // ❌ DUPLIKÁCIÓ
options: ["Budapest", "Berlin", "Prága"], // ❌ FELESLEGES
correctAnswer: 0 // ❌ FELESLEGES
}
```
### Helyes (Optimalizált):
```javascript
// ✅ JÓ - Csak szükséges mezők
const cleanedCard = {
text: "Mi a főváros?",
type: 0, // QUIZ
answer: [
{ answer: "A", text: "Budapest", correct: true },
{ answer: "B", text: "Berlin", correct: false },
{ answer: "C", text: "Prága", correct: false }
]
}
```
### Konverziós Példák Típusonként:
#### 1. QUIZ (type: 0) - Feleletválasztós
**Frontend állapot:**
```javascript
card = {
subType: 'multiplechoice',
question: "Melyik a helyes?",
options: ["A válasz", "B válasz", "C válasz"],
correctAnswer: 1
}
```
**Helyes backend formátum:**
```javascript
cleanedCard = {
text: "Melyik a helyes?",
type: 0,
answer: [
{ answer: "A", text: "A válasz", correct: false },
{ answer: "B", text: "B válasz", correct: true }, // correctAnswer: 1
{ answer: "C", text: "C válasz", correct: false }
]
}
```
#### 2. SENTENCE_PAIRING (type: 1) - Párosítás
**Frontend állapot:**
```javascript
card = {
subType: 'matching',
question: "Párosítsd össze!",
leftItems: ["Alma", "Banán"],
rightItems: ["Piros", "Sárga"],
correctPairs: { 0: 0, 1: 1 } // leftItems[0] -> rightItems[0]
}
```
**Helyes backend formátum:**
```javascript
cleanedCard = {
text: "Párosítsd össze!",
type: 1,
answer: [
{ left: "Alma", right: "Piros" },
{ left: "Banán", right: "Sárga" }
]
}
```
#### 3. OWN_ANSWER (type: 2) - Szöveges válasz
**Frontend állapot:**
```javascript
card = {
subType: 'text',
question: "Mi a főváros?",
acceptedAnswers: ["Budapest", "budapest", "Bp"]
}
```
**Helyes backend formátum:**
```javascript
cleanedCard = {
text: "Mi a főváros?",
type: 2,
answer: ["Budapest", "budapest", "Bp"]
}
```
#### 4. TRUE_FALSE (type: 3) - Igaz/Hamis
**Frontend állapot:**
```javascript
card = {
subType: 'truefalse',
statement: "A Föld lapos.",
correctAnswer: 1, // 0=Igaz, 1=Hamis
isTrue: false
}
```
**Helyes backend formátum:**
```javascript
cleanedCard = {
text: "A Föld lapos.",
type: 3,
answer: false
}
```
#### 5. CLOSER (type: 4) - Tippelés
**Frontend állapot:**
```javascript
card = {
subType: 'closer',
question: "Hány lakosa van Budapestnek?",
correctAnswer: 1750000,
tolerance: 10 // ±10%
}
```
**Helyes backend formátum:**
```javascript
cleanedCard = {
text: "Hány lakosa van Budapestnek?",
type: 4,
answer: {
correct: 1750000,
percent: 10
}
}
```
---
## 🔧 TESZTELÉSI TERV
1. **Logolás hozzáadása a backenden:**
```typescript
// CreateDeckCommandHandler.ts, UpdateDeckCommandHandler.ts
console.log('Received card data:', cmd.cards)
console.log('Card keys:', Object.keys(cmd.cards[0]))
```
2. **Frontendről küldött payload ellenőrzése:**
```javascript
// DeckCreator.jsx - handleSaveDeck
console.log('Payload before send:', JSON.stringify(payload, null, 2))
```
3. **Adatbázisban tárolt JSON ellenőrzése:**
```sql
SELECT id, name, cards FROM Decks WHERE id = 'xyz' LIMIT 1;
```
---
## ✅ KÖVETKEZŐ LÉPÉSEK
1. ✅ **Dokumentáció elkészült** - Ez a fájl
2. ✅ **Backend game logic ellenőrzés** - KÉSZ! Csak `answer` mezőt használ
3. ⏳ **Frontend konverzió implementálás** - Következő feladat:
- Új függvény: `convertCardToBackendFormat(card, deckType)`
- Minden kártyatípushoz megfelelő `answer` formátum generálása
- Felesleges mezők eltávolítása
4. ⏳ **Tesztelés** - Minden működik-e a változások után?
---
## 🛠️ IMPLEMENTÁCIÓS TERV
### 1. Létrehozandó segédfüggvény: `cardBackendConverter.js`
```javascript
// src/utils/cardBackendConverter.js
/**
* Konvertálja a frontend kártya formátumot backend-kompatibilis formátumra
* @param {Object} card - Frontend kártya objektum
* @param {string} deckType - Pakli típusa ('LUCK', 'JOKER', 'QUESTION')
* @returns {Object} Backend-kompatibilis kártya objektum
*/
export function convertCardToBackendFormat(card, deckType) {
const baseCard = {
text: card.text || card.question || card.statement || "",
}
// CardType mapping
const cardTypeMapping = {
'quiz': 0,
'multiplechoice': 0, // Alias
'pairing': 1,
'matching': 1, // Alias
'text': 2,
'truefalse': 3,
'closer': 4
}
const cardType = cardTypeMapping[card.subType] ?? cardTypeMapping[card.subType?.toLowerCase()]
if (cardType !== undefined) {
baseCard.type = cardType
}
// Típus-specifikus answer konverzió
switch (cardType) {
case 0: // QUIZ
if (card.options && Array.isArray(card.options)) {
baseCard.answer = card.options.map((opt, idx) => ({
answer: String.fromCharCode(65 + idx), // A, B, C, D...
text: opt,
correct: idx === card.correctAnswer
}))
}
break
case 1: // SENTENCE_PAIRING
if (card.leftItems && card.rightItems && card.correctPairs) {
baseCard.answer = Object.entries(card.correctPairs).map(([leftIdx, rightIdx]) => ({
left: card.leftItems[parseInt(leftIdx)],
right: card.rightItems[parseInt(rightIdx)]
}))
}
break
case 2: // OWN_ANSWER
if (card.acceptedAnswers && Array.isArray(card.acceptedAnswers)) {
baseCard.answer = card.acceptedAnswers.filter(a => a && a.trim())
}
break
case 3: // TRUE_FALSE
if (card.correctAnswer !== undefined) {
baseCard.answer = card.correctAnswer === 0 // 0=Igaz, 1=Hamis
} else if (card.isTrue !== undefined) {
baseCard.answer = card.isTrue
}
break
case 4: // CLOSER
if (card.correctAnswer !== undefined && card.tolerance !== undefined) {
baseCard.answer = {
correct: card.correctAnswer,
percent: card.tolerance
}
}
break
}
// LUCK típusú kártyákhoz consequence
if (deckType === 'LUCK' && card.consequence) {
baseCard.consequence = card.consequence
}
return baseCard
}
```
### 2. Módosítandó fájl: `DeckCreator.jsx`
**Jelenlegi kód (line ~120-165):**
```javascript
// ❌ RÉGI - Felesleges mezők küldése
const cleanedCards = validCards.map(card => {
const cleanedCard = {}
if (card.id) cleanedCard.id = card.id
if (card.subType && cardTypeMapping[card.subType] !== undefined) {
cleanedCard.type = cardTypeMapping[card.subType]
}
cleanedCard.text = card.text || card.question || card.statement || ""
if (card.question !== undefined) cleanedCard.question = card.question // FELESLEGES
if (card.statement !== undefined) cleanedCard.statement = card.statement // FELESLEGES
if (card.options !== undefined) cleanedCard.options = card.options // FELESLEGES
// ... stb
return cleanedCard
})
```
**Új kód:**
```javascript
// ✅ ÚJ - Csak szükséges mezők
import { convertCardToBackendFormat } from '../../utils/cardBackendConverter'
const cleanedCards = validCards.map(card =>
convertCardToBackendFormat(card, deck.type)
)
```
### 3. Tesztelési checklist
- [ ] QUIZ kártyák helyes answer formátummal mentődnek
- [ ] SENTENCE_PAIRING kártyák helyes left-right párokkal mentődnek
- [ ] OWN_ANSWER kártyák acceptedAnswers array-ként mentődnek
- [ ] TRUE_FALSE kártyák boolean answer-rel mentődnek
- [ ] CLOSER kártyák {correct, percent} formátummal mentődnek
- [ ] LUCK kártyák consequence mezője megmarad
- [ ] Mentett paklik betöltése és szerkesztése működik
- [ ] Játék során kártyák feldolgozása helyes
---
**Utolsó frissítés:** 2025-11-03
**Készítette:** GitHub Copilot
**Cél:** Adatoptimalizálás és felesleges payload csökkentés
---
## 📈 VÁRHATÓ EREDMÉNYEK
### Payload méret csökkenés példa:
**ELŐTTE (jelenleg):**
```json
{
"name": "Teszt Pakli",
"type": 2,
"ctype": 1,
"description": "Ez egy leírás", // ❌ FELESLEGES
"cards": [
{
"id": 1730123456789, // ❌ FELESLEGES
"text": "Mi a főváros?",
"question": "Mi a főváros?", // ❌ DUPLIKÁCIÓ
"type": 0,
"options": ["Budapest", "Berlin", "Prága"], // ❌ FELESLEGES
"correctAnswer": 0 // ❌ FELESLEGES
}
]
}
// Méret: ~280 byte
```
**UTÁNA (optimalizált):**
```json
{
"name": "Teszt Pakli",
"type": 2,
"ctype": 1,
"cards": [
{
"text": "Mi a főváros?",
"type": 0,
"answer": [
{"answer": "A", "text": "Budapest", "correct": true},
{"answer": "B", "text": "Berlin", "correct": false},
{"answer": "C", "text": "Prága", "correct": false}
]
}
]
}
// Méret: ~190 byte
```
**💾 Megtakarítás: ~32% ebben a példában!**
---
## 🎉 VÉGSŐ ÖSSZEFOGLALÁS
### Felesleges mezők száma:
- **Deck level:** 1 mező (`description`)
- **Card level:** 9 mező (`id`, `question`, `statement`, `options`, `correctAnswer`, `leftItems`, `rightItems`, `correctPairs`, `acceptedAnswers`, `hint`)
### Összes felesleges mező: **10 db**
### Ajánlott lépések:
1. ✅ Dokumentáció áttekintése
2. 🔄 `cardBackendConverter.js` implementálása
3. 🔧 `DeckCreator.jsx` módosítása
4. ✅ Tesztelés minden kártyatípussal
5. 🚀 Deploy
**Becsült munkaidő:** 2-3 óra implementálás + 1 óra tesztelés
---
## 📞 Kérdések / Problémák esetén
Ha bármilyen kérdés merül fel az implementálás során:
1. Ellenőrizd a backend `CardProcessingService.ts` fájlt
2. Nézd meg a példákat ebben a dokumentációban
3. Teszteld lokálisan először egy kis paklival
**Fontos:** A backend JSON mezőként tárolja a `cards` array-t, ezért bármit elfogad - de csak a dokumentált mezőket használja!
@@ -145,8 +145,6 @@ const Card_display = () => {
"QUESTION": "Kérdés", "QUESTION": "Kérdés",
"LUCK": "Szerencse", "LUCK": "Szerencse",
"JOKER": "Joker", "JOKER": "Joker",
"joker": "Joker",
"luck": "Szerencse",
// If backend converts to different numbers, map them: // If backend converts to different numbers, map them:
"0": "Igaz/Hamis", // truefalse = 0 "0": "Igaz/Hamis", // truefalse = 0
"1": "Feleletválasztós", // multiplechoice = 1 "1": "Feleletválasztós", // multiplechoice = 1
@@ -354,7 +352,7 @@ const Card_display = () => {
)} )}
{paginatedCards.map((card, idx) => { {paginatedCards.map((card, idx) => {
const cardIndex = startIndex + idx + 1 const cardIndex = startIndex + idx + 1
const questionText = card.text || card.question || card.statement || 'Kérdés hiányzik' const questionText = card.question || card.statement || 'Kérdés hiányzik'
// Get answers based on card type // Get answers based on card type
let answerOptions = [] let answerOptions = []
@@ -366,30 +364,13 @@ const Card_display = () => {
// Detect card type by fields if subType is missing // Detect card type by fields if subType is missing
let detectedType = subType let detectedType = subType
if (subType === 'undefined' || subType === 'null') { if (subType === 'undefined' || subType === 'null') {
// First check deck type - if deck is JOKER or LUCK type, cards inherit that // Check by numeric type field first
if (deck.type === 1) { if (card.type === 3) {
// Deck type 1 = Joker deck // type 3 = True/False
detectedType = 'joker' detectedType = 'truefalse'
} else if (deck.type === 0) { } else if (card.type === 2) {
// Deck type 0 = Luck deck // type 2 = Text answer
detectedType = 'luck' detectedType = 'text'
} else if (card.type !== undefined) {
// Check by card.type field (string or numeric)
const cardType = typeof card.type === 'string' ? card.type.toLowerCase() : card.type
if (cardType === 'joker' || card.type === 'JOKER') {
// Joker card
detectedType = 'joker'
} else if (cardType === 'luck' || card.type === 'LUCK') {
// Luck card
detectedType = 'luck'
} else if (card.type === 3) {
// type 3 = True/False
detectedType = 'truefalse'
} else if (card.type === 2) {
// type 2 = Text answer
detectedType = 'text'
}
} else if (card.leftItems && card.rightItems && card.correctPairs) { } else if (card.leftItems && card.rightItems && card.correctPairs) {
// Has leftItems, rightItems AND correctPairs = matching // Has leftItems, rightItems AND correctPairs = matching
detectedType = 'matching' detectedType = 'matching'
@@ -404,28 +385,6 @@ const Card_display = () => {
} }
} }
// Extract consequence info for JOKER and LUCK cards
let consequenceText = null
if ((detectedType === 'joker' || detectedType === 'luck') && card.consequence) {
const consequenceLabels = {
0: 'Lépj előre',
1: 'Lépj hátra',
2: 'Kör kihagyás',
3: 'Extra kör',
5: 'Vissza a starthoz'
}
const consequenceType = consequenceLabels[card.consequence.type] || 'Ismeretlen hatás'
const consequenceValue = card.consequence.value
if (consequenceValue && [0, 1].includes(card.consequence.type)) {
consequenceText = `${consequenceType} ${consequenceValue} mezőt`
} else if (consequenceValue && [2, 3].includes(card.consequence.type)) {
consequenceText = `${consequenceType} (${consequenceValue} kör)`
} else {
consequenceText = consequenceType
}
}
if (detectedType === 'truefalse' || detectedType === '0') { if (detectedType === 'truefalse' || detectedType === '0') {
// True/False cards // True/False cards
answerOptions = ['Igaz', 'Hamis'] answerOptions = ['Igaz', 'Hamis']
@@ -473,92 +432,16 @@ const Card_display = () => {
return ( return (
<div <div
key={cardId} key={cardId}
className="relative h-80" className="relative h-80 cursor-pointer"
style={{ perspective: "1000px" }} style={{ perspective: "1000px" }}
onClick={() => toggleCardFlip(cardId)}
> >
{detectedType === 'joker' ? (
// Joker card - no flip, just show the task
<div
className="w-full h-full bg-[color:var(--color-card)] rounded-2xl p-6 shadow-lg border-l-4 flex flex-col"
style={{
borderLeftColor: "var(--color-fun)",
}}
>
<div className="flex items-center justify-between mb-3">
<span className="text-[color:var(--color-text-muted)] text-sm font-medium">
Kártya #{cardIndex}
</span>
<span
className="inline-block px-2 py-1 rounded-full text-xs font-bold"
style={{
background: "var(--color-fun)",
color: "var(--color-text-inverse)",
}}
>
🃏 JOKER
</span>
</div>
<div className="flex-1 flex flex-col items-center justify-center">
<div className="text-6xl mb-4">🃏</div>
<div className="text-[color:var(--color-text)] text-center text-lg font-medium bg-[color:var(--color-fun)]/20 rounded-lg px-6 py-4 border-2 border-[color:var(--color-fun)]">
{questionText}
</div>
</div>
<div className="pt-3 border-t border-[color:var(--color-surface-selected)] text-xs text-[color:var(--color-text-muted)] text-center">
<div>Típus: <span className="font-semibold">Joker</span></div>
</div>
</div>
) : detectedType === 'luck' ? (
// Luck card - no flip, show text and consequence
<div
className="w-full h-full bg-[color:var(--color-card)] rounded-2xl p-6 shadow-lg border-l-4 flex flex-col"
style={{
borderLeftColor: "var(--color-luck)",
}}
>
<div className="flex items-center justify-between mb-3">
<span className="text-[color:var(--color-text-muted)] text-sm font-medium">
Kártya #{cardIndex}
</span>
<span
className="inline-block px-2 py-1 rounded-full text-xs font-bold"
style={{
background: "var(--color-luck)",
color: "var(--color-text-inverse)",
}}
>
🎲 SZERENCSE
</span>
</div>
<div className="flex-1 flex flex-col items-center justify-center">
<div className="text-6xl mb-4">🎲</div>
<div className="text-[color:var(--color-text)] text-center text-lg font-medium bg-[color:var(--color-luck)]/20 rounded-lg px-6 py-4 border-2 border-[color:var(--color-luck)] mb-4">
{questionText}
</div>
{consequenceText && (
<div className="text-[color:var(--color-text)] text-center">
<div className="text-xl font-bold bg-[color:var(--color-luck)]/30 rounded-lg px-6 py-3 border-2 border-[color:var(--color-luck)]">
{consequenceText}
</div>
</div>
)}
</div>
<div className="pt-3 border-t border-[color:var(--color-surface-selected)] text-xs text-[color:var(--color-text-muted)] text-center">
<div>Típus: <span className="font-semibold">Szerencse</span></div>
</div>
</div>
) : (
<div <div
className={`relative w-full h-full transition-transform duration-500 ${detectedType !== 'joker' && detectedType !== 'luck' ? 'cursor-pointer' : ''}`} className={`relative w-full h-full transition-transform duration-500`}
style={{ style={{
transformStyle: "preserve-3d", transformStyle: "preserve-3d",
transform: isFlipped ? "rotateY(180deg)" : "rotateY(0deg)" transform: isFlipped ? "rotateY(180deg)" : "rotateY(0deg)"
}} }}
onClick={detectedType !== 'joker' && detectedType !== 'luck' ? () => toggleCardFlip(cardId) : undefined}
> >
{/* Front side - Question */} {/* Front side - Question */}
<div <div
@@ -572,39 +455,15 @@ const Card_display = () => {
<span className="text-[color:var(--color-text-muted)] text-sm font-medium"> <span className="text-[color:var(--color-text-muted)] text-sm font-medium">
Kártya #{cardIndex} Kártya #{cardIndex}
</span> </span>
{detectedType !== 'joker' && detectedType !== 'luck' && ( <span
<span className="inline-block px-2 py-1 rounded-full text-xs font-bold"
className="inline-block px-2 py-1 rounded-full text-xs font-bold" style={{
style={{ background: currentDeckType?.color || "var(--color-success)",
background: currentDeckType?.color || "var(--color-success)", color: "var(--color-text-inverse)",
color: "var(--color-text-inverse)", }}
}} >
> {answerCount} válasz
{answerCount} válasz </span>
</span>
)}
{detectedType === 'joker' && (
<span
className="inline-block px-2 py-1 rounded-full text-xs font-bold"
style={{
background: "var(--color-fun)",
color: "var(--color-text-inverse)",
}}
>
🃏 JOKER
</span>
)}
{detectedType === 'luck' && (
<span
className="inline-block px-2 py-1 rounded-full text-xs font-bold"
style={{
background: "var(--color-luck)",
color: "var(--color-text-inverse)",
}}
>
🎲 SZERENCSE
</span>
)}
</div> </div>
<h3 className="text-lg font-bold text-[color:var(--color-text)] mb-3"> <h3 className="text-lg font-bold text-[color:var(--color-text)] mb-3">
@@ -633,7 +492,7 @@ const Card_display = () => {
> >
<div className="flex items-center justify-between mb-3"> <div className="flex items-center justify-between mb-3">
<span className="text-[color:var(--color-text-muted)] text-sm font-medium"> <span className="text-[color:var(--color-text-muted)] text-sm font-medium">
{detectedType === 'joker' || detectedType === 'luck' ? 'Kártya hatás' : 'Megoldás'} Megoldás
</span> </span>
<span <span
className="inline-block px-2 py-1 rounded-full text-xs font-bold" className="inline-block px-2 py-1 rounded-full text-xs font-bold"
@@ -642,37 +501,11 @@ const Card_display = () => {
color: "var(--color-text-inverse)", color: "var(--color-text-inverse)",
}} }}
> >
{detectedType === 'joker' || detectedType === 'luck' ? (detectedType === 'joker' ? '🃏 JOKER' : '🎲 SZERENCSE') : `${answerCount} válasz`} {answerCount} válasz
</span> </span>
</div> </div>
{detectedType === 'joker' ? ( {answerCount > 0 ? (
// Joker card - just show the task/challenge
<div className="flex flex-col items-center justify-center h-full py-8">
<div className="text-6xl mb-4">🃏</div>
<div className="text-[color:var(--color-text)] text-center text-lg font-medium bg-[color:var(--color-fun)]/20 rounded-lg px-6 py-4 border-2 border-[color:var(--color-fun)]">
{questionText}
</div>
<div className="text-[color:var(--color-text-muted)] text-sm mt-4 text-center italic">
A játékmester dönti el a teljesítést
</div>
</div>
) : detectedType === 'luck' ? (
// Luck card - show consequence
<div className="flex flex-col items-center justify-center h-full py-8">
<div className="text-6xl mb-4">🎲</div>
{consequenceText && (
<div className="text-[color:var(--color-text)] text-center">
<div className="text-2xl font-bold mb-4 bg-[color:var(--color-luck)]/20 rounded-lg px-6 py-3 border-2 border-[color:var(--color-luck)]">
{consequenceText}
</div>
</div>
)}
<div className="text-[color:var(--color-text-muted)] text-sm mt-2 text-center italic">
Azonnal végrehajt
</div>
</div>
) : answerCount > 0 ? (
<div className="space-y-2"> <div className="space-y-2">
<div className="text-[color:var(--color-text-muted)] text-sm font-medium mb-2"> <div className="text-[color:var(--color-text-muted)] text-sm font-medium mb-2">
Helyes válasz: Helyes válasz:
@@ -730,7 +563,6 @@ const Card_display = () => {
</div> </div>
</div> </div>
</div> </div>
)}
</div> </div>
) )
})} })}