125 lines
2.9 KiB
Go
125 lines
2.9 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
|
|
logger "git.site.quack-lab.dev/dave/cylogger"
|
|
|
|
"github.com/joho/godotenv"
|
|
)
|
|
|
|
type Options struct {
|
|
ClientID string
|
|
RedirectURI string
|
|
Scopes []string
|
|
DBPath string
|
|
}
|
|
|
|
var options Options
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
logger.InitFlag()
|
|
logger.Info("Starting Eve PI")
|
|
|
|
var err error
|
|
options, err = LoadOptions()
|
|
if err != nil {
|
|
logger.Error("Failed to load options %v", err)
|
|
return
|
|
}
|
|
|
|
// Create SSO instance
|
|
sso, err := NewSSO(
|
|
options.ClientID,
|
|
options.RedirectURI,
|
|
options.Scopes,
|
|
)
|
|
if err != nil {
|
|
logger.Error("Failed to create SSO instance %v", err)
|
|
return
|
|
}
|
|
|
|
// Setup HTTP server
|
|
mux := http.NewServeMux()
|
|
|
|
// Configure SSO to use existing muxer
|
|
sso.SetMuxer(mux)
|
|
|
|
// Add your own routes
|
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("EVE PI Server Running"))
|
|
})
|
|
|
|
// Start server
|
|
server := &http.Server{
|
|
Addr: ":3000",
|
|
Handler: mux,
|
|
}
|
|
|
|
logger.Info("Starting web server on :3000")
|
|
go func() {
|
|
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
|
logger.Error("Server failed: %v", err)
|
|
}
|
|
}()
|
|
|
|
mux.HandleFunc("/login", func(w http.ResponseWriter, r *http.Request) {
|
|
charName := r.URL.Query().Get("character")
|
|
if charName == "" {
|
|
http.Error(w, "Missing character parameter", http.StatusBadRequest)
|
|
return
|
|
}
|
|
logger.Info("Login requested for character %s", charName)
|
|
// Trigger the auth flow (will register callback if needed)
|
|
token, err := sso.GetToken(r.Context(), charName)
|
|
if err != nil {
|
|
logger.Error("Failed to authenticate character %s: %v", charName, err)
|
|
http.Error(w, "Authentication failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
logger.Info("Successfully authenticated character %s", charName)
|
|
w.Header().Set("Content-Type", "text/plain")
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("Authenticated! Access token: " + token))
|
|
})
|
|
}
|
|
|
|
func LoadOptions() (Options, error) {
|
|
// Load environment variables strictly from .env file (fail if there's an error loading)
|
|
if err := godotenv.Load(); err != nil {
|
|
return Options{}, fmt.Errorf("error loading .env file: %w", err)
|
|
}
|
|
|
|
clientID := os.Getenv("ESI_CLIENT_ID")
|
|
if clientID == "" {
|
|
return Options{}, fmt.Errorf("ESI_CLIENT_ID is required in .env file")
|
|
}
|
|
redirectURI := os.Getenv("ESI_REDIRECT_URI")
|
|
if redirectURI == "" {
|
|
return Options{}, fmt.Errorf("ESI_REDIRECT_URI is required in .env file")
|
|
}
|
|
rawScopes := os.Getenv("ESI_SCOPES")
|
|
if rawScopes == "" {
|
|
return Options{}, fmt.Errorf("ESI_SCOPES is required in .env file")
|
|
}
|
|
scopes := strings.Fields(rawScopes)
|
|
dbPath := os.Getenv("DB_PATH")
|
|
if dbPath == "" {
|
|
return Options{}, fmt.Errorf("DB_PATH is required in .env file")
|
|
}
|
|
|
|
return Options{
|
|
ClientID: clientID,
|
|
RedirectURI: redirectURI,
|
|
Scopes: scopes,
|
|
DBPath: dbPath,
|
|
}, nil
|
|
}
|