Vizsgajegyzetek

public static List<MintaClass> LoadFromJSON(string fileName = "minta.json")
{
    var jsonText = File.ReadAllText(fileName);
    return JsonSerializer.Deserialize<List<MintaClass>>(jsonText) ?? new List<MintaClass>();
}

List<MintaClass> minta = new List<MintaClass>(); // lehet var is
var minta = new List<MintaClass>();

try
{
    minta = MintaClass.LoadFromJSON();
}
catch
{
    Console.WriteLine("Hiba");
}

public int Valami { get; set; } // nem lehet null → default: 0
public int? Valami { get; set; } // lehet null

• {x:F0} → nincs tizedesjegy
  Pl: 12.78 → 13
• {x:F1} → 1 tizedesjegy
  Pl: 12.78 → 12.8
• {x:F2} → 2 tizedesjegy
  Pl: 12.78 → 12.78
• {d:F} → teljes dátum és idő
  Pl: 2024. június 29. 14:30:00
• {d:d} → rövid dátum
  Pl: 2024.06.29.
• {d:t} → rövid idő formátum
  Pl: 14:30
• {d:T} → teljes idő formátum
  Pl: 14:30:00
• {d:yyyy.MM.dd HH:mm} → egyedi dátum + idő formátum
  Pl: 2024.06.29 14:30

Formázás példa

double x = 12.786;
DateTime d = DateTime.Now;

Console.WriteLine($"{x:F1}");
Console.WriteLine($"{d:yyyy.MM.dd HH:mm}");
  

Vizualizálva

12.786
   ↓ F1
12.8

2024.06.29 14:30:45
        ↓ yyyy.MM.dd HH:mm
2024.06.29 14:30
  

• Where(x => ...) → Szűrés feltétel alapján
  Pl: csak a 18 év felettiek → people.Where(p => p.Age >= 18)
• Select(x => ...) → Adatok átalakítása más formára
  Pl: csak neveket kérsz le → people.Select(p => p.Name)
• SelectMany(...) → Lista a listából → egy nagy lista
  [[1,2],[3,4]] => [1,2,3,4]
• OrderBy(x => ...) → Növekvő rendezés
  Pl: név szerint A-Z → people.OrderBy(p => p.Name)
• OrderByDescending(...) → Csökkenő rendezés
  Pl: legnagyobb pontszámtól → scores.OrderByDescending(x => x)
• GroupBy(x => ...) → Csoportosítás kulcs szerint
  Pl: diákok osztály szerint → students.GroupBy(s => s.Class)
• ToList() → IEnumerable → List
  Pl: módosítható lista kell → query.ToList()
• ToArray() → Tömbbé alakítás
  Pl: fix méretű tömb kell → query.ToArray()
• First() → Első elem
  Hiba, ha nincs elem → numbers.First()
• FirstOrDefault() → Első elem vagy default/null
  Biztonságosabb üres listánál → numbers.FirstOrDefault()
• Single() → Pontosan 1 elem kell
  Hiba, ha 0 vagy több van → users.Single(u => u.Id == 5)
• SingleOrDefault() → 0 vagy 1 elem lehet
  Hiba, ha több van → users.SingleOrDefault(u => u.Id == 5)
• Count() → Elemszám
  Pl: hány elem van? → numbers.Count()
• Sum(x => ...) → Összegzés
  Pl: fizetések összege → employees.Sum(e => e.Salary)
• Max() / Min() → Legnagyobb / legkisebb elem
  Pl: legmagasabb pont → scores.Max()
• Average() → Átlag számítás
  Pl: átlag életkor → people.Average(p => p.Age)
• Distinct() → Duplikátumok eltávolítása
  [1,1,2,2] => [1,2]
• Skip(n) → Első n elem kihagyása
  Pl: lapozás → numbers.Skip(10)
• Zip(a,b,(x,y)=>...) → Két lista párosítása
  ["A","B"] + [1,2] => A1,B2
• Join(...) → Két lista összekapcsolása kulcs alapján
  Pl: users + orders → users.Join(...)

LINQ folyamat vizuálisan

[összes ember]
       ↓ Where
[felnőttek]
       ↓ OrderBy
[rendezett felnőttek]
       ↓ Select
[csak nevek]
       ↓ ToList
[List<string>]

Példa pipeline

var result = people
          .Where(p => p.Age > 18)
          .OrderBy(p => p.Name)
          .Select(p => p.Name)
          .ToList();

var ertek = 0
do
{
  try
  {
    ertek = szám_beolvasása;
  }
  catch
  {
    ertek = 0;
  }
} while (ertek <= 0);

int[] numbers = { 1, 2, 3, 4 };

var pairs = numbers.Zip(numbers.Skip(1), (a, b) => a + " -> " + b);

foreach (var item in pairs)
{
    Console.WriteLine(item);
}

// This code produces the following output:
// 1 -> 2
// 2 -> 3
// 3 -> 4

lista?.Where(x => feltétel1 && feltétel2)

    .OrderBy(x => x.tulajdonsag)
    .Where(x => feltétel3)
    .ToList()
    .ForEach(x =>
    {
        Console.WriteLine($"{x.adat1} - {x.adat2}");
    });

// Szöveg bekérés
Console.Write("Szöveg: ");
string text = Console.ReadLine();

// Egész szám bekérés
Console.Write("Szám: ");
int number = int.Parse(Console.ReadLine());

// Tört szám bekérés
Console.Write("Érték: ");
decimal value = decimal.Parse(Console.ReadLine().Replace(",", "."));

// Dátum bekérés
Console.Write("Dátum: ");
DateTime date = DateTime.Parse(Console.ReadLine());

var groups = lista
    .GroupBy(x => x.azonosito)
    .Select(g => new
    {
        id = g.Key,
        // esetleg id-k összehasonlítása
        elemek = g.OrderBy(x => x.valami).ToList()
    });

foreach (var item in lista)
{
    var eredmeny = item.adatok
        .Zip(item.adatok.Skip(1),
            (a, b) => szamitas)
        .Max();

    Console.WriteLine(eredmeny);
}

Egy objektumhoz több kapcsolódó elem tartozhat

public virtual ICollection<PeldaClass> PeldaCollection { get; set; } = new List<PeldaClass>();

Az objektum egy másik objektumhoz tartozik

public virtual PeldaSzuloClass Szulo { get; set; } = null!;

ICollection → több kapcsolódó adat tárolása listában

new List<>() → üres lista létrehozása

Szulo → egyetlen kapcsolódó objektum

null! → az érték később lesz beállítva

Példa:

1 légitársaság → több járat 1 járat → 1 légitársaság

Scaffold-DbContext -Connection "server=localhost;database=adatbazis-nev;uid=root;pwd=;" -Provider Mysql.EntityFrameworkCore

<DataGrid Name="dgMinta" IsReadOnly="True" AutoGenerateColumns="False">
    <DataGrid.Columns>
        <DataGridTextColumn Header="Id" Width="30" Binding="{Binding Id}" />
    </DataGrid.Columns>
</DataGrid>

Binding="{Binding Date, StringFormat=yyyy.MM.dd HH:mm}"
Binding="{Binding Price, StringFormat={}{0:# ###} Ft}"
Binding="{Binding Hossz, StringFormat={}{0:F1} km}"
Binding="{Binding Adat, TargetNullValue='N/A'}"

private MintaContext dbContext = new MintaContext();

cboMinta.ItemsSource = adatok;
cboMinta.DisplayMemberPath = "Név";
cboMinta.SelectedValuePath = "Id";
cboMinta.SelectedIndex = 0;

<ComboBox Name="cboMinta" />

var adatok = dbContext.Set<MintaClass>().ToList();

dgMinta.ItemsSource = adatok;

adatok.Insert(0, new MintaClass {});

• Bootstrap főoldal
• Bootstrap Grid Dokumentáció
• Bootstrap Táblázatok Dokumentáció

• Doksi: v20 Angular binding
• Szöveg: {{ valtozo }}
• Tulajdonság: [tulajdonsag]="változó"
• Esemény: (esemeny)="művelet"
• Kétirányú: [(ngModel)]="változó"
• Fontos: FormsModule importálása szükséges

• Doksi: v20 Angular components
• @Component(...)
• selector → HTML tag neve
• imports → modulok és komponensek
• templateUrl → külön HTML fájl
• változó → nev: tipus
• függvény → muvelet()
• betöltéskor → ngOnInit() (implementálni kell az OnInit-et)

• Doksi: Angular routing
• Sima út: routerLink="/utvonal"
• Paraméter: ['/utvonal', id]
• Aktív elem: routerLinkActive="classnev"
• Pontos egyezés: [routerLinkActiveOptions]="{ exact: true }"
• Fontos: RouterModule importálása szükséges

• Doksi: Angular routing konfiguráció
• providers: tömb
• provideRouter(...)
• provideHttpClient()

• Doksi: Angular routes
• Sima: path + component
• Paraméter: utvonal/:id
• Wildcard: ** (minden más path esetén)
• Redirect: redirectTo
• Vizsgán gyakori: wildcard mindig legalul

• Doksi: Angular HTTP
• inject: inject(HttpClient)
• Lista lekérése: get<Tipus[]>
• Egy elem lekérése: get<Tipus>
• Létrehozás: post<Tipus>
• Módosítás: put<Tipus>
• Törlés: delete()
• Query param: HttpParams → set(...)
• Teljes válasz: { observe: 'response' }
• Header olvasás: res.headers.get('header-valtozónév')

• Doksi: Angular HTTP
• subscribe({ ... })
• Siker: next
• Hiba: error
• Navigálás: navigate([""])
• Query parammal: navigate([""], { queryParams: { page: 6 } })

• Doksi: @Input • @Output
• Bemenet: @Input() változó
• Kimenet: @Output() változó és EventEmitter
• Esemény küldés: emit(érték)
• Szülőből átadás: [adat]="változó"
• Gyerek esemény figyelése: (esemény)="kezelő($event)"

• Doksi: Router tasks
• Fontos: ActivatedRoute injektálása szükséges
• Query param: activatedRoute.queryParamMap.subscribe(p => p.get('qp-név'))
• Route param: activatedRoute.snapshot.paramMap.get('rp-név')

getAll() {
  return this.http.get<Item[]>(`${this.apiUrl}/items`);
}

// Service
getDataById(id: number) {
  return this.http.get<Item>(`${this.apiUrl}/items/${id}`);
}

// Component - Subscribe
this.route.paramMap.subscribe(params => {
  const id = Number(params.get('id'));
  if (!Number.isNaN(id) && id > 0) {
    this.api.getDataById(id).subscribe(data => {
      this.item = data;
    });
  }
});

// Service
createItem(id: number, data: Item) {
  return this.http.post<Item>(`${this.apiUrl}/items/${id}`, data);
}

// Component - Subscribe form adatokkal
onSubmit(form: any) {
  const id = 5; // vagy a route param-ból
  this.api.createItem(id, form.value).subscribe({
    next: (data) => {
      this.router.navigate(['/items', data.id]);
    },
    error: (err) => {
      console.error('Hiba:', err);
    }
  });
}

• Frontend mapelés - syntax
• Prevent-default események
• Változók
• Navigálás
• Fetchelés
• SearchParams használata
• UseRouter használata
• onClick - handleClick használata
• onChange - használata
• Feltételes kód JSX-ben

const res = await axios.get("http://localhost:3000/api/mintaVégpont");

<Link className="btn" href="/mintaOldal">
  MintaFelirat
</Link>

// ezt egy <input-on belül
onChange={(e) => setData({ ...data, newValami: Number(e.target.value) })}

onClick={() => sendRating()}
// sendRating függvény meg csak egy szimpla axios.post(link, data);

import { create } from "zustand";

type GlobalStateData = {
  globalVariable?: string;
};

type GlobalStore = {
  gs: GlobalStateData;
  set: <K extends keyof GlobalStateData>(key: K, value: GlobalStateData[K]) => void;
};

export const useGlobalStore = create<GlobalStore>()((set) => ({
  gs: {
    globalVariable: "valami"
  },

  set: (key, value) =>
    set((state) => ({
      gs: {
        ...state.gs,
        [key]: value,
      },
    })),
}));

useEffect(() => {
  async function MintaData() {
    kód...
  }
  MintaData();
}, []);

"use client"

export default function HomePage() {

  kód...

  return (
    JSX kód tartalma... pl HTML tagek for ciklusok hívások stb
  )
}

              const [hiba, setHiba] = useState<string>("");
            

const { gs, set } = useGlobalStore();
set("globalVariable", "valami más");

Ez egy globális változó (bármelyik komponensben elérhető változó) értékét frissíti, gyakorlati haszna pl. UI state, light/dark mode, keresési paraméter

const [array, setArray] = useState<Model[]>([]);
setArray(apiLekeresResponse.data);

Ez a useState hook, amivel egy állapotváltozót hozol létre. Az array tartalmaz egy Model típusú tömböt, a setArray pedig egy függvény, amivel ezt az állapotot tudod később módosítani.

useEffect(() => {
  async function getData() {
    const parameter = gs.searchParameter ? gs.searchParameter : "*";
    const response = await axios.get(`url/${parameter}/valami`);
    setArray(response.data);
  }
  getData();
}, [dependencyValami]);

A useEffect hook minden alkalommal lefut, ha a "dependenyValami" frissül, üresen hagyott dependency array esetén csak az oldal betöltésekor fut le

<form onSubmit={handleSubmit}> oldal újratöltésének megakadályozása

              async function handleSubmit(event: FormEvent<HTMLFormElement>) {
              event.preventDefault();

              végpont kódja...

              }

const router = useRouter(); oldal közötti navigáció

const searhParams = useSearchParams(); // url-ből adatok kiszedése

              const példaAdat = Number(searhParams.get("példaÁtadottAdat"));
            

              {mintaAdatok.map((iterátor) => ())} // fontos a key={mintaAdatok.mintaAdat} HTML tag-en belül
            

              function FunctionName(átandandó-paraméter-neve pl-id: típus) {
              router.push(`/mintaOldalNeve?mintaVáltozó=${átandandó-paraméter-neve}`);
              }
            

              error.response?.data?.message
            

              axios.isAxiosError(error)              
            

              {változó && <div>{változó}</div>} //pl hiba
            

              import axios from "axios";
              import Image from "next/image";
              import Link from "next/link";
              import { useSearchParams } from "next/navigation";
              import { useEffect, useState } from "react";
              import { useRouter } from "next/navigation";
              import axios, { isAxiosError } from "axios";
            

Forrás: https://laravel.com/docs/13.x/routing#api-routes

php artisan install:api

Forrás: https://laravel.com/docs/13.x/eloquent

php artisan make:model ModelName -mc --api

Forrás: https://laravel.com/docs/13.x/migrations

php artisan make:migration create_table_name_table

Forrás: https://laravel.com/docs/13.x/migrations

php artisan migrate

Forrás: https://laravel.com/docs/13.x/migrations

php artisan migrate:refresh

Forrás: https://laravel.com/docs/13.x/migrations

php artisan migrate:fresh

Forrás: https://laravel.com/docs/13.x/migrations

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('flights', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('airline');
            $table->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::drop('flights');
    }
};

Forrás: https://laravel.com/docs/13.x/eloquent

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model
{
    // ...
}

Forrás: https://laravel.com/docs/13.x/eloquent

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Member extends Model
{
    public $timestamps = false;

    protected $fillable = [
        'name',
        'flight_id',
        'age',
    ];
}

php artisan make:resource ResourceName

Forrás: https://laravel.com/docs/13.x/eloquent-resources

public function toArray(Request $request): array {
    return [
        'identifier'  => $this->id,
        'title_of_something'  => strtoupper($this->title),
        'things'   => ThingResource::collection($this->whenLoaded('things')),
    ];
}

Forrás: https://laravel.com/docs/13.x/eloquent-relationships#one-to-many

// "1" oldal:
public function posts() {
    return $this->hasMany(Post::class);
}
// "N" oldal:
public function user() {
    return $this->belongsTo(User::class);
}

Forrás: https://laravel.com/docs/13.x/eloquent-relationships#many-to-many

Song.php
public function playlists() { return $this->belongsToMany(Playlist::class) }

Playlist.php
public function songs() { return $this->belongsToMany(Song::class) }

Forrás: https://laravel.com/docs/13.x/seeding

public function run(): void
    {
        User::factory(10)->create(); // 10 user generálása a factory segítségével

        $user1 = User::create(['name' => 'Name1', 'email' => 'name1@domain.hu']);

        $post1 = Post::create([
            'user_id' => $user1->id,
            'title' => 'Title',
            'content' => 'Content'
        ]);

        Comment::create([
            'post_id' => $post1->id,
            'user_name' => 'Guest',
            'body' => 'Body'
        ]);
    }

 
namespace Database\Seeders;
 
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Str;
 
class DatabaseSeeder extends Seeder
{
    /**
     * Run the database seeders.
     */
    public function run(): void
    {
        DB::table('users')->insert([
            'name' => Str::random(10),
            'email' => Str::random(10).'@example.com',
            'password' => Hash::make('password'),
        ]);
    }
}

Forrás: https://laravel.com/docs/13.x/routing

Route::apiResource('songs', SongController::class);
// Ez létrehozza: GET /api/songs, POST /api/songs, GET /api/songs/{id}, stb.

Route::put('/comments/{comment}', [CommentController::class, 'update']);

Route::get('/user', [UserController::class, 'index']);

• Doksi: ASP.NET Core Web API
• [ApiController]
• [Route("api")]
• öröklés: ControllerBase
• adatbázis: AdatbazisContext
• tipikus végpont: /api/...

• Doksi: EF Core kapcsolt adatok
• [HttpGet("...")]
• Útvonal paraméter: [FromRoute]
• Query paraméter: [FromQuery]
• Kapcsolt tábla: .Include(...)
• Kapcsolt táblához extra: .ThenInclude(...)
• Szűrés: .Where(...)
• Átalakítás: .Select(...)
• Nincs találat: NotFound(...)
• Siker: Ok(...)

• Doksi: EF Core lekérdezések
• [HttpGet(".../{id}")]
• Paraméter: [FromRoute]
• Keresés: .SingleOrDefault(...)
• Nincs találat: NotFound(...)
• Van találat: Ok(...)

• Doksi: ASP.NET Core Web API
• [HttpPost("...")]
• Body: [FromBody]
• JSON → objektum: JsonSerializer.Deserialize<Tipus>(...)
• Hozzáadás: .Add(...)
• Mentés: SaveChanges()
• Siker: StatusCode(201,...)
• Hibás kérés: BadRequest(...)

• Doksi: EF Core mentés
• [HttpPut(".../{id}")]
• Keresés: .SingleOrDefault(...)
• Módosítás: elem.Tulajdonsag = ...
• Frissítés: Update(...)
• Mentés: SaveChanges()
• Siker: Ok(...)

• Doksi: EF Core mentés
• [HttpDelete(".../{id}")]
• Keresés: .SingleOrDefault(...)
• Törlés: .Remove(...)
• Mentés: SaveChanges()
• Válasz: Ok(...) vagy NoContent()

• Doksi: EF Core DbContext
• öröklés: DbContext
• táblák: DbSet<Tipus>
• kapcsolat: OnConfiguring(...)
• adatbázis: UseMySQL(...)

• Doksi: EF Core modeling
• Egyedi index: .HasIndex(...).IsUnique()
• Összetett index: .HasIndex(x => new { ... })
• Kezdő adatok: .HasData(...)

• Doksi: JsonSerializer
• Fájl olvasás: File.ReadAllText(...)
• Lista deszerializálás: Deserialize<List<Tipus>>(...)
• Betöltés seed-be: .HasData(...)

• Doksi: EF Core entity properties
• Táblanév: [Table("...")]
• Kötelező: [Required]
• Max hossz: [StringLength(...)]
• Értéktartomány: [Range(...)]
• Oszloptípus: [Column(TypeName = "...")]
• Kapcsolat: SzerzoId + navigációs property
• Nem adatbázis mező: [NotMapped]

• NextJS végpontok
• Prisma operátorok

request: NextRequest, { params }: { params: Promise<{ id: string }> }

export async function GET() {
    const data = await prisma.table.findMany({});
    // + hibakezelés
}

export async function GET(//dinamikus végpont, urlből szedd ki az id-t) {
    const { id } = await params;
    const data = await prisma.table.findUnique({
      where: { id: Number(id) },
    });
  // + hibakezelés
}

const body = await request.json();
const newOne = await prisma.table.create({
  data: body,
});
// + hibakezelés

export async function PATCH(//url-ből id kinyerése) {
    //konkrétan ugyanaz mint a POST, csak ne createlj, hanem update-t használj, illetve awaiteld az id-t a paraméterből és arra keress a where operátorral
    // + hibakezelés
}

export async function PUT(// url-ből id kinyerése) {
        //ugyanaz mint a PATCH
        // + hibakezelés
  }
}

export async function DELETE(//url-ből id kinyerése) {
    //olyan mint a GET by id, csak itt delete prisma operátor
    return new NextResponse(null, { status: 204 }); // ha nem kér a feladat semmilyen válaszüzenetet, akkor simán null az első paraméter
    // + hibakezelés
}

const resWithNewData = res.map((e, i) => ({
  ...e,
  index: `${i + 1}.`,
}));
// utána ezt return nextrespone-ba, mint mindenhol máshol

if not exist "c:\data\" mkdir "c:\data"
if not exist "c:\data\db" mkdir "c:\data\db"
"c:\Program Files\MongoDB\Server\8.2\bin\mongod.exe" --dbpath="c:\data\db" --replSet "rs0"

if exist "C:\data" (
    rmdir /s /q "C:\data"
)

tar -xf data.zip -C C:\
pause

1. JSON fájlok megírása
2. extract-data
3. startMongoDb.bat
4. mongo.bat
5. npx prisma db pull --force
6. schema szerkesztése
7. npx prisma db push

[
  {
    "_id": 1,
    "unique_something": "alpha",
    "default_something": "default value"
  },
  {
    "_id": 2,
    "unique_something": "beta",
    "default_something": "custom value"
  }
]

[
  {
    "_id": 1,
    "date": {
      "$date": "2026-04-29T00:00:00.000Z"
      // ISO formátumú dátum, a MongoDB ezt így értelmezi majd, és a Prisma is jól fogja kezelni a @db.Date használatával
    },
    "relation_id": 1
  },
  {
    "_id": 2,
    "date": null,
    "relation_id": 2
  }
]

@echo off
chcp 65001
"mongoimport.exe" --uri="mongodb://localhost:27017" --db=dbname --collection=collectionname --drop --file=filename.json --jsonArray
"mongoimport.exe" --uri="mongodb://localhost:27017" --db=dbname --collection=collectionname --drop --file=filename.json --jsonArray
echo PLEASE KILL AND RESTART YOUR BACKEND SERVER DEV TASK IF RUNNING!

DATABASE_URL="mongodb://localhost:27017/dbname"

npx prisma db pull --force

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

model Collection1 {
  id                Int    @id @map("_id")
  unique_something  String @unique
  default_something String @default("default value")

  viewpoints Collection2[]

  @@index([default_something])  //keresésnél gyorsabb adatelérés - nem kötelező
  @@map("collection1name")
}

model Collection2 {
  id          Int       @id @map("_id")
  date        DateTime? @default(now()) @db.Date
  relation_id Int

  location Collection1? @relation(fields: [relation_id], references: [id])

  @@map("collection2name")
}

1:N kapcsolat (egy a többhöz)

Jelentése:
Egy rekordhoz több másik rekord tartozhat,
de a másik oldal egy rekordja csak egyhez kapcsolódhat.

Példa:
1 kategóriához több ingatlan tartozhat,
de 1 ingatlan csak 1 kategóriához tartozik.

────────────────────────────

Prisma szabály:

Az "N" oldalon van:
- a foreign key mező
- a @relation kapcsolat

Példa:
kategoria_id Int

kategora Kategora? @relation(fields: [kategoria_id], references: [id])

────────────────────────────

Az "1" oldalon van:
- a virtuális tömb mező

Példa:
ingatlanok Ingatlan[]

────────────────────────────

Mit jelent a virtuális mező?

Nem valódi adatbázismező.
A Prisma automatikusan kezeli.
Arra szolgál, hogy egyszerűen el lehessen érni
az összetartozó rekordokat.

────────────────────────────

  try {

        kód...

      } catch (error) {
        return NextResponse.json(
          { message: error instanceof Error ? error.message : "Ismeretlen hiba!" },
          { status: 500 },
        );
      }
    

### 6. feladat: A megadott járműtípussal elérhető utak lekérdezése
GET http://localhost:3000/api/journeys/112

### 7. feladat: Új utazási ajánlat hozzáadása
POST http://localhost:3000/api/journeys
content-type: application/json
# Request body tartalma: (A következő üres sort ne törölje ki!)

{
  "id": 12345,
  "vehicle_id": 1,
  "description": "A festői szépségű német főváros…",
  "departure": "2022-08-10T00:00:00.000Z",
  "pictureUrl": "https://pictures.com/berlin.jpg"
}

### 8. feladat: Utazási ajánlat törlése id alapján
DELETE http://localhost:3000/api/journeys/333

request: NextRequest, { params }: { params: Promise<{ id: string }> }

export async function GET()

### 6. feladat: A megadott járműtípussal elérhető utak lekérdezése
GET http://localhost:3000/api/journeys/112

### 7. feladat: Új utazási ajánlat hozzáadása
POST http://localhost:3000/api/journeys
content-type: application/json
# Request body tartalma: (A következő üres sort ne törölje ki!)

{
  "id": 12345,
  "vehicle_id": 1,
  "description": "A festői szépségű német főváros…",
  "departure": "2022-08-10T00:00:00.000Z",
  "pictureUrl": "https://pictures.com/berlin.jpg"
}

### 8. feladat: Utazási ajánlat törlése id alapján
DELETE http://localhost:3000/api/journeys/333

  } catch (error) {
    if (error instanceof Error && error.message.includes("Mintaszöveg")) {
      return NextResponse.json({ message: "Mintaszöveg" }, { status: feladatban meghatározott hibaüzenet pl: 404 });
    }
    

npx prisma db push

// példa 1 - egyszerű lekérés
const example1 = await prisma.exampleModel.findMany()

// példa 2 - where használata
const example2 = await prisma.exampleModel.findMany({
  where: {
    exampleField: "value"
  }
})

// példa 3 - select használata
const example3 = await prisma.exampleModel.findMany({
  select: {
    exampleField: true
  }
})

// példa 4 - create
const example4 = await prisma.exampleModel.create({
  data: {
    exampleField: "value"
  }
})

// példa 5 - update
const example5 = await prisma.exampleModel.update({
  where: {
    id: 1
  },
  data: {
    exampleField: "newValue"
  }
})

// példa 6 - delete
const example6 = await prisma.exampleModel.delete({
  where: {
    id: 1
  }
})

where - itt adsz meg feltételeket pl. id: 1 vagy name: "John"

data - itt adod meg a létrehozandó vagy módosítandó adatokat pl. name: "Anna"

select - megadod, hogy mely mezőket akarod visszakapni pl. { id: true, name: true }

include - kapcsolt (relációs) adatokat kérsz le pl. { posts: true }

omit - megadod, mit NE adjon vissza pl. { password: true }

orderBy - rendezés pl. { createdAt: "desc" }

take - hány rekordot kérsz le (limit) pl. 10

skip - hány rekordot hagyjon ki (offset) pl. 5

distinct - csak egyedi értékeket ad vissza pl. ["email"]

create - új kapcsolt rekord létrehozása relációban

update - kapcsolt rekord frissítése

upsert - ha létezik frissít, ha nem, létrehoz

delete - rekord törlése

deleteMany - több rekord törlése feltétel alapján

updateMany - több rekord frissítése feltétel alapján

createMany - több rekord létrehozása egyszerre

count - megszámolja a rekordokat