api/api.go

@@ -1,31 +0,0 @@
-package api
-
-import (
-	"github.com/labstack/echo/v4"
-	"go.uber.org/zap"
-
-	db "github.com/your-username/your-repo/database/sqlite/generated"
-)
-
-// API holds all API handlers
-type API struct {
-	Storage *StorageHandler
-	logger  *zap.Logger
-}
-
-// New creates a new API instance
-func New(dbQueries *db.Queries, logger *zap.Logger) *API {
-	return &API{
-		Storage: NewStorageHandler(dbQueries, logger),
-		logger:  logger,
-	}
-}
-
-// RegisterRoutes registers all API routes
-func (a *API) RegisterRoutes(e *echo.Echo, middleware echo.MiddlewareFunc) {
-	// Create API group with middleware
-	api := e.Group("/api/v1", middleware)
-	
-	// Register routes for each handler
-	a.Storage.RegisterRoutes(api)
-}

api/storage.go

@@ -1,193 +0,0 @@
-package api
-
-import (
-	"context"
-	"database/sql"
-	"net/http"
-	"strconv"
-
-	"github.com/labstack/echo/v4"
-	"go.uber.org/zap"
-
-	db "github.com/your-username/your-repo/database/sqlite/generated"
-)
-
-type StorageHandler struct {
-	db     *db.Queries
-	logger *zap.Logger
-}
-
-func NewStorageHandler(db *db.Queries, logger *zap.Logger) *StorageHandler {
-	return &StorageHandler{
-		db:     db,
-		logger: logger,
-	}
-}
-
-// GetStorageSpaces returns all storage spaces
-func (h *StorageHandler) GetStorageSpaces(c echo.Context) error {
-	ctx := context.Background()
-	
-	storageSpaces, err := h.db.GetAllStorageSpaces(ctx)
-	if err != nil {
-		h.logger.Error("Failed to fetch storage spaces", zap.Error(err))
-		return c.JSON(http.StatusInternalServerError, map[string]string{
-			"error": "Failed to fetch storage spaces",
-		})
-	}
-	
-	// Convert to a format suitable for the frontend
-	result := make([]map[string]interface{}, len(storageSpaces))
-	for i, space := range storageSpaces {
-		result[i] = map[string]interface{}{
-			"id":       space.ID,
-			"parent":   space.Parent,
-			"location": space.Location,
-		}
-	}
-	
-	return c.JSON(http.StatusOK, result)
-}
-
-// GetObjectsInStorage returns all objects in a specific storage space
-func (h *StorageHandler) GetObjectsInStorage(c echo.Context) error {
-	ctx := context.Background()
-	
-	// Parse storage ID from URL
-	storageIDStr := c.Param("id")
-	storageID, err := strconv.ParseInt(storageIDStr, 10, 64)
-	if err != nil {
-		h.logger.Warn("Invalid storage ID", zap.String("id", storageIDStr))
-		return c.JSON(http.StatusBadRequest, map[string]string{
-			"error": "Invalid storage ID",
-		})
-	}
-	
-	// Check if storage exists
-	_, err = h.db.GetStorageSpaceByID(ctx, storageID)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return c.JSON(http.StatusNotFound, map[string]string{
-				"error": "Storage space not found",
-			})
-		}
-		h.logger.Error("Failed to fetch storage space", zap.Error(err))
-		return c.JSON(http.StatusInternalServerError, map[string]string{
-			"error": "Failed to fetch storage space",
-		})
-	}
-	
-	// Get objects in this storage
-	objects, err := h.db.GetObjectsByStorageID(ctx, storageID)
-	if err != nil {
-		h.logger.Error("Failed to fetch objects in storage", zap.Error(err))
-		return c.JSON(http.StatusInternalServerError, map[string]string{
-			"error": "Failed to fetch objects in storage",
-		})
-	}
-	
-	// Convert to a format suitable for the frontend
-	result := make([]map[string]interface{}, len(objects))
-	for i, obj := range objects {
-		result[i] = map[string]interface{}{
-			"id":             obj.ID,
-			"name":           obj.Name,
-			"storagespaceId": obj.StoragespaceID,
-			"description":    obj.Description.String,
-			"serialnumber":   obj.Serialnumber.String,
-		}
-	}
-	
-	return c.JSON(http.StatusOK, result)
-}
-
-// GetStorageHierarchyObjects returns all objects in a storage hierarchy
-func (h *StorageHandler) GetStorageHierarchyObjects(c echo.Context) error {
-	ctx := context.Background()
-	
-	// Parse root storage ID from URL
-	rootStorageIDStr := c.Param("id")
-	rootStorageID, err := strconv.ParseInt(rootStorageIDStr, 10, 64)
-	if err != nil {
-		h.logger.Warn("Invalid storage ID", zap.String("id", rootStorageIDStr))
-		return c.JSON(http.StatusBadRequest, map[string]string{
-			"error": "Invalid storage ID",
-		})
-	}
-	
-	// Check if root storage exists
-	_, err = h.db.GetStorageSpaceByID(ctx, rootStorageID)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return c.JSON(http.StatusNotFound, map[string]string{
-				"error": "Storage space not found",
-			})
-		}
-		h.logger.Error("Failed to fetch storage space", zap.Error(err))
-		return c.JSON(http.StatusInternalServerError, map[string]string{
-			"error": "Failed to fetch storage space",
-		})
-	}
-	
-	// Get all storage spaces to build the hierarchy
-	allStorageSpaces, err := h.db.GetAllStorageSpaces(ctx)
-	if err != nil {
-		h.logger.Error("Failed to fetch all storage spaces", zap.Error(err))
-		return c.JSON(http.StatusInternalServerError, map[string]string{
-			"error": "Failed to fetch storage hierarchy",
-		})
-	}
-	
-	// Build a list of all storage IDs in the hierarchy
-	storageIDs := []int64{rootStorageID}
-	storageIDs = append(storageIDs, h.getChildStorageIDs(allStorageSpaces, rootStorageID)...)
-	
-	// Get objects for all storage spaces in the hierarchy
-	var allObjects []map[string]interface{}
-	
-	for _, storageID := range storageIDs {
-		// Get objects in this storage
-		objects, err := h.db.GetObjectsByStorageID(ctx, storageID)
-		if err != nil {
-			h.logger.Error("Failed to fetch objects in storage", 
-				zap.Int64("storageID", storageID),
-				zap.Error(err))
-			continue // Skip this storage if there's an error
-		}
-		
-		// Convert to a format suitable for the frontend
-		for _, obj := range objects {
-			allObjects = append(allObjects, map[string]interface{}{
-				"id":             obj.ID,
-				"name":           obj.Name,
-				"storagespaceId": obj.StoragespaceID,
-				"description":    obj.Description.String,
-				"serialnumber":   obj.Serialnumber.String,
-			})
-		}
-	}
-	
-	return c.JSON(http.StatusOK, allObjects)
-}
-
-// Helper function to recursively get all child storage IDs
-func (h *StorageHandler) getChildStorageIDs(spaces []db.Storagespace, parentID int64) []int64 {
-	var childIDs []int64
-	
-	for _, space := range spaces {
-		if space.Parent.Valid && space.Parent.Int64 == parentID {
-			childIDs = append(childIDs, space.ID)
-			// Recursively get children of this child
-			childIDs = append(childIDs, h.getChildStorageIDs(spaces, space.ID)...)
-		}
-	}
-	
-	return childIDs
-}
-
-// RegisterRoutes registers all storage-related routes
-func (h *StorageHandler) RegisterRoutes(g *echo.Group) {
-	g.GET("/storageSpaces", h.GetStorageSpaces)
-	g.GET("/storageSpaces/:id/objects", h.GetObjectsInStorage)
-	g.GET("/storageSpaces/:id/hierarchy/objects", h.GetStorageHierarchyObjects)
-}

database/sqlite/query.sql

@@ -1,69 +1,55 @@
 -- name: GetAllUsers :many
-SELECT id, username FROM users;
+SELECT * FROM users;
 
 -- name: GetUserByID :one
-SELECT id, username FROM users WHERE id = ?;
+SELECT * FROM users WHERE ID = ?;
 
 -- name: AddUser :exec
-INSERT INTO users (username) VALUES (?);
+INSERT INTO users (Username) VALUES (?);
 
 -- name: GetUserSessions :many
-SELECT user_id, username, session_token, created_at, valid_until FROM user_sessions_view WHERE user_id = ?;
+SELECT * FROM user_sessions_view WHERE user_ID = ?;
 
 -- name: AddUserSession :exec
-INSERT INTO user_sessions (user_id, session_token, created_at, valid_until, name)
+INSERT INTO user_sessions (user_ID, session_token, created_at, valid_until, name)
 VALUES (?, ?, ?, ?, ?);
 
 -- name: GetObjectsInStorage :many
-SELECT object_id, object_name, storage_location FROM object_storage WHERE storage_location = ?;
+SELECT * FROM object_storage WHERE storage_location = ?;
 
 -- name: GetUserEvents :many
-SELECT event_id, event_name, description, location, start_date, end_date, organizer FROM event_details WHERE organizer = ?;
+SELECT * FROM event_details WHERE organizer = ?;
 
 -- name: GetEventObjects :many
-SELECT objects.id, objects.storagespace_id, objects.name, objects.description, objects.serialnumber, objects.created 
+SELECT objects.* FROM objects
-FROM objects
+                          JOIN events_objects ON objects.ID = events_objects.object_ID
-JOIN events_objects ON objects.id = events_objects.object_id
+WHERE events_objects.event_ID = ?;
-WHERE events_objects.event_id = ?;
 
 -- name: AddObject :exec
-INSERT INTO objects (storagespace_id, name, description, serialnumber, created)
+INSERT INTO objects (storagespace_ID, Name, Description, Serialnumber, created)
 VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP);
 
 -- name: CreateEvent :exec
-INSERT INTO events (user_id, name, description, location, start_date, end_date)
+INSERT INTO events (user_ID, Name, Description, Location, Start_Date, End_Date)
 VALUES (?, ?, ?, ?, ?, ?);
 
 -- name: GetEventCheckIns :many
-SELECT check_in_id, username, event_name, object_name, datetime, checkin_state FROM check_in_log WHERE event_name = ?;
+SELECT * FROM check_in_log WHERE event_name = ?;
 
 -- name: AddCheckIn :exec
-INSERT INTO check_in (user_id, checkin_event_id, event_id, object_id, checkin_state_id, datetime)
+INSERT INTO check_in (user_ID, checkin_event_ID, event_ID, object_ID, checkin_state_ID, datetime)
 VALUES (?, ?, ?, ?, ?, ?);
 
 -- name: GetObjectAnnotations :many
-SELECT id, user_id, object_id, event_id, check_in_id, events_object_id, text, datetime FROM annotations WHERE object_id = ?;
+SELECT * FROM annotations WHERE object_ID = ?;
 
 -- name: AddAnnotation :exec
-INSERT INTO annotations (user_id, object_id, event_id, check_in_id, events_object_id, text, datetime)
+INSERT INTO annotations (user_ID, object_ID, event_ID, check_in_ID, events_object_ID, text, datetime)
 VALUES (?, ?, ?, ?, ?, ?, ?);
 
 -- name: GetEventPictures :many
-SELECT id, user_id, storagespace_id, object_id, event_id, check_in_id, path, description, datetime FROM pictures WHERE event_id = ?;
+SELECT * FROM pictures WHERE event_ID = ?;
 
 -- name: AddPicture :exec
-INSERT INTO pictures (user_id, storagespace_id, object_id, event_id, check_in_id, path, description, datetime)
+INSERT INTO pictures (user_ID, storagespace_ID, object_ID, event_ID, check_in_ID, Path, Description, datetime)
 VALUES (?, ?, ?, ?, ?, ?, ?, ?);
-
--- name: GetAllStorageSpaces :many
-SELECT id, parent, location FROM storagespace;
-
--- name: GetStorageSpaceByID :one
-SELECT id, parent, location FROM storagespace WHERE id = ?;
-
--- name: GetChildStorageSpaces :many
-SELECT id, parent, location FROM storagespace WHERE parent = ?;
-
--- name: GetObjectsByStorageID :many
-SELECT id, storagespace_id, name, description, serialnumber, created 
-FROM objects WHERE storagespace_id = ?;

main.go

@@ -5,25 +5,18 @@ import (
 	"database/sql"
 	"embed"
 	"encoding/json"
-	"flag"
 	"fmt"
+	"github.com/num30/config"
 	"github.com/pressly/goose/v3"
 	"go.uber.org/zap"
 	"io"
 	"net/http"
-	"os"
-	"strconv"
 	"strings"
-	"time"
 
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	_ "github.com/mattn/go-sqlite3"
 	"golang.org/x/oauth2"
-	"gopkg.in/yaml.v2"
-	
-	"github.com/your-username/your-repo/api"
-	db "github.com/your-username/your-repo/database/sqlite/generated"
 )
 
 //go:embed static/*
@@ -33,11 +26,11 @@ var staticFiles embed.FS
 var sqliteMigrations embed.FS
 
 type OAuthConfig struct {
-	ClientID     string `config:"client_id" yaml:"client_id"`
+	ClientID     string `config:"client_id"`
-	ClientSecret string `config:"client_secret" yaml:"client_secret"`
+	ClientSecret string `config:"client_secret"`
-	AuthURL      string `config:"auth_url" yaml:"auth_url"`
+	AuthURL      string `config:"auth_url"`
-	TokenURL     string `config:"token_url" yaml:"token_url"`
+	TokenURL     string `config:"token_url"`
-	UserInfoURL  string `config:"user_info_url" yaml:"user_info_url"`
+	UserInfoURL  string `config:"userinfo_url"`
 }
 
 type DBConfig struct {
@@ -55,7 +48,7 @@ type Config struct {
 	Server   struct {
 		Port int `config:"port"`
 	} `config:"server"`
-	OAuth OAuthConfig `config:"oauth" yaml:"oauth"`
+	OAuth OAuthConfig `config:"oauth"`
 	DB    DBConfig    `config:"db"`
 }
 
@@ -65,98 +58,29 @@ var (
 	logger      *zap.Logger
 )
 
-var sqlDB *sql.DB
+var db *sql.DB
 
 func main() {
-	// Load configuration from YAML file, environment variables, and flags
+	var cfg Config
-	configFile := flag.String("config", "config.yaml", "Path to config file")
-	serverPort := flag.Int("port", 0, "Server port (overrides config file)")
-	oauthClientID := flag.String("oauth-client-id", "", "OAuth Client ID (overrides config file)")
-	oauthClientSecret := flag.String("oauth-client-secret", "", "OAuth Client Secret (overrides config file)")
-	oauthAuthURL := flag.String("oauth-auth-url", "", "OAuth Auth URL (overrides config file)")
-	oauthTokenURL := flag.String("oauth-token-url", "", "OAuth Token URL (overrides config file)")
-	oauthUserInfoURL := flag.String("oauth-user-info-url", "", "OAuth User Info URL (overrides config file)")
-	flag.Parse()
 
-	// Set default values
+	cfgReader := config.NewConfReader("config").WithSearchDirs("./", ".")
-	cfg = Config{
+	cfgErr := cfgReader.Read(&cfg)
-		Env: "dev",
-		Server: struct {
-			Port int `config:"port"`
-		}{Port: 8088},
-		OAuth: OAuthConfig{},
-		DB: DBConfig{
-			Driver: "sqlite3",
-			DBName: "./inventor.sqlite",
-		},
-	}
-
-	yamlData, err := os.ReadFile(*configFile)
-	if err != nil {
-		fmt.Printf("Warning: Could not read config file: %v\n", err)
-	} else {
-		if err := yaml.Unmarshal(yamlData, &cfg); err != nil {
-			fmt.Printf("Warning: Could not parse config file: %v\n", err)
-		} else {
-			fmt.Println("Successfully loaded configuration from", *configFile)
-		}
-	}
-
-	if envPort := os.Getenv("INVENTOR_SERVER_PORT"); envPort != "" {
-		if port, err := strconv.Atoi(envPort); err == nil {
-			cfg.Server.Port = port
-		}
-	}
-	if envClientID := os.Getenv("INVENTOR_OAUTH_CLIENT_ID"); envClientID != "" {
-		cfg.OAuth.ClientID = envClientID
-	}
-	if envClientSecret := os.Getenv("INVENTOR_OAUTH_CLIENT_SECRET"); envClientSecret != "" {
-		cfg.OAuth.ClientSecret = envClientSecret
-	}
-	if envAuthURL := os.Getenv("INVENTOR_OAUTH_AUTH_URL"); envAuthURL != "" {
-		cfg.OAuth.AuthURL = envAuthURL
-	}
-	if envTokenURL := os.Getenv("INVENTOR_OAUTH_TOKEN_URL"); envTokenURL != "" {
-		cfg.OAuth.TokenURL = envTokenURL
-	}
-	if envUserInfoURL := os.Getenv("INVENTOR_OAUTH_USER_INFO_URL"); envUserInfoURL != "" {
-		cfg.OAuth.UserInfoURL = envUserInfoURL
-	}
-
-	// 3. Override with command line flags (highest priority)
-	if *serverPort != 0 {
-		cfg.Server.Port = *serverPort
-	}
-	if *oauthClientID != "" {
-		cfg.OAuth.ClientID = *oauthClientID
-	}
-	if *oauthClientSecret != "" {
-		cfg.OAuth.ClientSecret = *oauthClientSecret
-	}
-	if *oauthAuthURL != "" {
-		cfg.OAuth.AuthURL = *oauthAuthURL
-	}
-	if *oauthTokenURL != "" {
-		cfg.OAuth.TokenURL = *oauthTokenURL
-	}
-	if *oauthUserInfoURL != "" {
-		cfg.OAuth.UserInfoURL = *oauthUserInfoURL
-	}
 
 	zapcfg := zap.NewProductionConfig()
 	if cfg.Env == "dev" {
 		zapcfg = zap.NewDevelopmentConfig()
 	}
-	logger, err = zapcfg.Build()
+	logger, err := zapcfg.Build()
 	if err != nil {
 		panic(fmt.Sprintf("Failed to initialize logger: %v", err))
 	}
 	defer logger.Sync()
 
-	// Configuration errors are now handled inline during loading
+	if cfgErr != nil {
+		logger.Fatal("Failed to load config", zap.Error(cfgErr))
+	}
 
-	// Print the raw config to see what's actually loaded
+	logger.Info("Loaded config", zap.Any("config", cfg))
-	logger.Debug("Raw config loaded", zap.Any("config", cfg))
 
 	// Initialize OAuth2
 	oauthConfig = &oauth2.Config{
@@ -166,17 +90,10 @@ func main() {
 			AuthURL:  cfg.OAuth.AuthURL,
 			TokenURL: cfg.OAuth.TokenURL,
 		},
-		RedirectURL: fmt.Sprintf("http://localhost:3000/oauth/callback"),
+		RedirectURL: fmt.Sprintf("http://localhost:%d/oauth/callback", cfg.Server.Port),
-		Scopes:      []string{"profile", "email", "openid"},
+		Scopes:      []string{"profile", "email"},
 	}
-
+	fmt.Println(oauthConfig)
-	// Log the OAuth config that's actually being used
-	logger.Info("Initialized OAuth Config",
-		zap.String("ClientID", oauthConfig.ClientID),
-		zap.String("ClientSecret", oauthConfig.ClientSecret),
-		zap.String("AuthURL", oauthConfig.Endpoint.AuthURL),
-		zap.String("TokenURL", oauthConfig.Endpoint.TokenURL),
-		zap.String("RedirectURL", oauthConfig.RedirectURL))
 
 	// Initialize database connection
 	var dsn string
@@ -189,28 +106,25 @@ func main() {
 			cfg.DB.User, cfg.DB.Password, cfg.DB.Host, cfg.DB.Port, cfg.DB.DBName)
 	}
 
-	sqlDB, err = sql.Open(cfg.DB.Driver, dsn)
+	db, err = sql.Open(cfg.DB.Driver, dsn)
 	if err != nil {
 		logger.Fatal("Failed to connect to database", zap.Error(err))
 	}
-	defer sqlDB.Close()
+	defer db.Close()
 
 	// Test the connection
-	if err = sqlDB.Ping(); err != nil {
+	if err = db.Ping(); err != nil {
 		logger.Fatal("Failed to ping database", zap.Error(err))
 	}
 	logger.Info("Successfully connected to database", zap.String("driver", cfg.DB.Driver))
 
 	if cfg.DB.Driver == "sqlite3" {
 		logger.Info("migrating sqlite database")
-		if err := migrateSqlite(sqlDB); err != nil {
+		if err := migrateSqlite(db); err != nil {
 			logger.Fatal("Failed to migrate database", zap.Error(err))
 		}
 	}
 
-	// Initialize database queries
-	dbQueries := db.New(sqlDB)
-
 	// Initialize Echo
 	e := echo.New()
 	e.Use(middleware.Logger())
@@ -221,12 +135,9 @@ func main() {
 	e.GET("/oauth/login", handleOAuthLogin)
 	e.GET("/oauth/callback", handleOAuthCallback)
 
-	// Initialize API
-	apiHandler := api.New(dbQueries, logger)
-	
 	// Protected API routes
-	apiGroup := e.Group("/api/v1", oauthMiddleware)
+	api := e.Group("/api/v1", oauthMiddleware)
-	apiGroup.GET("/health", func(c echo.Context) error {
+	api.GET("/health", func(c echo.Context) error {
 		user := c.Get("user").(map[string]interface{})
 		logger.Info("Health check requested", zap.Any("user", user))
 		return c.JSON(http.StatusOK, map[string]interface{}{
@@ -235,9 +146,6 @@ func main() {
 		})
 	})
 
-	// Register all other API routes
-	apiHandler.RegisterRoutes(e, oauthMiddleware)
-
 	// Serve static files - must be after API routes
 	e.GET("/*", echo.WrapHandler(http.FileServer(http.FS(staticFiles))))
 
@@ -286,15 +194,6 @@ func handleOAuthCallback(c echo.Context) error {
 
 	logger.Info("OAuth token exchanged successfully", zap.String("access_token", token.AccessToken))
 
-	// Fetch user info to verify the token works
-	userInfo, err := fetchUserInfo(token.AccessToken)
-	if err != nil {
-		logger.Error("Failed to fetch user info after token exchange", zap.Error(err))
-		// Continue anyway, as the token might still be valid
-	} else {
-		logger.Info("Successfully fetched user info after token exchange", zap.Any("userInfo", userInfo))
-	}
-
 	// Return HTML that stores the token and redirects to the main app
 	html := fmt.Sprintf(`
 	<!DOCTYPE html>
@@ -331,30 +230,10 @@ func oauthMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 			return c.JSON(http.StatusUnauthorized, map[string]string{"error": "invalid Authorization header"})
 		}
 
-		// Log the UserInfoURL being used
-		logger.Info("Fetching user info", zap.String("UserInfoURL", cfg.OAuth.UserInfoURL))
-
 		// Validate token and fetch user info
 		userInfo, err := fetchUserInfo(token)
 		if err != nil {
 			logger.Error("OAuth token validation failed", zap.Error(err))
-			
-			// For debugging purposes, try to get more information about the error
-			logger.Debug("Attempting to decode token for debugging", zap.String("token", token))
-			
-			// Create a mock user for development purposes if in dev mode
-			if cfg.Env == "dev" {
-				logger.Warn("DEV MODE: Using mock user due to token validation failure")
-				mockUser := map[string]interface{}{
-					"sub": "mock-user-id",
-					"name": "Mock User",
-					"email": "mock@example.com",
-					"preferred_username": "mockuser",
-				}
-				c.Set("user", mockUser)
-				return next(c)
-			}
-			
 			return c.JSON(http.StatusUnauthorized, map[string]string{"error": "invalid token"})
 		}
 
@@ -366,64 +245,27 @@ func oauthMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 
 // Fetch user info from OAuth provider
 func fetchUserInfo(token string) (map[string]interface{}, error) {
-	if cfg.OAuth.UserInfoURL == "" {
-		return nil, fmt.Errorf("UserInfoURL is empty")
-	}
-
-	// Create a new request
 	req, err := http.NewRequest("GET", cfg.OAuth.UserInfoURL, nil)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create request: %w", err)
+		return nil, err
 	}
-	
-	// Set headers - try both common authorization methods
 	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("Accept", "application/json")
 
-	// Log the full request for debugging
+	client := http.Client{}
-	logger.Debug("UserInfo request",
-		zap.String("url", req.URL.String()),
-		zap.String("method", req.Method),
-		zap.Any("headers", req.Header))
-
-	// Create a client with reasonable timeout
-	client := &http.Client{
-		Timeout: 10 * time.Second,
-	}
-	
-	// Execute the request
 	resp, err := client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("request failed: %w", err)
+		return nil, err
 	}
 	defer resp.Body.Close()
 
-	// Read the response body
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	// Log the response for debugging
-	logger.Debug("UserInfo response",
-		zap.Int("status", resp.StatusCode),
-		zap.String("body", string(body)),
-		zap.Any("headers", resp.Header))
-
-	// Check for successful status code
 	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("OAuth validation failed with status %d: %s", resp.StatusCode, string(body))
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("OAuth validation failed: %s", string(body))
 	}
 
-	// Parse the JSON response
 	var userInfo map[string]interface{}
-	if err := json.Unmarshal(body, &userInfo); err != nil {
+	if err := json.NewDecoder(resp.Body).Decode(&userInfo); err != nil {
-		return nil, fmt.Errorf("failed to parse user info: %w", err)
+		return nil, err
-	}
-
-	// Verify we have some basic user information
-	if userInfo["sub"] == nil && userInfo["id"] == nil && userInfo["email"] == nil {
-		return nil, fmt.Errorf("response doesn't contain expected user information")
 	}
 
 	return userInfo, nil

web/src/components/StorageHierarchy.vue

@@ -1,193 +0,0 @@
-<template>
-  <v-container>
-    <v-card>
-      <v-card-title class="text-h5">
-        Storage Hierarchy
-        <v-spacer></v-spacer>
-        <v-select
-          v-model="selectedStorageId"
-          :items="storageSpaces"
-          item-title="location"
-          item-value="id"
-          label="Select Storage Space"
-          density="compact"
-          variant="outlined"
-          class="ml-2"
-          style="max-width: 300px"
-        ></v-select>
-      </v-card-title>
-      
-      <v-card-text>
-        <v-alert
-          v-if="error"
-          type="error"
-          variant="tonal"
-          closable
-        >
-          {{ error }}
-        </v-alert>
-        
-        <div v-if="loading" class="d-flex justify-center align-center my-4">
-          <v-progress-circular indeterminate color="primary"></v-progress-circular>
-        </div>
-        
-        <template v-else>
-          <v-expansion-panels v-if="selectedStorage">
-            <storage-box 
-              :storage="selectedStorage" 
-              :objects="objectsInStorage"
-              :nested-storages="nestedStorages"
-            />
-          </v-expansion-panels>
-          
-          <v-alert v-else type="info" variant="tonal">
-            Please select a storage space to view its contents
-          </v-alert>
-        </template>
-      </v-card-text>
-    </v-card>
-  </v-container>
-</template>
-
-<script lang="ts" setup>
-import { ref, computed, watch, onMounted, defineComponent } from 'vue';
-import { useStorageStore } from '@/stores/storage';
-
-// Component for recursive display of storage boxes
-const StorageBox = defineComponent({
-  name: 'StorageBox',
-  props: {
-    storage: Object,
-    objects: Array,
-    nestedStorages: Array
-  },
-  setup(props) {
-    const objectsInCurrentStorage = computed(() => {
-      return props.objects.filter(obj => obj.storagespaceId === props.storage.id);
-    });
-    
-    const childStorages = computed(() => {
-      return props.nestedStorages.filter(storage => 
-        storage.parent && storage.parent.valid && storage.parent.int64 === props.storage.id
-      );
-    });
-    
-    return () => (
-      <v-expansion-panel>
-        <v-expansion-panel-title>
-          <div class="d-flex align-center">
-            <v-icon class="mr-2">mdi-package-variant-closed</v-icon>
-            <span>{ props.storage.location || `Storage #${props.storage.id}` }</span>
-            <v-chip class="ml-2" size="small" color="primary" variant="outlined">
-              { objectsInCurrentStorage.value.length } objects
-            </v-chip>
-          </div>
-        </v-expansion-panel-title>
-        <v-expansion-panel-text>
-          <div class="mb-4">
-            <h3 class="text-subtitle-1 mb-2">Objects in this storage:</h3>
-            {objectsInCurrentStorage.value.length > 0 ? (
-              <v-list lines="two">
-                {objectsInCurrentStorage.value.map(obj => (
-                  <v-list-item
-                    :key="obj.id"
-                    :title="obj.name"
-                    :subtitle="obj.description || 'No description'"
-                  >
-                    <template v-slot:prepend>
-                      <v-icon>mdi-cube-outline</v-icon>
-                    </template>
-                    <template v-slot:append>
-                      <v-chip size="small" color="grey" variant="flat">
-                        SN: { obj.serialnumber || 'N/A' }
-                      </v-chip>
-                    </template>
-                  </v-list-item>
-                ))}
-              </v-list>
-            ) : (
-              <v-alert type="info" variant="tonal" density="compact">
-                No objects in this storage
-              </v-alert>
-            )}
-          </div>
-          
-          {childStorages.value.length > 0 && (
-            <div class="mt-4">
-              <h3 class="text-subtitle-1 mb-2">Nested storage spaces:</h3>
-              <v-expansion-panels>
-                {childStorages.value.map(childStorage => (
-                  <StorageBox
-                    key={childStorage.id}
-                    storage={childStorage}
-                    objects={props.objects}
-                    nestedStorages={props.nestedStorages}
-                  />
-                ))}
-              </v-expansion-panels>
-            </div>
-          )}
-        </v-expansion-panel-text>
-      </v-expansion-panel>
-    );
-  }
-});
-
-// Main component logic
-const storageStore = useStorageStore();
-const loading = ref(false);
-const error = ref(null);
-const selectedStorageId = ref(null);
-
-const storageSpaces = computed(() => storageStore.storageSpaces);
-const objects = computed(() => storageStore.objects);
-
-const selectedStorage = computed(() => {
-  if (!selectedStorageId.value) return null;
-  return storageSpaces.value.find(s => s.id === selectedStorageId.value);
-});
-
-const objectsInStorage = computed(() => {
-  if (!selectedStorageId.value) return [];
-  return objects.value;
-});
-
-const nestedStorages = computed(() => {
-  return storageSpaces.value;
-});
-
-watch(selectedStorageId, async (newId) => {
-  if (newId) {
-    await fetchStorageData(newId);
-  }
-});
-
-async function fetchStorageData(storageId) {
-  loading.value = true;
-  error.value = null;
-  
-  try {
-    await storageStore.fetchStorageHierarchy(storageId);
-  } catch (err) {
-    error.value = err.message || 'Failed to load storage data';
-  } finally {
-    loading.value = false;
-  }
-}
-
-onMounted(async () => {
-  loading.value = true;
-  error.value = null;
-  
-  try {
-    await storageStore.fetchStorageSpaces();
-    if (storageSpaces.value.length > 0) {
-      selectedStorageId.value = storageSpaces.value[0].id;
-    }
-  } catch (err) {
-    error.value = err.message || 'Failed to load storage spaces';
-  } finally {
-    loading.value = false;
-  }
-});
-</script>

web/src/pages/index.vue

@@ -1,21 +1,7 @@
 <template>
-  <v-container>
+  <HelloWorld />
-    <v-row>
-      <v-col cols="12">
-        <h1 class="text-h4 mb-4">Inventory Management System</h1>
-        
-        <v-card class="mb-4">
-          <v-card-text>
-            <p>Welcome to the Inventory Management System. Use this dashboard to view and manage objects in storage spaces.</p>
-          </v-card-text>
-        </v-card>
-        
-        <StorageHierarchy />
-      </v-col>
-    </v-row>
-  </v-container>
 </template>
 
 <script lang="ts" setup>
-import StorageHierarchy from '@/components/StorageHierarchy.vue';
+  //
 </script>

web/src/stores/auth.ts

@@ -5,13 +5,10 @@ export const useAuthStore = defineStore('auth', {
   state: () => ({
     token: localStorage.getItem('auth_token') || null,
     user: null as any | null,
-    loading: false,
-    error: null as string | null,
   }),
   
   getters: {
     isAuthenticated: (state) => !!state.token,
-    isLoading: (state) => state.loading,
   },
   
   actions: {
@@ -24,60 +21,32 @@ export const useAuthStore = defineStore('auth', {
       this.user = user;
     },
     
-    setError(error: string | null) {
-      this.error = error;
-    },
-    
     logout() {
       this.token = null;
       this.user = null;
-      this.error = null;
       localStorage.removeItem('auth_token');
     },
     
     async fetchUserInfo() {
       if (!this.token) return;
       
-      this.loading = true;
-      this.error = null;
-      
       try {
         const response = await fetch('/api/v1/health', {
           headers: {
-            'Authorization': `Bearer ${this.token}`,
+            'Authorization': `Bearer ${this.token}`
-            'Accept': 'application/json'
           }
         });
         
         if (response.ok) {
           const data = await response.json();
           this.setUser(data.user);
-          console.log('User info fetched successfully:', data.user);
         } else {
-          // Get error details
+          // If token is invalid, logout
-          let errorText = 'Authentication failed';
+          this.logout();
-          try {
-            const errorData = await response.json();
-            errorText = errorData.error || errorText;
-          } catch (e) {
-            // If we can't parse the error as JSON, use the status text
-            errorText = response.statusText || errorText;
-          }
-          
-          console.error('Failed to fetch user info:', errorText);
-          this.setError(errorText);
-          
-          // If token is invalid (401), logout
-          if (response.status === 401) {
-            this.logout();
-          }
         }
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error('Failed to fetch user info:', error);
-        console.error('Failed to fetch user info:', errorMessage);
+        this.logout();
-        this.setError(errorMessage);
-      } finally {
-        this.loading = false;
       }
     }
   }

web/src/stores/storage.ts

@@ -1,113 +0,0 @@
-import { defineStore } from 'pinia';
-
-export const useStorageStore = defineStore('storage', {
-  state: () => ({
-    storageSpaces: [] as any[],
-    objects: [] as any[],
-    loading: false,
-    error: null as string | null,
-  }),
-  
-  getters: {
-    getStorageById: (state) => (id: number) => {
-      return state.storageSpaces.find(storage => storage.id === id);
-    },
-    
-    getObjectsInStorage: (state) => (storageId: number) => {
-      return state.objects.filter(obj => obj.storagespaceId === storageId);
-    },
-    
-    getChildStorages: (state) => (parentId: number) => {
-      return state.storageSpaces.filter(storage => 
-        storage.parent && storage.parent === parentId
-      );
-    }
-  },
-  
-  actions: {
-    async fetchStorageSpaces() {
-      this.loading = true;
-      this.error = null;
-      
-      try {
-        const response = await fetch('/api/v1/storageSpaces', {
-          headers: {
-            'Authorization': `Bearer ${localStorage.getItem('auth_token')}`,
-          },
-        });
-        
-        if (!response.ok) {
-          throw new Error('Failed to fetch storage spaces');
-        }
-        
-        const data = await response.json();
-        this.storageSpaces = data.map((space: any) => ({
-          id: space.id,
-          parent: space.parent,
-          location: space.location
-        }));
-      } catch (error: any) {
-        this.error = error.message;
-        throw error;
-      } finally {
-        this.loading = false;
-      }
-    },
-    
-    async fetchObjectsInStorage(storageId: number) {
-      this.loading = true;
-      this.error = null;
-      
-      try {
-        const response = await fetch(`/api/v1/storageSpaces/${storageId}/objects`, {
-          headers: {
-            'Authorization': `Bearer ${localStorage.getItem('auth_token')}`,
-          },
-        });
-        
-        if (!response.ok) {
-          throw new Error('Failed to fetch objects');
-        }
-        
-        const data = await response.json();
-        this.objects = data;
-      } catch (error: any) {
-        this.error = error.message;
-        throw error;
-      } finally {
-        this.loading = false;
-      }
-    },
-    
-    async fetchStorageHierarchy(rootStorageId: number) {
-      this.loading = true;
-      this.error = null;
-      
-      try {
-        // First, ensure we have all storage spaces
-        if (this.storageSpaces.length === 0) {
-          await this.fetchStorageSpaces();
-        }
-        
-        // Then fetch all objects in the hierarchy
-        const response = await fetch(`/api/v1/storageSpaces/${rootStorageId}/hierarchy/objects`, {
-          headers: {
-            'Authorization': `Bearer ${localStorage.getItem('auth_token')}`,
-          },
-        });
-        
-        if (!response.ok) {
-          throw new Error('Failed to fetch storage hierarchy');
-        }
-        
-        const data = await response.json();
-        this.objects = data;
-      } catch (error: any) {
-        this.error = error.message;
-        throw error;
-      } finally {
-        this.loading = false;
-      }
-    }
-  }
-});