Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package search
import (
"cmp"
"reflect"
"slices"
"sort"
"strings"
"github.com/getarcaneapp/arcane/types/v2/category"
"github.com/getarcaneapp/arcane/types/v2/meta"
"github.com/getarcaneapp/arcane/types/v2/search"
"go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
)
type CustomizeSearchService struct {
categories []category.Category
}
func NewCustomizeSearchService() *CustomizeSearchService {
return &CustomizeSearchService{categories: BuildCategories[CustomizeItem](search.CustomizeProfile)}
}
// GetCustomizeCategories returns the category index initialized by the service.
func (s *CustomizeSearchService) GetCustomizeCategories() []category.Category {
return s.categories
}
// BuildCategories extracts searchable metadata in model field order.
func BuildCategories[T any](profile search.Profile) []category.Category {
catMetaMap := utils.ExtractCategoryMetadata[T]()
categories := map[string][]meta.Metadata{}
var categoryOrder []string
rt := reflect.TypeFor[T]()
for field := range rt.Fields() {
keyTag := field.Tag.Get("key")
key, _, _ := strings.Cut(keyTag, ",")
if key == "" {
continue
}
metaTag := utils.ParseMetaTag(field.Tag.Get("meta"))
label := cmp.Or(metaTag["label"], key)
typ := cmp.Or(metaTag["type"], "text")
desc := metaTag["description"]
keywords := utils.ParseKeywords(metaTag["keywords"])
categoryID := metaTag["category"]
if categoryID == "" && profile == search.SettingsProfile {
catMeta := utils.ParseMetaTag(field.Tag.Get("catmeta"))
categoryID = catMeta["id"]
}
if categoryID == "" {
categoryID = kit.Ternary(profile == search.SettingsProfile, "jobs", "defaults")
}
if categoryID == "internal" && profile == search.SettingsProfile {
continue
}
if len(categories[categoryID]) == 0 && !slices.Contains(categoryOrder, categoryID) {
categoryOrder = append(categoryOrder, categoryID)
}
sm := meta.Metadata{
Key: key,
Label: label,
Type: typ,
Description: desc,
Keywords: keywords,
}
categories[categoryID] = append(categories[categoryID], sm)
}
results := []category.Category{}
for _, catID := range categoryOrder {
catMeta := catMetaMap[catID]
if catMeta == nil {
continue
}
keywords := utils.ParseKeywords(catMeta["keywords"])
if keywords == nil {
keywords = []string{}
}
results = append(results, category.Category{
ID: catMeta["id"],
Title: catMeta["title"],
Description: catMeta["description"],
Icon: catMeta["icon"],
URL: catMeta["url"],
Keywords: keywords,
Settings: categories[catID],
})
}
return results
}
// Search matches category metadata using the selected ranking profile.
func Search(categories []category.Category, query string, profile search.Profile) search.Response {
query = strings.ToLower(strings.TrimSpace(query))
if query == "" {
return search.Response{
Results: []category.Category{},
Query: query,
Count: 0,
}
}
var results []category.Category
if profile == search.CustomizeProfile {
results = []category.Category{}
}
for _, cat := range categories {
categoryMatch := categoryMatchesInternal(cat, query)
matchingSettings := findMatchingSettingsInternal(cat.Settings, query)
if categoryMatch || len(matchingSettings) > 0 {
relevanceScore := calculateRelevanceInternal(cat, matchingSettings, query, profile)
categoryResult := category.Category{
ID: cat.ID,
Title: cat.Title,
Description: cat.Description,
Icon: cat.Icon,
URL: cat.URL,
Keywords: cat.Keywords,
Settings: cat.Settings,
RelevanceScore: relevanceScore,
}
if profile == search.CustomizeProfile {
categoryResult.MatchingSettings = cat.MatchingSettings
}
if len(matchingSettings) > 0 {
categoryResult.MatchingSettings = matchingSettings
}
results = append(results, categoryResult)
}
}
sort.Slice(results, func(i, j int) bool {
return results[i].RelevanceScore > results[j].RelevanceScore
})
return search.Response{
Results: results,
Query: query,
Count: len(results),
}
}
func categoryMatchesInternal(cat category.Category, query string) bool {
if strings.Contains(strings.ToLower(cat.Title), query) {
return true
}
if strings.Contains(strings.ToLower(cat.Description), query) {
return true
}
for _, keyword := range cat.Keywords {
if strings.Contains(strings.ToLower(keyword), query) {
return true
}
}
return false
}
func findMatchingSettingsInternal(settings []meta.Metadata, query string) []meta.Metadata {
var matching []meta.Metadata
for _, setting := range settings {
if settingMatchesInternal(setting, query) {
matching = append(matching, setting)
}
}
return matching
}
func settingMatchesInternal(setting meta.Metadata, query string) bool {
if strings.Contains(strings.ToLower(setting.Key), query) {
return true
}
if strings.Contains(strings.ToLower(setting.Label), query) {
return true
}
if strings.Contains(strings.ToLower(setting.Description), query) {
return true
}
for _, keyword := range setting.Keywords {
if strings.Contains(strings.ToLower(keyword), query) {
return true
}
}
return false
}
func calculateRelevanceInternal(cat category.Category, matchingSettings []meta.Metadata, query string, profile search.Profile) int {
score := 0
if profile == search.CustomizeProfile && strings.ToLower(cat.Title) == query {
score += 30
} else if strings.Contains(strings.ToLower(cat.Title), query) {
score += 20
}
if strings.Contains(strings.ToLower(cat.Description), query) {
score += 15
}
for _, keyword := range cat.Keywords {
if strings.ToLower(keyword) == query {
score += 25
if profile == search.CustomizeProfile {
break
}
} else if strings.Contains(strings.ToLower(keyword), query) {
score += 10
if profile == search.CustomizeProfile {
break
}
}
}
for _, setting := range matchingSettings {
score += calculateSettingRelevanceInternal(setting, query, profile)
}
return score
}
func calculateSettingRelevanceInternal(setting meta.Metadata, query string, profile search.Profile) int {
score := 0
if strings.ToLower(setting.Key) == query {
score += 30
} else if strings.Contains(strings.ToLower(setting.Key), query) {
score += 15
}
if strings.Contains(strings.ToLower(setting.Label), query) {
score += 12
}
if strings.Contains(strings.ToLower(setting.Description), query) {
score += 8
}
for _, keyword := range setting.Keywords {
if strings.ToLower(keyword) == query {
score += 20
if profile == search.CustomizeProfile {
break
}
} else if strings.Contains(strings.ToLower(keyword), query) {
score += 5
if profile == search.CustomizeProfile {
break
}
}
}
return score
}