Ana içeriğe atla

​
Temel Kullanım Örnekleri

Bu sayfa Ziva ile TUI uygulamaları oluşturmanın pratik örneklerini içerir. Tüm örnekler çalıştırılmaya hazırdır ve kütüphanenin ana özelliklerini gösterir.

​
Örnek 1: Basit Onay

Onay görevi ile temel örnek: 
package main

import (
    "fmt"
    "log"
    "github.com/qzeleza/ziva"
)

func main() {
    // Onay görevi oluştur
    confirm := ziva.NewYesNoTask(
        "Eylem Onayı",
        "Tüm geçici dosyalar silinsin mi?",
    )

    // Kuyruk oluştur ve görev ekle
    queue := ziva.NewQueue("Sistem Temizliği")
    queue.AddTasks(confirm)

    // Çalıştır
    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }

    // Sonucu işle
    if confirm.IsYes() {
        fmt.Println("🗑️  Geçici dosyalar silindi")
    } else {
        fmt.Println("❌ İşlem iptal edildi")
    }
}

​
Örnek 2: Listeden Seçim

Listeden tek seçenek seçme örneği: 
package main

import (
    "fmt"
    "log"
    "github.com/qzeleza/ziva"
)

func main() {
    // Açıklamalı seçenekler
    environments := []string{
        "dev||Geliştirme ortamı - yerel makine",
        "staging||Test ortamı - QA için",
        "production||Canlı ortam - kullanıcılar",
    }

    // Seçim görevi oluştur
    envTask := ziva.NewSingleSelectTask(
        "Dağıtım Ortamı Seçimi",
        environments,
    ).WithDefaultItem("staging")

    // Kuyruğu yapılandır ve çalıştır
    queue := ziva.NewQueue("Uygulama Dağıtımı")
    queue.WithAppName("DeployTool")
    queue.AddTasks(envTask)

    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }

    // Sonucu al
    selected := envTask.GetSelected()
    fmt.Printf("🚀 Dağıtım ortamı: %s\n", selected)
}

​
Örnek 3: Çoklu Seçim

Birden fazla bileşen seçme örneği: 
package main

import (
    "fmt"
    "log"
    "strings"
    "github.com/qzeleza/ziva"
)

func main() {
    // Kurulacak bileşenler
    components := []string{
        "web||Web sunucusu",
        "api||REST API",
        "db||Veritabanı",
        "cache||Önbellek",
        "monitoring||İzleme",
        "backup||Yedekleme",
    }

    // Çoklu seçim görevi oluştur
    compTask := ziva.NewMultiSelectTask(
        "Kurulacak bileşenleri seçin",
        components,
    ).WithSelectAll("Tümünü kur").
      WithDefaultItems([]string{"web", "api"})

    queue := ziva.NewQueue("Sistem Kurulumu")
    queue.AddTasks(compTask)

    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }

    // Seçilen bileşenleri göster
    selected := compTask.GetSelected()
    if len(selected) > 0 {
        fmt.Printf("📦 Kurulacaklar: %s\n",
            strings.Join(selected, ", "))
    } else {
        fmt.Println("❌ Hiçbir bileşen seçilmedi")
    }
}

​
Örnek 4: Doğrulama ile Giriş

Doğrulama ile kullanıcı verisi toplama örneği: 
package main

import (
    "fmt"
    "log"
    "github.com/qzeleza/ziva"
)

func main() {
    v := ziva.DefaultValidators

    // Doğrulama ile giriş alanları oluştur
    name := ziva.NewInputTask("İsim", "Adınızı girin:").
        WithValidator(v.Required())

    email := ziva.NewInputTask("Email", "Email adresinizi girin:").
        WithInputType(ziva.InputTypeEmail).
        WithValidator(v.Email())

    website := ziva.NewInputTask("Site", "Website URL (opsiyonel):").
        WithValidator(v.OptionalURL())

    // Kuyruk oluştur
    queue := ziva.NewQueue("Kullanıcı Kaydı")
    queue.WithAppName("UserReg")
    queue.AddTasks(name, email, website)

    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }

    // Toplanan bilgileri göster
    fmt.Println("\n✅ Kayıt tamamlandı:")
    fmt.Printf("İsim: %s\n", name.GetValue())
    fmt.Printf("Email: %s\n", email.GetValue())
    if website.GetValue() != "" {
        fmt.Printf("Website: %s\n", website.GetValue())
    }
}

​
Örnek 5: Fonksiyonel Görev

Uzun süren işlem yürütme örneği: 
package main

import (
    "log"
    "math/rand"
    "time"
    "github.com/qzeleza/ziva"
)

func main() {
    // Rapor verileri
    var stats struct {
        FilesProcessed int
        Errors         int
        Duration       time.Duration
    }

    // Fonksiyonel görev oluştur
    processTask := ziva.NewFuncTask(
        "Dosya İşleme",
        func() error {
            start := time.Now()

            // Dosya işleme simülasyonu
            for i := 0; i < 100; i++ {
                time.Sleep(50 * time.Millisecond)
                stats.FilesProcessed++

                // Rastgele hatalar
                if rand.Intn(20) == 0 {
                    stats.Errors++
                }
            }

            stats.Duration = time.Since(start)
            return nil
        },
        // Sonuç özeti fonksiyonu
        ziva.WithSummaryFunction(func() []string {
            return []string{
                fmt.Sprintf("İşlenen dosya: %d", stats.FilesProcessed),
                fmt.Sprintf("Hata: %d", stats.Errors),
                fmt.Sprintf("Süre: %v", stats.Duration.Round(time.Millisecond)),
            }
        }),
    )

    queue := ziva.NewQueue("Toplu İşlem")
    queue.AddTasks(processTask)

    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }
}

​
Örnek 6: Kapsamlı Uygulama

Web sunucusu yapılandırması için tam örnek: 
package main

import (
    "fmt"
    "log"
    "strconv"
    "time"
    "github.com/qzeleza/ziva"
)

type ServerConfig struct {
    Host    string
    Port    int
    SSL     bool
    CertPath string
    Modules  []string
}

func main() {
    config := &ServerConfig{}

    // Yapılandırma görevlerini oluştur
    tasks := createConfigTasks(config)

    // Kuyruğu yapılandır
    queue := ziva.NewQueue("Web Sunucusu Yapılandırması")
    queue.WithAppName("WebServerSetup").
          WithTasksNumbered(true, "[%02d]").
          WithTitleColor(ziva.BlueBright, true)

    queue.AddTasks(tasks...)

    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }

    // Son yapılandırmayı göster
    printConfig(config)
}

func createConfigTasks(config *ServerConfig) []ziva.Task {
    v := ziva.DefaultValidators

    // 1. Host
    hostTask := ziva.NewInputTask("Sunucu Host", "IP adresi veya domain:").
        WithValidator(v.Required()).
        WithTimeout(30*time.Second, "localhost")

    // 2. Port
    portTask := ziva.NewInputTask("Port", "Sunucu portu (1-65535):").
        WithInputType(ziva.InputTypeNumber).
        WithValidator(v.Port()).
        WithTimeout(15*time.Second, "8080")

    // 3. SSL
    sslTask := ziva.NewYesNoTask("SSL", "HTTPS etkinleştirilsin mi?").
        WithDefaultItem("Evet")

    // 4. Modüller
    modules := []string{
        "auth||Kullanıcı kimlik doğrulama",
        "cors||Cross-Origin Resource Sharing",
        "compress||Yanıt sıkıştırma",
        "static||Statik dosyalar",
        "proxy||Ters proxy",
        "cache||Önbellek",
    }

    moduleTask := ziva.NewMultiSelectTask("Modüller", modules).
        WithSelectAll("Tüm modülleri etkinleştir").
        WithDefaultItems([]string{"auth", "static"})

    // 5. Yapılandırma uygulama fonksiyonel görevi
    applyTask := ziva.NewFuncTask(
        "Yapılandırma Uygulama",
        func() error {
            // Yapılandırmayı topla
            config.Host = hostTask.GetValue()
            if port, err := strconv.Atoi(portTask.GetValue()); err == nil {
                config.Port = port
            }
            config.SSL = sslTask.IsYes()
            config.Modules = moduleTask.GetSelected()

            // Ayar uygulama simülasyonu
            time.Sleep(2 * time.Second)
            return nil
        },
        ziva.WithSummaryFunction(func() []string {
            return []string{
                "Yapılandırma uygulandı",
                "Sunucu başlatılmaya hazır",
            }
        }),
    )

    return []ziva.Task{hostTask, portTask, sslTask, moduleTask, applyTask}
}

func printConfig(config *ServerConfig) {
    fmt.Println("\n🔧 Sunucu Yapılandırması:")
    fmt.Printf("Adres: %s:%d\n", config.Host, config.Port)
    fmt.Printf("SSL: %v\n", config.SSL)
    fmt.Printf("Modüller: %v\n", config.Modules)

    // Bağlantı URL'si
    protocol := "http"
    if config.SSL {
        protocol = "https"
    }
    fmt.Printf("\n🌐 URL: %s://%s:%d\n", protocol, config.Host, config.Port)
}

​
Kullanım İpuçları

​
1. Görev Gruplandırma

İlgili görevleri mantıksal olarak gruplandırın: 
// Kimlik doğrulama grubu
authTasks := []ziva.Task{
    ziva.NewInputTask("Username", "Kullanıcı adı:"),
    ziva.NewInputTask("Password", "Şifre:").WithInputType(ziva.InputTypePassword),
}

// Ayarlar grubu
configTasks := []ziva.Task{
    ziva.NewSingleSelectTask("Theme", themes),
    ziva.NewYesNoTask("Notifications", "Bildirimler etkinleştirilsin mi?"),
}

queue.AddTasks(authTasks...)
queue.AddTasks(configTasks...)

​
2. İptal İşleme

queue := ziva.NewQueue("Kurulum")
if err := queue.Run(); err != nil {
    if err == context.Canceled {
        fmt.Println("❌ Kurulum kullanıcı tarafından iptal edildi")
        return
    }
    log.Fatal(err)
}

​
3. Yapılandırma Kaydetme

// Başarılı yürütmeden sonra
config := collectResults(tasks...)
if err := saveConfig(config); err != nil {
    log.Printf("Kayıt hatası: %v", err)
}

​
Ayrıca Bakınız

⌘I