add multi source search for books

nevzattalhaozcan · nevzattalhaozcan · commit f1b0237edb9b · 2025-10-07T06:39:11.000+03:00
diff --git a/internal/clients/bookapi.go b/internal/clients/bookapi.go
@@ -0,0 +1,107 @@
+package clients
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/nevzattalhaozcan/forgotten/internal/models"
+)
+
+type BookAPIClient interface {
+	Search(query string, limit int) ([]*models.ExternalBook, error)
+	SearchMerged(query string, limit int) ([]*models.ExternalBook, error)
+}
+
+type MultiSourceClient struct {
+	googleBooks     *GoogleBooksClient
+	openLibrary     *OpenLibraryClient
+	preferredSource string
+}
+
+func NewMultiSourceClient(googleAPIKey string, preferredSource string) *MultiSourceClient {
+	var googleClient *GoogleBooksClient
+	if googleAPIKey != "" {
+		googleClient = NewGoogleBooksClient(googleAPIKey)
+	}
+	return &MultiSourceClient{
+		googleBooks:     googleClient,
+		openLibrary:     NewOpenLibraryClient(),
+		preferredSource: preferredSource,
+	}
+}
+
+func (c *MultiSourceClient) Search(query string, limit int) ([]*models.ExternalBook, error) {
+	var books []*models.ExternalBook
+	var err error
+
+	if c.preferredSource == "google" || c.preferredSource == "all" {
+		if c.googleBooks != nil {
+			books, err = c.googleBooks.Search(query, limit, true)
+			if err == nil && len(books) > 0 {
+				return books, nil
+			}
+			if err != nil {
+				fmt.Printf("Google Books search error: %v, falling back to Open Library\n", err)
+			}
+		}
+	}
+
+	books, err = c.openLibrary.Search(query, limit)
+	if err != nil {
+		return nil, fmt.Errorf("all sources failed: %w", err)
+	}
+	log.Printf("Found %d books from Open Library\n", len(books))
+	return books, nil
+}
+
+func (c *MultiSourceClient) SearchMerged(query string, limit int) ([]*models.ExternalBook, error) {
+	var allBooks []*models.ExternalBook
+	seen := make(map[string]bool)
+
+	if c.googleBooks != nil {
+		gbBooks, err := c.googleBooks.SearchMultiLang(query, limit)
+		if err == nil {
+			for _, b := range gbBooks {
+				key := getExternalBookKey(b)
+				if !seen[key] {
+					seen[key] = true
+					allBooks = append(allBooks, b)
+				}
+			}
+			log.Printf("Found %d books from Google Books\n", len(gbBooks))
+		} else {
+			fmt.Printf("Google Books search error: %v\n", err)
+		}
+	}
+
+	if len(allBooks) < limit {
+		remaining := limit - len(allBooks)
+		olBooks, err := c.openLibrary.Search(query, remaining*2)
+		if err == nil {
+			for _, b := range olBooks {
+				if len(allBooks) >= limit {
+					break
+				}
+				key := getExternalBookKey(b)
+				if !seen[key] {
+					seen[key] = true
+					allBooks = append(allBooks, b)
+				}
+			}
+			log.Printf("Found %d books from Open Library\n", len(olBooks))
+		}
+	}
+
+	if len(allBooks) == 0 {
+		return nil, fmt.Errorf("no books found from any source")
+	}
+
+	return allBooks, nil
+}
+
+func getExternalBookKey(eb *models.ExternalBook) string {
+	if eb.ISBN != nil && *eb.ISBN != "" {
+		return "isbn:" + *eb.ISBN
+	}
+	return "ext:" + eb.ExternalID
+}
diff --git a/internal/clients/googlebooks.go b/internal/clients/googlebooks.go
@@ -0,0 +1,147 @@
+package clients
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/nevzattalhaozcan/forgotten/internal/models"
+)
+
+type GoogleBooksClient struct {
+	APIKey  string
+	BaseURL string
+	Client  *http.Client
+}
+
+func NewGoogleBooksClient(apiKey string) *GoogleBooksClient {
+	return &GoogleBooksClient{
+		APIKey:  apiKey,
+		BaseURL: "https://www.googleapis.com/books/v1",
+		Client:  &http.Client{},
+	}
+}
+
+type gbSearchResponse struct {
+	Items []struct {
+		ID         string
+		VolumeInfo struct {
+			Title               string   `json:"title"`
+			Authors             []string `json:"authors"`
+			Publisher           string   `json:"publisher"`
+			PublishedDate       string   `json:"publishedDate"`
+			Description         string   `json:"description"`
+			PageCount           int      `json:"pageCount"`
+			Categories          []string `json:"categories"`
+			AverageRating       float32  `json:"averageRating"`
+			RatingsCount        int      `json:"ratingsCount"`
+			Language            string   `json:"language"`
+			IndustryIdentifiers []struct {
+				Type       string `json:"type"`
+				Identifier string `json:"identifier"`
+			} `json:"industryIdentifiers"`
+			ImageLinks struct {
+				Thumbnail      string `json:"thumbnail"`
+				SmallThumbnail string `json:"smallThumbnail"`
+			} `json:"imageLinks"`
+		}
+	}
+}
+
+func (c *GoogleBooksClient) Search(query string, limit int, tr bool) ([]*models.ExternalBook, error) {
+	params := url.Values{}
+	params.Set("q", query)
+	if tr {
+		params.Set("langRestrict", "tr")
+	}
+	params.Set("maxResults", fmt.Sprintf("%d", limit))
+	params.Set("key", c.APIKey)
+
+	u := fmt.Sprintf("%s/volumes?%s", c.BaseURL, params.Encode())
+	resp, err := c.Client.Get(u)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var data gbSearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return nil, err
+	}
+
+	var out []*models.ExternalBook
+	for _, item := range data.Items {
+		vi := item.VolumeInfo
+
+		var author *string
+		if len(vi.Authors) > 0 {
+			a := vi.Authors[0]
+			author = &a
+		}
+
+		var isbn *string
+		for _, id := range vi.IndustryIdentifiers {
+			if id.Type == "ISBN_13" {
+				isbn = &id.Identifier
+				break
+			}
+		}
+
+		var genre *string
+		if len(vi.Categories) > 0 {
+			g := vi.Categories[0]
+			genre = &g
+		}
+
+		var coverURL *string
+		if vi.ImageLinks.Thumbnail != "" {
+			cover := vi.ImageLinks.Thumbnail
+			coverURL = &cover
+		}
+
+		var year *int
+		if len(vi.PublishedDate) >= 4 {
+			y := 0
+			fmt.Sscanf(vi.PublishedDate[:4], "%d", &y)
+			if y > 0 {
+				year = &y
+			}
+		}
+
+		var desc *string
+		if vi.Description != "" {
+			desc = &vi.Description
+		}
+
+		var rating *float32
+		if vi.AverageRating > 0 {
+			rating = &vi.AverageRating
+		}
+
+		eb := &models.ExternalBook{
+			ExternalID:    fmt.Sprintf("GB_%s", item.ID),
+			Source:        "googlebooks",
+			Title:         vi.Title,
+			Author:        author,
+			CoverURL:      coverURL,
+			Genre:         genre,
+			Pages:         &vi.PageCount,
+			PublishedYear: year,
+			ISBN:          isbn,
+			Description:   desc,
+			Rating:        rating,
+		}
+		out = append(out, eb)
+	}
+	return out, nil
+}
+
+func (c *GoogleBooksClient) SearchMultiLang(query string, limit int) ([]*models.ExternalBook, error) {
+	books, err := c.Search(query, limit, true)
+	if err == nil && len(books) > limit/2 {
+		return books, nil
+	}
+
+	return c.Search(query, limit, false)
+}
diff --git a/internal/clients/openlibrary.go b/internal/clients/openlibrary.go
@@ -34,7 +34,9 @@ type olSearchResponse struct {
 }
 
 func (c *OpenLibraryClient) Search(query string, limit int) ([]*models.ExternalBook, error) {
-	u := fmt.Sprintf("%s/search.json?q=%s&limit=%d", c.BaseURL, url.QueryEscape(query), limit)
+	u := fmt.Sprintf("%s/search.json?q=%s&language=tur&limit=%d",
+		c.BaseURL, url.QueryEscape(query),
+		limit)
 	resp, err := c.Client.Get(u)
 	if err != nil {
 		return nil, err
diff --git a/internal/config/config.go b/internal/config/config.go
@@ -14,6 +14,13 @@ type Config struct {
 	JWT JWTConfig
 	App AppConfig
 	Redis RedisConfig
+	BookAPIs BookAPIsConfig
+}
+
+type BookAPIsConfig struct {
+	GoogleBooksAPIKey string
+	ISBNDBAPIKey      string
+	PreferredSource   string // "google", "isbndb", "openlibrary"
 }
 
 type ServerConfig struct {
@@ -88,6 +95,11 @@ func Load() *Config {
 			TLS: getEnvAsBool("REDIS_TLS", false),
 			CacheTTLSeconds: getEnvAsInt("REDIS_CACHE_TTL_SECONDS", 600),
 		},
+		BookAPIs: BookAPIsConfig{
+			GoogleBooksAPIKey: getEnv("GOOGLE_BOOKS_API_KEY", ""),
+			ISBNDBAPIKey:      getEnv("ISBNDB_API_KEY", ""),
+			PreferredSource:   getEnv("BOOK_API_SOURCE", "google"),
+		},
 	}
 }
 
diff --git a/internal/handlers/book.go b/internal/handlers/book.go
@@ -179,6 +179,17 @@ func (h *BookHandler) ListBooks(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"books": books})
 }
 
+// @Summary Search for books
+// @Description Search for books using an external API
+// @Tags Books
+// @Produce json
+// @Param q query string true "Search query"
+// @Param limit query int false "Number of results to return" default(20)
+// @Param source query string false "Source to search (google, isbndb, openlibrary)" default(all)
+// @Success 200 {object} map[string]interface{} "Search results"
+// @Failure 400 {object} map[string]string "Bad request"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/v1/books/search [get]
 func (h *BookHandler) Search(c *gin.Context) {
 	query := c.Query("q")
 	if query == "" {
diff --git a/internal/handlers/server.go b/internal/handlers/server.go
@@ -59,7 +59,7 @@ func (s *Server) setupRoutes() {
 	var clubRepo repository.ClubRepository = repository.NewClubRepository(s.db)
 	var eventRepo repository.EventRepository = repository.NewEventRepository(s.db)
 	var bookRepo repository.BookRepository = repository.NewBookRepository(s.db)
-	var olClient clients.OpenLibraryClient = *clients.NewOpenLibraryClient()
+	var bookClient clients.BookAPIClient = clients.NewMultiSourceClient(s.config.BookAPIs.GoogleBooksAPIKey, s.config.BookAPIs.PreferredSource)
 	var postRepo repository.PostRepository = repository.NewPostRepository(s.db)
 	var commentRepo repository.CommentRepository = repository.NewCommentRepository(s.db)
 	var readingRepo repository.ReadingRepository = repository.NewReadingRepository(s.db)
@@ -95,7 +95,7 @@ func (s *Server) setupRoutes() {
 	eventService := services.NewEventService(eventRepo, clubRepo, s.config)
 	eventHandler := NewEventHandler(eventService)
 
-	bookService := services.NewBookService(bookRepo, &olClient, s.config)
+	bookService := services.NewBookService(bookRepo, bookClient, s.config)
 	bookHandler := NewBookHandler(bookService)
 
 	postService := services.NewPostService(postRepo, userRepo, clubRepo, bookRepo, s.db, s.config)
diff --git a/internal/services/book.go b/internal/services/book.go
