add lesson4

Author: talgat-yandex

lesson4/example1/.env.example

@@ -0,0 +1,2 @@
+PORT=
+AI_API_KEY=

lesson4/example1/.gitignore

@@ -0,0 +1 @@
+.env

lesson4/example1/configs/conf.go

@@ -0,0 +1,27 @@
+package configs
+
+import (
+	"context"
+	"flag"
+)
+
+type Config struct {
+	Api *ApiConfig
+}
+
+func NewConfig(ctx context.Context) (*Config, error) {
+	conf := &Config{}
+
+	_ = conf.loadDotEnvFiles()
+
+	// Api config
+	if c, err := newApiConfig(ctx); err != nil {
+		return nil, err
+	} else {
+		conf.Api = c
+	}
+
+	flag.Parse()
+
+	return conf, nil
+}

lesson4/example1/configs/env.go

@@ -0,0 +1,9 @@
+package configs
+
+import (
+	"github.com/joho/godotenv"
+)
+
+func (c *Config) loadDotEnvFiles() error {
+	return godotenv.Load(".env", ".env.local")
+}

lesson4/example1/configs/service_api.go

@@ -0,0 +1,26 @@
+package configs
+
+import (
+	"context"
+	"flag"
+
+	"github.com/sethvargo/go-envconfig"
+)
+
+type ApiConfig struct {
+	Port     int    `env:"PORT"`
+	AIApiKey string `env:"AI_API_KEY"`
+}
+
+func newApiConfig(ctx context.Context) (*ApiConfig, error) {
+	c := &ApiConfig{}
+
+	if err := envconfig.Process(ctx, c); err != nil {
+		return nil, err
+	}
+
+	flag.IntVar(&c.Port, "port", c.Port, "server port [PORT]")
+	flag.StringVar(&c.AIApiKey, "token-key", c.AIApiKey, "Open AI API key [AI_API_KEY]")
+
+	return c, nil
+}

lesson4/example1/go.mod

@@ -0,0 +1,8 @@
+module github.com/talgat-ruby/lessons-go/lesson4/example1
+
+go 1.22.5
+
+require (
+	github.com/joho/godotenv v1.5.1
+	github.com/sethvargo/go-envconfig v1.1.0
+)

lesson4/example1/go.sum

@@ -0,0 +1,6 @@
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/sethvargo/go-envconfig v1.1.0 h1:cWZiJxeTm7AlCvzGXrEXaSTCNgip5oJepekh/BOQuog=
+github.com/sethvargo/go-envconfig v1.1.0/go.mod h1:JLd0KFWQYzyENqnEPWWZ49i4vzZo/6nRidxI8YvGiHw=

lesson4/example1/internal/api/handler/ai/main.go

@@ -0,0 +1,9 @@
+package ai
+
+type Handler struct {
+	apiKey string
+}
+
+func New(apiKey string) *Handler {
+	return &Handler{apiKey: apiKey}
+}

lesson4/example1/internal/api/handler/ai/prompt.go

@@ -0,0 +1,55 @@
+package ai
+
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+
+	"github.com/talgat-ruby/lessons-go/lesson4/example1/internal/gemini"
+	"github.com/talgat-ruby/lessons-go/lesson4/example1/pkg/response"
+)
+
+type promptReqBody struct {
+	Prompt string `json:"prompt"`
+}
+
+func (h *Handler) Prompt(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	slog.InfoContext(ctx, "aiHandler::Prompt::start")
+
+	var b promptReqBody
+	err := json.NewDecoder(r.Body).Decode(&b)
+	if err != nil {
+		slog.ErrorContext(
+			ctx,
+			"aiHandler::Prompt::fail",
+			"error", err,
+		)
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	g := gemini.NewGemini(h.apiKey)
+	text, err := g.SendPrompt(b.Prompt)
+	if err != nil {
+		slog.ErrorContext(
+			ctx,
+			"aiHandler::Prompt::fail",
+			"error", err,
+		)
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	data := &promptResponseBody{
+		Message: text,
+	}
+	if err := response.JSON(w, data); err != nil {
+		slog.ErrorContext(
+			ctx,
+			"aiHandler::Prompt::fail",
+			"error", err,
+		)
+		return
+	}
+}

lesson4/example1/internal/api/handler/ai/response.go

@@ -0,0 +1,5 @@
+package ai
+
+type promptResponseBody struct {
+	Message string `json:"message"`
+}

lesson4/example1/internal/api/handler/ping/main.go

@@ -0,0 +1,7 @@
+package pingHandler
+
+type Handler struct{}
+
+func New() *Handler {
+	return &Handler{}
+}

lesson4/example1/internal/api/handler/ping/ping.go

@@ -0,0 +1,25 @@
+package pingHandler
+
+import (
+	"log/slog"
+	"net/http"
+
+	"github.com/talgat-ruby/lessons-go/lesson4/example1/pkg/response"
+)
+
+func (h *Handler) Ping(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	slog.InfoContext(ctx, "pingHandler::Ping::start")
+
+	data := &pingResponseBody{
+		Message: "pong",
+	}
+	if err := response.JSON(w, data); err != nil {
+		slog.ErrorContext(
+			ctx,
+			"pingHandler::Ping::fail",
+			"error", err,
+		)
+		return
+	}
+}

lesson4/example1/internal/api/handler/ping/response.go

@@ -0,0 +1,5 @@
+package pingHandler
+
+type pingResponseBody struct {
+	Message string `json:"message"`
+}

lesson4/example1/internal/api/main.go

@@ -0,0 +1,74 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+
+	"github.com/talgat-ruby/lessons-go/lesson4/example1/configs"
+	"github.com/talgat-ruby/lessons-go/lesson4/example1/internal/api/router"
+	apiT "github.com/talgat-ruby/lessons-go/lesson4/example1/internal/api/types"
+)
+
+type server struct {
+	conf *configs.ApiConfig
+}
+
+func New(conf *configs.ApiConfig) apiT.Api {
+	s := &server{
+		conf: conf,
+	}
+
+	return s
+}
+
+func (s *server) Config() *configs.ApiConfig {
+	return s.conf
+}
+
+func (s *server) Start(ctx context.Context, cancel context.CancelFunc) {
+	mux := http.NewServeMux()
+	router.SetupRoutes(mux, s)
+
+	// start up HTTP
+	srv := &http.Server{
+		Addr:    fmt.Sprintf(":%d", s.conf.Port),
+		Handler: mux,
+		BaseContext: func(_ net.Listener) context.Context {
+			return ctx
+		},
+	}
+
+	// Listen from s different goroutine
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			slog.ErrorContext(ctx, "server error", "error", err)
+		}
+
+		cancel()
+	}()
+
+	slog.InfoContext(
+		ctx,
+		"starting api service",
+		"port", s.conf.Port,
+		"playground", fmt.Sprintf("http://localhost:%d/", s.conf.Port),
+	)
+
+	shutdown := make(chan os.Signal, 1)   // Create channel to signify s signal being sent
+	signal.Notify(shutdown, os.Interrupt) // When an interrupt is sent, notify the channel
+
+	go func() {
+		sig := <-shutdown
+
+		slog.WarnContext(ctx, "signal received - shutting down...", "signal", sig)
+		if err := srv.Shutdown(ctx); err != nil {
+			slog.ErrorContext(ctx, "server shutdown error", "error", err)
+		}
+	}()
+}

lesson4/example1/internal/api/router/ai.go

@@ -0,0 +1,13 @@
+package router
+
+import (
+	"net/http"
+
+	aiHandler "github.com/talgat-ruby/lessons-go/lesson4/example1/internal/api/handler/ai"
+)
+
+func ai(mux *http.ServeMux, apiKey string) {
+	h := aiHandler.New(apiKey)
+
+	mux.Handle("POST /prompt", http.HandlerFunc(h.Prompt))
+}

lesson4/example1/internal/api/router/main.go

@@ -0,0 +1,13 @@
+package router
+
+import (
+	"net/http"
+
+	apiT "github.com/talgat-ruby/lessons-go/lesson4/example1/internal/api/types"
+)
+
+// SetupRoutes setup router api
+func SetupRoutes(mux *http.ServeMux, api apiT.Api) {
+	ping(mux)
+	ai(mux, api.Config().AIApiKey)
+}

lesson4/example1/internal/api/router/ping.go

@@ -0,0 +1,13 @@
+package router
+
+import (
+	"net/http"
+
+	pingHandler "github.com/talgat-ruby/lessons-go/lesson4/example1/internal/api/handler/ping"
+)
+
+func ping(mux *http.ServeMux) {
+	h := pingHandler.New()
+
+	mux.Handle("GET /ping", http.HandlerFunc(h.Ping))
+}

lesson4/example1/internal/api/types/api.go

@@ -0,0 +1,12 @@
+package types
+
+import (
+	"context"
+
+	"github.com/talgat-ruby/lessons-go/lesson4/example1/configs"
+)
+
+type Api interface {
+	Start(ctx context.Context, cancel context.CancelFunc)
+	Config() *configs.ApiConfig
+}

lesson4/example1/internal/gemini/main.go

@@ -0,0 +1,9 @@
+package gemini
+
+type Gemini struct {
+	apiKey string
+}
+
+func NewGemini(apiKey string) *Gemini {
+	return &Gemini{apiKey}
+}