golang-api-skeleton/api/v1/users/users.go

package users

import (
	"fmt"
	"net/http"
	"strconv"

	"git.devices.local/mawas/golang-api-skeleton/lib/apperrors"
	"git.devices.local/mawas/golang-api-skeleton/lib/cache"
	"git.devices.local/mawas/golang-api-skeleton/lib/common"
	"git.devices.local/mawas/golang-api-skeleton/lib/response"
	"git.devices.local/mawas/golang-api-skeleton/models"
	"git.devices.local/mawas/golang-api-skeleton/repositories"
	"git.devices.local/mawas/golang-api-skeleton/services"
	"github.com/blevesearch/bleve"
	"github.com/blevesearch/bleve/v2/search"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"gorm.io/gorm"
)

func prepare(c *gin.Context) (response.Envelope, *services.UserService) {
	resp := response.Envelope{
		RequestID: c.MustGet("requestID").(string),
	}
	userRepo := repositories.NewUserRepository(
		c.MustGet("db").(*gorm.DB),
		c.MustGet("userID").(string),
		c.MustGet("username").(string),
		c.MustGet("cache").(cache.Cache),
	)
	userService := services.NewUserService(userRepo)
	return resp, userService
}

// Create handler function for POST /api/v1/users
func Create(c *gin.Context) {
	var requestBody []*models.User
	resp, userService := prepare(c)
	defer resp.Recovery(c)
	if err := c.ShouldBindBodyWith(&requestBody, binding.JSON); err != nil {
		c.AbortWithStatusJSON(resp.HTTPError(apperrors.NewError(
			apperrors.ValidationFailed,
			err.Error(),
		)))
		return
	}
	users, err := userService.Create(requestBody)
	if err != nil {
		c.AbortWithStatusJSON(resp.HTTPError(err))
		return
	}
	index := c.MustGet("index").(bleve.Index)
	for i := range users {
		index.Index(users[i].ID.String(), users[i])
	}
	c.JSON(http.StatusOK, resp.SetSuccess(users))
}

// ReadByID handler function for path GET /api/v1/users/:id
func ReadByID(c *gin.Context) {
	resp, userService := prepare(c)
	username := c.Param("username")
	// index, err := bleve.Open("users.bleve")
	// if err != nil {
	// 	fmt.Println("error", err.Error())
	// }
	index := c.MustGet("index").(bleve.Index)
	raw, err := index.Document(username)
	if err != nil {
		fmt.Println("error", err.Error())
	}
	fmt.Println("<>>>>>>", string(raw.Fields[0].Value()))
	query := bleve.NewMatchQuery("jdoe")
	search := bleve.NewSearchRequest(query)
	searchResults, err := index.Search(search)
	if err != nil {
		fmt.Println("error", err.Error())
	}
	fmt.Println(searchResults)
	user, err := userService.ReadByID(username)
	if err != nil {
		c.AbortWithStatusJSON(resp.HTTPError(err))
		return
	}
	c.JSON(http.StatusOK, resp.SetSuccess(user))
}

// ReadALL handler function for path GET /api/v1/users
func ReadAll(c *gin.Context) {
	filter := c.Query("filter")
	page, _ := strconv.Atoi(c.Query("page"))
	limit, _ := strconv.Atoi(c.Query("limit"))
	if page > 0 {
		page += -1
	}
	fmt.Println(page * limit)
	resp, userService := prepare(c)
	// filter := "tokens:01F5G2F9B2CZZVV67MVDMJ5SBZ"
	// filter := "firstname:jane"
	// filter := "*mustermann*"
	index := c.MustGet("index").(bleve.Index)
	// query := bleve.NewMatchQuery(filter)
	var err error
	if filter != "" {
		query := bleve.NewQueryStringQuery(filter)
		searchRequest := bleve.NewSearchRequest(query)
		s := search.SortOrder{
			&search.SortField{
				Field:   "Username",
				Missing: search.SortFieldMissingFirst,
			},
			&search.SortDocID{},
		}
		searchRequest.SortByCustom(s)
		// search.Fields = []string{"Username", "Firstname", "Lastname", "Email", "Tokens"}
		searchRequest.SortBy([]string{"_id"})
		searchRequest.IncludeLocations = true
		searchResults, err := index.Search(searchRequest)
		if err != nil {
			fmt.Println("error", err.Error())
		}
		ids := make([]common.GUID, len(searchResults.Hits))
		for i := range searchResults.Hits {
			ids[i], _ = common.StringToGUID(searchResults.Hits[i].ID)
		}
		debugFilterPrint(searchResults)
		users, err := userService.ReadSelection(ids)
		if err != nil {
			c.AbortWithStatusJSON(resp.HTTPError(err))
			return
		}
		c.JSON(http.StatusOK, resp.SetSuccess(users))
		return
	}
	// fmt.Println("Limit:", limit, "Page:", page)
	// 	search := bleve.NewSearchRequest(query)
	// if limit > 0 {
	// 	search = bleve.NewSearchRequestOptions(query, limit, page*limit, true)
	// }

	users, err := userService.ReadAll()
	if err != nil {
		c.AbortWithStatusJSON(resp.HTTPError(err))
		return
	}
	c.JSON(http.StatusOK, resp.SetSuccess(users))
}

func debugFilterPrint(searchResults *bleve.SearchResult) {
	fmt.Println("Total:", searchResults.Total, len(searchResults.Hits))
	for _, hit := range searchResults.Hits {
		fmt.Println(hit.Fields)
		for k, v := range hit.Fields {
			fmt.Printf("Field %v = %v\n", k, v)
		}
		for fieldName, fieldMap := range hit.Locations {
			for termName, locations := range fieldMap {
				for _, location := range locations {
					// may be usefull to report back for highlighting in filter_info or so
					fmt.Printf("    Field %s has term %s from %d to %d (Pos %d?)\n", fieldName, termName, location.Start, location.End, location.Pos)
				}
			}
		}
	}
}