go version
go env GOPATH

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Merhaba API! Bu ilk Go API'niz.")
	})

	log.Println("Sunucu 8080 portunda dinleniyor...")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
)

func main() {
	r := chi.NewRouter()

	// Bazı middleware'ler ekleyelim
	r.Use(middleware.Logger) // Her isteği loglar
	r.Use(middleware.Recoverer) // Panik durumlarını yakalar

	// Rotaları tanımlayalım
	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Ana sayfa"))
	})

	r.Get("/urunler", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Tüm ürünler listesi"))
	})

	r.Get("/urunler/{id}", func(w http.ResponseWriter, r *http.Request) {
		productID := chi.URLParam(r, "id")
		fmt.Fprintf(w, "Ürün ID: %s", productID)
	})

	r.Post("/urunler", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Yeni ürün oluşturuldu"))
	})

	log.Println("Sunucu 8080 portunda Chi ile dinleniyor...")
	log.Fatal(http.ListenAndServe(":8080", r))
}

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strconv" // strconv kütüphanesini import edin

	"github.com/go-chi/chi/v5"
)

type Product struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Price float64 `json:"price"`
}

var products = []Product{
	{ID: 1, Name: "Klavye", Price: 150.0},
	{ID: 2, Name: "Fare", Price: 75.0},
}

func main() {
	r := chi.NewRouter()

	r.Get("/urunler", getProducts)
	r.Get("/urunler/{id}", getProductByID)
	r.Post("/urunler", createProduct)

	log.Println("JSON API sunucu 8080 portunda dinleniyor...")
	log.Fatal(http.ListenAndServe(":8080", r))
}

func getProducts(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(products)
}

func getProductByID(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	idStr := chi.URLParam(r, "id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Geçersiz ürün ID'si", http.StatusBadRequest)
		return
	}

	for _, p := range products {
		if p.ID == id {
			json.NewEncoder(w).Encode(p)
			return
		}
	}

	http.Error(w, "Ürün bulunamadı", http.StatusNotFound)
}

func createProduct(w http.ResponseWriter, r *http.Request) {
	var newProduct Product
	err := json.NewDecoder(r.Body).Decode(&newProduct)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// Yeni ID atama (basit bir örnek için)
	if len(products) > 0 {
		newProduct.ID = products[len(products)-1].ID + 1
	} else {
		newProduct.ID = 1
	}
	products = append(products, newProduct)

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(newProduct)
}

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/lib/pq" // PostgreSQL sürücüsü
)

func main() {
	connStr := "user=postgres password=root dbname=yourdb sslmode=disable"
	db, err := sql.Open("postgres", connStr)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close() // Fonksiyon sonunda bağlantıyı kapat

	err = db.Ping() // Bağlantıyı test et
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Veritabanına başarıyla bağlanıldı!")

	// Basit bir sorgu örneği
	var version string
	err = db.QueryRow("SELECT version()").Scan(&version)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("PostgreSQL Sürümü:", version)

	// Tablo oluşturma örneği (bir kez çalıştırın)
	// createTableSQL := `
	// CREATE TABLE IF NOT EXISTS users (
	// id SERIAL PRIMARY KEY,
	// name TEXT NOT NULL,
	// email TEXT UNIQUE NOT NULL
	// );`
	// _, err = db.Exec(createTableSQL)
	// if err != nil {
	// log.Fatal(err)
	// }
	// fmt.Println("Users tablosu oluşturuldu veya zaten mevcut.")

	// Veri ekleme
	// insertSQL := `INSERT INTO users(name, email) VALUES($1, $2) RETURNING id`
	// var userID int
	// err = db.QueryRow(insertSQL, "Alican", "alican@example.com").Scan(&userID)
	// if err != nil {
	// log.Fatal(err)
	// }
	// fmt.Println("Yeni kullanıcı eklendi, ID:", userID)

	// Veri okuma
	rows, err := db.Query("SELECT id, name, email FROM users")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()

	fmt.Println("\nKullanıcılar:")
	for rows.Next() {
		var id int
		var name, email string
		if err := rows.Scan(&id, &name, &email); err != nil {
			log.Fatal(err)
		}
		fmt.Printf("ID: %d, İsim: %s, Email: %s\n", id, name, email)
	}
	if err := rows.Err(); err != nil {
		log.Fatal(err)
	}
}

func respondWithError(w http.ResponseWriter, code int, message string) {
	respondWithJSON(w, code, map[string]string{"error": message})
}

func respondWithJSON(w http.ResponseWriter, code int, payload interface{}) {
	response, err := json.Marshal(payload)
	if err != nil {
		log.Printf("JSON'a dönüştürme hatası: %v", err)
		http.Error(w, "Sunucu iç hatası", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(code)
	w.Write(response)
}

// Kullanım örneği (daha önceki getProductByID fonksiyonundan bir kesit):
// if err != nil {
//     respondWithError(w, http.StatusBadRequest, "Geçersiz ürün ID'si")
//     return
// }
// ...
// respondWithError(w, http.StatusNotFound, "Ürün bulunamadı")

func AuthMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		token := r.Header.Get("Authorization")
		if token == "" || token != "Bearer secret_token" { // Basit bir kontrol
			http.Error(w, "Yetkilendirme gerekli", http.StatusUnauthorized)
			return
		}
		// İsteğe ek bilgi ekleyebilirsiniz (örn. kullanıcı ID'si)
		// ctx := context.WithValue(r.Context(), "userID", 123)
		// next.ServeHTTP(w, r.WithContext(ctx))
		next.ServeHTTP(w, r)
	})
}

// Kullanım örneği:
// r.With(AuthMiddleware).Get("/admin", adminHandler)

package main_test // main paketini test etmek için main_test

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"github.com/go-chi/chi/v5"
	"your_module_path/main" // main paketini import edin
)

// main.go'daki router'ı döndüren bir fonksiyonunuz olduğunu varsayalım
// func setupRouter() *chi.Mux {
//     r := chi.NewRouter()
//     r.Get("/urunler", getProducts)
//     r.Post("/urunler", createProduct)
//     return r
// }

func TestGetProducts(t *testing.T) {
	// router'ı oluşturalım (main.go'daki router kurulumuna benzer)
	// Burası için main.go'daki func main() içindeki router setup'ı kopyalayıp
	// bir fonksiyona taşımak daha iyi olurdu (e.g. `main.SetupRouter()`)
	r := chi.NewRouter()
	r.Get("/urunler", main.GetProducts) // main.GetProducts'ı doğrudan çağırın
	// main.go dosyasında GetProducts fonksiyonunu dışarıdan erişilebilir (büyük harfle başlamalı) yapın

	req, _ := http.NewRequest("GET", "/urunler", nil)
	rr := httptest.NewRecorder()
	r.ServeHTTP(rr, req)

	if status := rr.Code; status != http.StatusOK {
		t.Errorf("Beklenmeyen durum kodu: got %v want %v",
			status, http.StatusOK)
	}

	expected := `[{"id":1,"name":"Klavye","price":150},{"id":2,"name":"Fare","price":75}]`
	// Burada doğrudan string kontrolü yerine JSON ayrıştırma ve karşılaştırma yapmak daha sağlamdır.
	if strings.TrimSpace(rr.Body.String()) != expected { // rr.Body.String()'de boşluklar olabilir
		t.Errorf("Beklenmeyen yanıt gövdesi: got %v want %v",
			rr.Body.String(), expected)
	}
}

func TestCreateProduct(t *testing.T) {
	r := chi.NewRouter()
	r.Post("/urunler", main.CreateProduct) // main.CreateProduct'ı çağırın

	var jsonStr = []byte(`{"name":"Monitör","price":500}`)
	req, _ := http.NewRequest("POST", "/urunler", strings.NewReader(string(jsonStr)))
	req.Header.Set("Content-Type", "application/json")

	rr := httptest.NewRecorder()
	r.ServeHTTP(rr, req)

	if status := rr.Code; status != http.StatusCreated {
		t.Errorf("Beklenmeyen durum kodu: got %v want %v",
			status, http.StatusCreated)
	}

	var product main.Product // main.Product struct'ına erişmek için
	err := json.Unmarshal(rr.Body.Bytes(), &product)
	if err != nil {
		t.Fatalf("Yanıt gövdesi JSON ayrıştırılamadı: %v", err)
	}

	if product.Name != "Monitör" || product.Price != 500 {
		t.Errorf("Ürün verileri eşleşmiyor: got %+v want Name: Monitör, Price: 500", product)
	}
	if product.ID == 0 { // ID'nin otomatik atanıp atanmadığını kontrol et
		t.Errorf("Yeni ürüne ID atanmadı")
	}
}

// Bu alan sadece örnek [code] etiketi kullanımı içindir.
// Gerçekte buraya ek kodlar veya ilgili bilgiler gelebilir.
// [b]Önemli Not:[/b] Kod blokları içindeki yorumlar da sayfa uzunluğuna katkıda bulunur.