Перейти к основному содержанию

​
Базовые примеры использования

Эта страница содержит практические примеры создания TUI приложений с помощью Ziva. Все примеры готовы к запуску и демонстрируют основные возможности библиотеки.

​
Пример 1: Простое подтверждение

Базовый пример с задачей подтверждения: 
package main

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

func main() {
    // Создаем задачу подтверждения
    confirm := ziva.NewYesNoTask(
        "Подтверждение действия",
        "Удалить все временные файлы?",
    )

    // Создаем очередь и добавляем задачу
    queue := ziva.NewQueue("Очистка системы")
    queue.AddTasks(confirm)

    // Запускаем
    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }

    // Обрабатываем результат
    if confirm.IsYes() {
        fmt.Println("🗑️  Временные файлы удалены")
    } else {
        fmt.Println("❌ Операция отменена")
    }
}

​
Пример 2: Выбор из списка

Пример с выбором одного варианта из списка: 
package main

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

func main() {
    // Опции с описаниями
    environments := []string{
        "dev||Среда разработки - локальная машина",
        "staging||Тестовая среда - для QA",
        "production||Боевая среда - пользователи",
    }

    // Создаем задачу выбора
    envTask := ziva.NewSingleSelectTask(
        "Выбор среды развертывания",
        environments,
    ).WithDefaultItem("staging")

    // Настраиваем и запускаем очередь
    queue := ziva.NewQueue("Развертывание приложения")
    queue.WithAppName("DeployTool")
    queue.AddTasks(envTask)

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

    // Получаем результат
    selected := envTask.GetSelected()
    fmt.Printf("🚀 Развертывание в среду: %s\n", selected)
}

​
Пример 3: Множественный выбор

Пример с выбором нескольких компонентов: 
package main

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

func main() {
    // Компоненты для установки
    components := []string{
        "web||Веб-сервер",
        "api||REST API",
        "db||База данных",
        "cache||Кеширование",
        "monitoring||Мониторинг",
        "backup||Резервное копирование",
    }

    // Создаем задачу множественного выбора
    compTask := ziva.NewMultiSelectTask(
        "Выберите компоненты для установки",
        components,
    ).WithSelectAll("Установить все").
      WithDefaultItems([]string{"web", "api"})

    queue := ziva.NewQueue("Установка системы")
    queue.AddTasks(compTask)

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

    // Показываем выбранные компоненты
    selected := compTask.GetSelected()
    if len(selected) > 0 {
        fmt.Printf("📦 Будут установлены: %s\n",
            strings.Join(selected, ", "))
    } else {
        fmt.Println("❌ Не выбрано ни одного компонента")
    }
}

​
Пример 4: Ввод с валидацией

Пример сбора пользовательских данных с валидацией: 
package main

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

func main() {
    v := ziva.DefaultValidators

    // Создаем поля ввода с валидацией
    name := ziva.NewInputTask("Имя", "Введите ваше имя:").
        WithValidator(v.Required())

    email := ziva.NewInputTask("Email", "Введите email:").
        WithInputType(ziva.InputTypeEmail).
        WithValidator(v.Email())

    website := ziva.NewInputTask("Сайт", "URL сайта (опционально):").
        WithValidator(v.OptionalURL())

    // Создаем очередь
    queue := ziva.NewQueue("Регистрация пользователя")
    queue.WithAppName("UserReg")
    queue.AddTasks(name, email, website)

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

    // Выводим собранную информацию
    fmt.Println("\n✅ Регистрация завершена:")
    fmt.Printf("Имя: %s\n", name.GetValue())
    fmt.Printf("Email: %s\n", email.GetValue())
    if website.GetValue() != "" {
        fmt.Printf("Сайт: %s\n", website.GetValue())
    }
}

​
Пример 5: Функциональная задача

Пример выполнения длительной операции: 
package main

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

func main() {
    // Данные для отчета
    var stats struct {
        FilesProcessed int
        Errors         int
        Duration       time.Duration
    }

    // Создаем функциональную задачу
    processTask := ziva.NewFuncTask(
        "Обработка файлов",
        func() error {
            start := time.Now()

            // Имитация обработки файлов
            for i := 0; i < 100; i++ {
                time.Sleep(50 * time.Millisecond)
                stats.FilesProcessed++

                // Случайные ошибки
                if rand.Intn(20) == 0 {
                    stats.Errors++
                }
            }

            stats.Duration = time.Since(start)
            return nil
        },
        // Функция сводки результатов
        ziva.WithSummaryFunction(func() []string {
            return []string{
                fmt.Sprintf("Обработано файлов: %d", stats.FilesProcessed),
                fmt.Sprintf("Ошибок: %d", stats.Errors),
                fmt.Sprintf("Время выполнения: %v", stats.Duration.Round(time.Millisecond)),
            }
        }),
    )

    queue := ziva.NewQueue("Пакетная обработка")
    queue.AddTasks(processTask)

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

​
Пример 6: Комплексное приложение

Полный пример настройки веб-сервера: 
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{}

    // Создаем задачи конфигурации
    tasks := createConfigTasks(config)

    // Настраиваем очередь
    queue := ziva.NewQueue("Настройка веб-сервера")
    queue.WithAppName("WebServerSetup").
          WithTasksNumbered(true, "[%02d]").
          WithTitleColor(ziva.BlueBright, true)

    queue.AddTasks(tasks...)

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

    // Показываем итоговую конфигурацию
    printConfig(config)
}

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

    // 1. Хост
    hostTask := ziva.NewInputTask("Хост сервера", "IP адрес или домен:").
        WithValidator(v.Required()).
        WithTimeout(30*time.Second, "localhost")

    // 2. Порт
    portTask := ziva.NewInputTask("Порт", "Порт сервера (1-65535):").
        WithInputType(ziva.InputTypeNumber).
        WithValidator(v.Port()).
        WithTimeout(15*time.Second, "8080")

    // 3. SSL
    sslTask := ziva.NewYesNoTask("SSL", "Включить HTTPS?").
        WithDefaultItem("Да")

    // 4. Модули
    modules := []string{
        "auth||Аутентификация пользователей",
        "cors||Cross-Origin Resource Sharing",
        "compress||Сжатие ответов",
        "static||Статические файлы",
        "proxy||Обратный прокси",
        "cache||Кеширование",
    }

    moduleTask := ziva.NewMultiSelectTask("Модули", modules).
        WithSelectAll("Включить все модули").
        WithDefaultItems([]string{"auth", "static"})

    // 5. Функциональная задача применения конфигурации
    applyTask := ziva.NewFuncTask(
        "Применение конфигурации",
        func() error {
            // Собираем конфигурацию
            config.Host = hostTask.GetValue()
            if port, err := strconv.Atoi(portTask.GetValue()); err == nil {
                config.Port = port
            }
            config.SSL = sslTask.IsYes()
            config.Modules = moduleTask.GetSelected()

            // Имитация применения настроек
            time.Sleep(2 * time.Second)
            return nil
        },
        ziva.WithSummaryFunction(func() []string {
            return []string{
                "Конфигурация применена",
                "Сервер готов к запуску",
            }
        }),
    )

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

func printConfig(config *ServerConfig) {
    fmt.Println("\n🔧 Конфигурация сервера:")
    fmt.Printf("Адрес: %s:%d\n", config.Host, config.Port)
    fmt.Printf("SSL: %v\n", config.SSL)
    fmt.Printf("Модули: %v\n", config.Modules)

    // URL для подключения
    protocol := "http"
    if config.SSL {
        protocol = "https"
    }
    fmt.Printf("\n🌐 URL: %s://%s:%d\n", protocol, config.Host, config.Port)
}

​
Советы по использованию

​
1. Группировка задач

Логически группируйте связанные задачи: 
// Группа аутентификации
authTasks := []ziva.Task{
    ziva.NewInputTask("Username", "Логин:"),
    ziva.NewInputTask("Password", "Пароль:").WithInputType(ziva.InputTypePassword),
}

// Группа настроек
configTasks := []ziva.Task{
    ziva.NewSingleSelectTask("Theme", themes),
    ziva.NewYesNoTask("Notifications", "Включить уведомления?"),
}

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

​
2. Обработка отмены

queue := ziva.NewQueue("Setup")
if err := queue.Run(); err != nil {
    if err == context.Canceled {
        fmt.Println("❌ Настройка отменена пользователем")
        return
    }
    log.Fatal(err)
}

​
3. Сохранение конфигурации

// После успешного выполнения
config := collectResults(tasks...)
if err := saveConfig(config); err != nil {
    log.Printf("Ошибка сохранения: %v", err)
}

​
См. также

⌘I