Implemented search functionality

2 files changed, 227 insertions, 0 deletions

diff --git a/search/search.go b/search/search.go
new file mode 100644
index 0000000..4b49843
--- /dev/null
+++ b/search/search.go
@@ -0,0 +1,212 @@
+package main
+
+import (
+	"embed"
+	"encoding/json"
+	"html/template"
+	"log"
+	"net/http"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// Variables to customise the search behaviour
+const (
+	listenStr        = "0.0.0.0:8080"
+	titleScore       = 20
+	tagsScore        = 10
+	descriptionScore = 5
+	contentScore     = 1
+)
+
+//go:embed index.html search.html
+var templatesFS embed.FS
+
+//go:embed index.json
+var indexFS embed.FS
+
+// html templates
+var searchTemplate = template.Must(template.New("search").ParseFS(templatesFS, "search.html", "index.html"))
+
+// index records
+type JsonIndexRecord struct {
+	Content     string   `json:"content"`
+	Description string   `json:"description"`
+	Permalink   string   `json:"permalink"`
+	Tags        []string `json:"tags"`
+	Title       string   `json:"title"`
+}
+
+type SearchIndexRecord struct {
+	Title       []string
+	Tags        []string
+	Description []string
+	Content     []string
+	Permalink   string
+}
+
+var jsonIndex []JsonIndexRecord
+var searchIndex []SearchIndexRecord
+
+// The following works on index entries to clean up words : remove case, punctuation, words less than 3 characters
+var validWord = regexp.MustCompile(`([a-zA-Z0-9]+)`)
+
+func normalizeWords(words []string) (result []string) {
+	sort.Strings(words) // to easily remove duplicates
+	lastword := ""
+	for i := 0; i < len(words); i++ {
+		word := strings.ToLower(validWord.FindString(words[i])) // Get rid of punctuation, would not work well for french apostrophes
+		if word == lastword || len(word) < 3 {                  // we remove duplicates and words less than 3 characters
+			continue
+		}
+		result = append(result, word)
+	}
+	return
+}
+
+// The scoring function used by the index
+func scoreIndex(words []string, indexWords []string) (score int) {
+	for i := 0; i < len(indexWords); i++ {
+		for j := 0; j < len(words); j++ {
+			if strings.Contains(indexWords[i], words[j]) {
+				score++
+			}
+		}
+	}
+	return
+}
+
+// We need a way to sort by score and get an article Id
+type Pair struct {
+	Id    int
+	Score int
+}
+
+type Pairs []Pair
+
+func (p Pairs) Len() int           { return len(p) }
+func (p Pairs) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+func (p Pairs) Less(i, j int) bool { return p[i].Score < p[j].Score }
+
+// the template variables
+type SearchPage struct {
+	Query             string
+	SearchTitle       bool
+	SearchTags        bool
+	SearchDescription bool
+	SearchContent     bool
+	Results           []JsonIndexRecord
+}
+
+// The search handler of the webui
+func searchHandler(w http.ResponseWriter, r *http.Request) error {
+	p := SearchPage{
+		Query: strings.ToLower(r.FormValue("query")),
+	}
+	if p.Query != "" {
+		log.Printf("searching for: %s", p.Query)
+		// First we reset the search options status
+		p.SearchTitle = r.FormValue("searchTitle") == "true"
+		p.SearchTags = r.FormValue("searchTags") == "true"
+		p.SearchDescription = r.FormValue("searchDescription") == "true"
+		p.SearchContent = r.FormValue("searchContent") == "true"
+		// Then we walk the index
+		words := normalizeWords(strings.Fields(p.Query))
+		scores := make(Pairs, 0)
+		for i := 0; i < len(jsonIndex); i++ {
+			score := 0
+			if p.SearchTitle {
+				score = titleScore * scoreIndex(words, searchIndex[i].Title)
+			}
+			if p.SearchTags {
+				score += tagsScore * scoreIndex(words, searchIndex[i].Tags)
+			}
+			if p.SearchDescription {
+				score += descriptionScore * scoreIndex(words, searchIndex[i].Description)
+			}
+			if p.SearchContent {
+				score += contentScore * scoreIndex(words, searchIndex[i].Content)
+			}
+			if score > 0 {
+				scores = append(scores, Pair{i, score})
+			}
+		}
+		// we sort highest scores first
+		sort.Sort(scores)
+		for i := len(scores) - 1; i >= 0; i-- {
+			p.Results = append(p.Results, jsonIndex[scores[i].Id])
+		}
+	} else {
+		// default checkbox values
+		p.SearchTitle = true
+		p.SearchTags = true
+	}
+	w.Header().Set("Cache-Control", "no-store, no-cache")
+	if err := searchTemplate.ExecuteTemplate(w, "index.html", p); err != nil {
+		return newStatusError(http.StatusInternalServerError, err)
+	}
+	return nil
+}
+
+// the environment that will be passed to our handlers
+type handlerError interface {
+	error
+	Status() int
+}
+type statusError struct {
+	code int
+	err  error
+}
+
+func (e *statusError) Error() string           { return e.err.Error() }
+func (e *statusError) Status() int             { return e.code }
+func newStatusError(code int, err error) error { return &statusError{code: code, err: err} }
+
+type handler struct {
+	h func(w http.ResponseWriter, r *http.Request) error
+}
+
+// ServeHTTP allows our handler type to satisfy http.Handler
+func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	path := r.URL.Path
+	err := h.h(w, r)
+	if err != nil {
+		switch e := err.(type) {
+		case handlerError:
+			log.Printf("HTTP %d - %s", e.Status(), e)
+			http.Error(w, e.Error(), e.Status())
+		default:
+			// Any error types we don't specifically look out for default to serving a HTTP 500
+			log.Printf("%s : handler returned an unexpected error : %+v", path, e)
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		}
+	}
+}
+
+// The main function
+func main() {
+	if indexFile, err := indexFS.Open("index.json"); err != nil {
+		log.Fatal("Failed to open index.json : " + err.Error())
+	} else {
+		defer indexFile.Close()
+		// we decode the jsonIndex
+		if err := json.NewDecoder(indexFile).Decode(&jsonIndex); err != nil {
+			log.Fatal("Failed to decode index.json : " + err.Error())
+		}
+
+		// then build the search index with normalized words
+		searchIndex = make([]SearchIndexRecord, len(jsonIndex))
+		for i := 0; i < len(jsonIndex); i++ {
+			searchIndex[i].Title = normalizeWords(strings.Fields(jsonIndex[i].Title))
+			searchIndex[i].Description = normalizeWords(strings.Fields(jsonIndex[i].Description))
+			searchIndex[i].Tags = normalizeWords(jsonIndex[i].Tags)
+			searchIndex[i].Content = normalizeWords(strings.Fields(jsonIndex[i].Content))
+			searchIndex[i].Permalink = jsonIndex[i].Permalink
+		}
+	}
+
+	http.Handle("/", handler{searchHandler})
+	log.Printf("Starting webui on %s", listenStr)
+	log.Fatal(http.ListenAndServe(listenStr, nil))
+}
diff --git a/search/search.html b/search/search.html
new file mode 100644
index 0000000..74041ab
--- /dev/null
+++ b/search/search.html
@@ -0,0 +1,15 @@
+{{ define "search" }}
+<form action="/search/" method="post">
+	<input class="fullwidth" type="text" placeholder="Enter your search terms here" name="query" value="{{ .Query }}" required><br>
+	<input type="checkbox" id="searchTitle" name="searchTitle" value="true"{{ if .SearchTitle }} checked{{ end }}><label for="searchTitle">Titles</label>
+	<input type="checkbox" id="searchTags" name="searchTags" value="true"{{ if .SearchTags }} checked{{ end }}><label for="searchTags">Tags</label>
+	<input type="checkbox" id="searchDescription" name="searchDescription" value="true"{{ if .SearchDescription }} checked{{ end }}><label for="searchDescription">Descriptions</label>
+	<input type="checkbox" id="searchContent" name="searchContent" value="true"{{ if .SearchContent }} checked{{ end }}><label for="searchContent">Contents</label>
+	<input type="submit" value="Search">
+</form>
+<ul>
+	{{ range .Results }}
+	<li><a href="{{ .Permalink }}">{{ .Title }}</a> : {{ .Description }}</li>
+	{{ end }}
+</ul>
+{{ end }}