@Entity
@Table(name = "products")
public class Product {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(length = 1000)
    private String description;
    
    @Column(nullable = false)
    private BigDecimal price;
    
    private Integer stock;
    
    private String imageUrl;
    
    @ManyToOne
    @JoinColumn(name = "category_id")
    private Category category;
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    private LocalDateTime updatedAt;
    
    // Getters and setters
}

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    
    List<Product> findByCategoryId(Long categoryId);
    
    @Query("SELECT p FROM Product p WHERE p.name LIKE %:keyword% OR p.description LIKE %:keyword%")
    List<Product> search(@Param("keyword") String keyword);
    
    @Query("SELECT p FROM Product p WHERE p.price BETWEEN :minPrice AND :maxPrice")
    List<Product> findByPriceRange(@Param("minPrice") BigDecimal minPrice, @Param("maxPrice") BigDecimal maxPrice);
}

@Service
public class ProductService {
    
    private final ProductRepository productRepository;
    private final CategoryRepository categoryRepository;
    
    public ProductService(ProductRepository productRepository, CategoryRepository categoryRepository) {
        this.productRepository = productRepository;
        this.categoryRepository = categoryRepository;
    }
    
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
    
    public Product getProductById(Long id) {
        return productRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("Product not found with id: " + id));
    }
    
    public List<Product> getProductsByCategory(Long categoryId) {
        return productRepository.findByCategoryId(categoryId);
    }
    
    public List<Product> searchProducts(String keyword) {
        return productRepository.search(keyword);
    }
    
    public Product createProduct(Product product) {
        return productRepository.save(product);
    }
    
    public Product updateProduct(Long id, Product productDetails) {
        Product product = getProductById(id);
        product.setName(productDetails.getName());
        product.setDescription(productDetails.getDescription());
        product.setPrice(productDetails.getPrice());
        product.setStock(productDetails.getStock());
        product.setImageUrl(productDetails.getImageUrl());
        product.setCategory(productDetails.getCategory());
        return productRepository.save(product);
    }
    
    public void deleteProduct(Long id) {
        Product product = getProductById(id);
        productRepository.delete(product);
    }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    private final ProductService productService;
    
    public ProductController(ProductService productService) {
        this.productService = productService;
    }
    
    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productService.getProductById(id);
    }
    
    @GetMapping("/category/{categoryId}")
    public List<Product> getProductsByCategory(@PathVariable Long categoryId) {
        return productService.getProductsByCategory(categoryId);
    }
    
    @GetMapping("/search")
    public List<Product> searchProducts(@RequestParam String keyword) {
        return productService.searchProducts(keyword);
    }
    
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Product createProduct(@Valid @RequestBody Product product) {
        return productService.createProduct(product);
    }
    
    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @Valid @RequestBody Product product) {
        return productService.updateProduct(id, product);
    }
    
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
    }
}

export interface Product {
  id: number;
  name: string;
  description: string;
  price: number;
  stock: number;
  imageUrl: string;
  categoryId: number;
  createdAt: string;
  updatedAt: string;
}

import { Injectable } from '@angular/core';
import { HttpClient, HttpParams } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../environments/environment';
import { Product } from '../models/product.model';

@Injectable({
  providedIn: 'root'
})
export class ProductService {
  private apiUrl = `${environment.apiUrl}/products`;
  
  constructor(private http: HttpClient) { }
  
  getProducts(): Observable<Product[]> {
    return this.http.get<Product[]>(this.apiUrl);
  }
  
  getProductById(id: number): Observable<Product> {
    return this.http.get<Product>(`${this.apiUrl}/${id}`);
  }
  
  getProductsByCategory(categoryId: number): Observable<Product[]> {
    return this.http.get<Product[]>(`${this.apiUrl}/category/${categoryId}`);
  }
  
  searchProducts(keyword: string): Observable<Product[]> {
    let params = new HttpParams().set('keyword', keyword);
    return this.http.get<Product[]>(`${this.apiUrl}/search`, { params });
  }
  
  createProduct(product: Product): Observable<Product> {
    return this.http.post<Product>(this.apiUrl, product);
  }
  
  updateProduct(id: number, product: Product): Observable<Product> {
    return this.http.put<Product>(`${this.apiUrl}/${id}`, product);
  }
  
  deleteProduct(id: number): Observable<void> {
    return this.http.delete<void>(`${this.apiUrl}/${id}`);
  }
}

import { Component, OnInit } from '@angular/core';
import { ProductService } from '../../core/services/product.service';
import { Product } from '../../core/models/product.model';

@Component({
  selector: 'app-product-list',
  templateUrl: './product-list.component.html',
  styleUrls: ['./product-list.component.scss']
})
export class ProductListComponent implements OnInit {
  products: Product[] = [];
  loading = false;
  error: string | null = null;
  
  constructor(private productService: ProductService) { }
  
  ngOnInit(): void {
    this.loadProducts();
  }
  
  loadProducts(): void {
    this.loading = true;
    this.error = null;
    
    this.productService.getProducts().subscribe(
      products => {
        this.products = products;
        this.loading = false;
      },
      error => {
        this.error = 'Ürünler yüklenirken bir hata oluştu.';
        this.loading = false;
        console.error('Ürünler yüklenirken hata:', error);
      }
    );
  }
  
  deleteProduct(id: number): void {
    if (confirm('Bu ürünü silmek istediğinizden emin misiniz?')) {
      this.productService.deleteProduct(id).subscribe(
        () => {
          this.products = this.products.filter(product => product.id !== id);
        },
        error => {
          console.error('Ürün silinirken hata:', error);
        }
      );
    }
  }
}

<div class="product-list-container">
  <h1>Ürünler</h1>
  
  <div *ngIf="loading" class="loading-container">
    <mat-spinner></mat-spinner>
  </div>
  
  <div *ngIf="error" class="error-container">
    <p>{{ error }}</p>
  </div>
  
  <div *ngIf="!loading && !error" class="product-grid">
    <mat-card *ngFor="let product of products" class="product-card">
      <img mat-card-image [src]="product.imageUrl || 'assets/images/placeholder.jpg'" [alt]="product.name">
      <mat-card-content>
        <h2>{{ product.name }}</h2>
        <p>{{ product.description }}</p>
        <p class="price">{{ product.price | currency:'TRY':'symbol':'1.2-2' }}</p>
      </mat-card-content>
      <mat-card-actions>
        <button mat-button color="primary" [routerLink]="['/products', product.id]">DETAYLAR</button>
        <button mat-button color="accent" (click)="addToCart(product)">SEPETE EKLE</button>
      </mat-card-actions>
    </mat-card>
  </div>
</div>

.product-list-container {
  padding: 20px;
  
  h1 {
    margin-bottom: 20px;
    font-size: 24px;
    font-weight: 500;
  }
  
  .loading-container {
    display: flex;
    justify-content: center;
    align-items: center;
    height: 200px;
  }
  
  .error-container {
    color: #f44336;
    margin: 20px 0;
  }
  
  .product-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
    gap: 20px;
  }
  
  .product-card {
    height: 100%;
    display: flex;
    flex-direction: column;
    
    img {
      height: 200px;
      object-fit: cover;
    }
    
    mat-card-content {
      flex-grow: 1;
      
      h2 {
        font-size: 18px;
        font-weight: 500;
        margin-bottom: 8px;
      }
      
      p {
        color: rgba(0, 0, 0, 0.6);
        margin-bottom: 8px;
      }
      
      .price {
        font-size: 20px;
        font-weight: 700;
        color: #3f51b5;
      }
    }
    
    mat-card-actions {
      display: flex;
      justify-content: space-between;
    }
  }
  
  @media (max-width: 768px) {
    .product-grid {
      grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
    }
  }
  
  @media (max-width: 576px) {
    .product-grid {
      grid-template-columns: 1fr;
    }
  }
}

---
title: 'Başlık'
description: 'Açıklama'
---

# Ana Başlık

## Alt Başlık

Normal metin içeriği.

### Kod Örnekleri

```java
// Java kodu

// TypeScript kodu

### Stil Kılavuzu

Dokümantasyonun tutarlı bir stile sahip olması için aşağıdaki kurallara uyulmalıdır:

1. **Başlıklar**: Ana başlıklar için `#`, alt başlıklar için `##`, `###` vb. kullanın.
2. **Kod Blokları**: Kod blokları için üç backtick (```) ve dil adını kullanın.
3. **Vurgulama**: Önemli noktaları vurgulamak için **kalın** veya *italik* metin kullanın.
4. **Listeler**: Sıralı veya sırasız listeler için uygun Markdown sözdizimini kullanın.
5. **Bağlantılar**: Bağlantılar için `[metin](URL)` formatını kullanın.
6. **Görüntüler**: Görüntüler için `![alt metin](görüntü URL'si)` formatını kullanın.

## Dokümantasyon Dosya Yapısı

Dokümantasyon dosyaları, aşağıdaki yapıda organize edilmiştir:

## Dokümantasyon Tamamlama Kontrol Listesi

Dokümantasyonun tamamlanması için aşağıdaki kontrol listesi kullanılabilir:

1. **İçerik Kontrolü**:
   - [ ] Tüm bölümler eksiksiz bir şekilde yazılmış mı?
   - [ ] Bölümler arasında tutarlılık var mı?
   - [ ] Tüm gerekli konular ele alınmış mı?

2. **Kod Örnekleri Kontrolü**:
   - [ ] Tüm kod örnekleri doğru ve güncel mi?
   - [ ] Kod örnekleri açıklamalarla desteklenmiş mi?
   - [ ] Kod örnekleri uygun şekilde biçimlendirilmiş mi?

3. **Dil ve Dilbilgisi Kontrolü**:
   - [ ] Dokümantasyon Türkçe dilbilgisi kurallarına uygun mu?
   - [ ] Teknik terimler doğru ve tutarlı bir şekilde kullanılmış mı?
   - [ ] Yazım hataları ve imla hataları kontrol edilmiş mi?

4. **Format ve Stil Kontrolü**:
   - [ ] Başlıklar, listeler ve diğer Markdown öğeleri doğru şekilde kullanılmış mı?
   - [ ] Dokümantasyon tutarlı bir stile sahip mi?
   - [ ] Görüntüler ve bağlantılar doğru şekilde eklenmiş mi?

5. **Navigasyon Kontrolü**:
   - [ ] Bölümler arasında gezinme kolay mı?
   - [ ] İçindekiler tablosu güncel ve doğru mu?
   - [ ] Bağlantılar doğru şekilde çalışıyor mu?

## Dokümantasyon Tamamlama Süreci

Dokümantasyonun tamamlanması için aşağıdaki adımlar izlenmelidir:

1. **İçerik Gözden Geçirme**: Tüm bölümleri gözden geçirin ve eksik veya hatalı içerikleri düzeltin.
2. **Kod Örnekleri Kontrolü**: Tüm kod örneklerini kontrol edin ve gerekirse güncelleyin.
3. **Dil ve Dilbilgisi Kontrolü**: Dokümantasyonu dil ve dilbilgisi açısından kontrol edin.
4. **Format ve Stil Kontrolü**: Dokümantasyonun formatını ve stilini kontrol edin.
5. **Navigasyon Kontrolü**: Dokümantasyonun navigasyonunu kontrol edin.
6. **Son Kontrol**: Dokümantasyonu bir bütün olarak son kez gözden geçirin.

## Sonuç

Bu bölümde, e-ticaret uygulaması için hazırladığımız kapsamlı dokümantasyonun tamamlanması ve son kontrollerin yapılması sürecini ele aldık. Dokümantasyonun yapısı, içindekiler tablosu, kod örneklerinin kontrolü, dokümantasyon formatı ve stili, dosya yapısı, tamamlama kontrol listesi ve tamamlama süreci konularını inceledik.

Dokümantasyonun tutarlı, eksiksiz ve kullanışlı olması, projenin başarılı bir şekilde uygulanması için kritik öneme sahiptir. Bu nedenle, dokümantasyonun tamamlanması ve son kontrollerin yapılması, projenin önemli bir aşamasıdır.

Bu dokümantasyon, e-ticaret uygulamanızın geliştirilmesi, entegrasyonu ve deployment edilmesi için kapsamlı bir rehber olarak hizmet edecektir. Dokümantasyonu takip ederek, modern ve ölçeklenebilir bir e-ticaret uygulaması oluşturabilirsiniz.