103 |
104 |
105 |
106 |
107 |
108 | {hadith.collection}
109 |
110 | {#if hadith.hadith_no}
111 |
114 | {hadith.hadith_no}
115 |
116 | {/if}
117 |
118 |
119 |
140 |
162 |
163 |
164 |
165 | {hadith.book_en}
166 | {#if hadith.book_no || hadith.book_ref_no}
167 | |
168 | B:{hadith.book_no} - H:{hadith.book_ref_no}
169 | {/if}
170 |
171 |
175 |
176 | {#if hadith.narrator_en}
177 |
178 | {hadith.narrator_en}
179 |
180 | {/if}
181 |
182 |
183 |
184 | {#each hadith.body_en.split(' ') as word}
185 | {#if hadith.highlights && hadith.highlights.includes(word.replace(/[.,/#!$%^&*;:{}=\-_`~()"']/g, ''))}
186 | {word}
190 | {:else}
191 | {word}
192 | {/if}
193 | {' '}
194 | {/each}
195 |
196 |
200 | {#if hadith.chapter_en}
201 |
Chapter: {hadith.chapter_en}
202 | {/if}
203 | {#if hadith.hadith_grade}
204 |
205 |
206 | {hadith.hadith_grade}
210 |
211 | {/if}
212 |
219 | Hadith copied!
220 |
221 | {/if}
222 |
223 |
--------------------------------------------------------------------------------
/api/search.go:
--------------------------------------------------------------------------------
1 | /*
2 | Package handler provides the HTTP handlers for the serverless API.
3 | This file contains the handler for the /search endpoint.
4 | */
5 | package handler
6 |
7 | import (
8 | "context"
9 | "encoding/base64"
10 | "encoding/json"
11 | "fmt"
12 | "net/http"
13 | "os"
14 | "regexp"
15 | "strconv"
16 | "strings"
17 | "time"
18 |
19 | lru "github.com/hashicorp/golang-lru"
20 | "go.mongodb.org/mongo-driver/bson"
21 | "go.mongodb.org/mongo-driver/mongo"
22 | "go.mongodb.org/mongo-driver/mongo/options"
23 | )
24 |
25 | const (
26 | pageSize = 500
27 | )
28 |
29 | var (
30 | mongoClient *mongo.Client
31 | cache *lru.Cache
32 |
33 | shortNames = []string{"bukhari", "abudawud", "nasai", "tirmidhi", "ibnmajah", "muslim"}
34 | simpleEnglishRegex = regexp.MustCompile(`^[a-zA-Z0-9\s]+$`)
35 | )
36 |
37 | // SearchHadith returns a list of hadiths that match the search query.
38 | func SearchHadith(w http.ResponseWriter, r *http.Request) {
39 | ctx := r.Context()
40 |
41 | query := r.URL.Query().Get("search")
42 | if reason, ok := validateQuery(query); !ok {
43 | sendBadRequestResp(w, reason)
44 | return
45 | }
46 | query = sanitizeQuery(query)
47 |
48 | cache, err := getCache()
49 | if err != nil {
50 | sendServerErrorResp(w, err)
51 | return
52 | }
53 |
54 | if val, ok := cache.Get(query); ok {
55 | fmt.Println("cache hit")
56 | sendResp(w, val)
57 | return
58 | }
59 |
60 | colResps, err := searchInMongo(ctx, query)
61 | if err != nil {
62 | sendServerErrorResp(w, err)
63 | return
64 | }
65 | searchResp := colRespToSearchResp(colResps)
66 |
67 | cache.Add(query, searchResp)
68 | fmt.Println("cache added")
69 |
70 | sendResp(w, searchResp)
71 | }
72 |
73 | func searchInMongo(ctx context.Context, query string) ([]CollectionResponse, error) {
74 | result := make([]CollectionResponse, 0)
75 |
76 | words := strings.Fields(query)
77 | if isSpecificHadith(words) {
78 | hadith, err := getHadith(ctx, strings.ToLower(words[0]), words[1])
79 | if err != nil {
80 | return result, err
81 | }
82 |
83 | cache.Add(query, hadith)
84 | result = append(result, hadith...)
85 | return result, nil
86 | }
87 |
88 | hadithGroups, err := compoundSearch(ctx, query)
89 | if err != nil {
90 | return result, err
91 | }
92 |
93 | for _, group := range hadithGroups {
94 | result = append(result, mongoResultToColResp(group))
95 | }
96 |
97 | cache.Add(query, result)
98 | return result, nil
99 | }
100 |
101 | func compoundSearch(ctx context.Context, query string) ([]MongoGroupByResult, error) {
102 | client, err := getMongoClient()
103 | if err != nil {
104 | return nil, err
105 | }
106 | collection := client.Database("hadith").Collection("hadiths")
107 |
108 | pipeline := pipelineQueryGroupByCollection(query)
109 | cursor, err := collection.Aggregate(ctx, pipeline)
110 | if err != nil {
111 | return nil, err
112 | }
113 |
114 | var results []MongoGroupByResult
115 | err = cursor.All(ctx, &results)
116 | if err != nil {
117 | return nil, err
118 | }
119 |
120 | return results, nil
121 | }
122 |
123 | func pipelineQueryGroupByCollection(query string) []bson.M {
124 | return []bson.M{
125 | {
126 | "$search": bson.M{
127 | "compound": bson.M{
128 | // "must": bson.A{
129 | // bson.M{
130 | // "text": bson.M{
131 | // "query": query,
132 | // "path": bson.A{"body_en", "chapter_en"},
133 | // "fuzzy": bson.M{"maxEdits": 1, "maxExpansions": 10},
134 | // },
135 | // },
136 | // },
137 | "should": bson.A{
138 | bson.M{
139 | "phrase": bson.M{
140 | "query": query,
141 | "path": bson.A{"body_en", "chapter_en"},
142 | "slop": 5,
143 | },
144 | },
145 | },
146 | },
147 | "highlight": bson.M{
148 | "path": bson.A{"body_en", "chapter_en"},
149 | },
150 | },
151 | },
152 | {
153 | "$group": bson.M{
154 | "_id": "$collection_id",
155 | "collection": bson.M{
156 | "$first": "$collection",
157 | },
158 | "count": bson.M{
159 | "$sum": 1,
160 | },
161 | "hadiths": bson.M{
162 | "$push": bson.M{
163 | "collection_id": "$collection_id",
164 | "collection": "$collection",
165 | "hadith_no": "$hadith_no",
166 | "book_no": "$book_no",
167 | "book_en": "$book_en",
168 | "chapter_no": "$chapter_no",
169 | "chapter_en": "$chapter_en",
170 | "narrator_en": "$narrator_en",
171 | "body_en": "$body_en",
172 | "book_ref_no": "$book_ref_no",
173 | "hadith_grade": "$hadith_grade",
174 | "score": bson.M{"$meta": "searchScore"},
175 | "highlights": bson.M{"$meta": "searchHighlights"},
176 | },
177 | },
178 | },
179 | },
180 | {
181 | "$limit": pageSize,
182 | },
183 | {
184 | "$sort": bson.M{
185 | "hadiths.score": -1,
186 | },
187 | },
188 | }
189 | }
190 |
191 | func getHadith(ctx context.Context, hadithName, hadithNo string) ([]CollectionResponse, error) {
192 | client, err := getMongoClient()
193 | if err != nil {
194 | return nil, err
195 | }
196 | collection := client.Database("hadith").Collection("hadiths")
197 |
198 | cursor, err := collection.Find(
199 | ctx,
200 | bson.M{
201 | "collection_id": hadithName,
202 | "hadith_no": bson.M{
203 | "$regex": hadithNo + ".*",
204 | "$options": "",
205 | },
206 | },
207 | )
208 | if err != nil {
209 | return nil, err
210 | }
211 |
212 | var results []MongoHadith
213 | err = cursor.All(ctx, &results)
214 | if err != nil {
215 | return nil, err
216 | }
217 |
218 | // usually there is only one hadith
219 | res := make([]CollectionResponse, 0)
220 | if len(results) == 0 {
221 | return res, nil
222 | }
223 |
224 | first := CollectionResponse{}
225 | first.GroupByResult = &GroupByResult{}
226 | first.ID = results[0].CollectionID
227 | first.Collection = results[0].Collection
228 | first.Count = 1
229 | first.Hadiths = make([]HadithResponse, 0)
230 | first.Hadiths = append(first.Hadiths, mongoHadithToResp(results[0]))
231 | res = append(res, first)
232 |
233 | return res, nil
234 | }
235 |
236 | func validateQuery(query string) (string, bool) {
237 | if len(query) < 3 {
238 | return "Query must be at least 3 characters", false
239 | }
240 |
241 | if !simpleEnglishRegex.MatchString(query) {
242 | return "Query must be in simple English and numbers", false
243 | }
244 |
245 | return "", true
246 | }
247 |
248 | func sanitizeQuery(query string) string {
249 | return strings.ToLower(strings.ReplaceAll(query, "'", ""))
250 | }
251 |
252 | func isSpecificHadith(words []string) bool {
253 | if len(words) == 2 &&
254 | contains(shortNames, words[0]) &&
255 | isNumber(words[1]) {
256 | return true
257 | }
258 | return false
259 | }
260 |
261 | func sendResp(w http.ResponseWriter, r interface{}) {
262 | w.Header().Set("Content-Type", "application/json")
263 | w.WriteHeader(http.StatusOK)
264 | json.NewEncoder(w).Encode(r)
265 | }
266 |
267 | func sendBadRequestResp(w http.ResponseWriter, reason string) {
268 | w.WriteHeader(http.StatusBadRequest)
269 | w.Write([]byte(reason))
270 | }
271 |
272 | func sendServerErrorResp(w http.ResponseWriter, err error) {
273 | w.WriteHeader(http.StatusInternalServerError)
274 | w.Write([]byte(err.Error()))
275 | }
276 |
277 | func getMongoClient() (*mongo.Client, error) {
278 | if mongoClient != nil {
279 | return mongoClient, nil
280 | }
281 |
282 | client, err := mongo.NewClient(options.Client().ApplyURI(os.Getenv("MONGO_URI")))
283 | if err != nil {
284 | return nil, err
285 | }
286 |
287 | ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
288 | defer cancel()
289 |
290 | err = client.Connect(ctx)
291 | if err != nil {
292 | return nil, err
293 | }
294 |
295 | mongoClient = client
296 | return mongoClient, nil
297 | }
298 |
299 | func getCache() (*lru.Cache, error) {
300 | if cache != nil {
301 | return cache, nil
302 | }
303 |
304 | c, err := lru.New(1000)
305 | if err != nil {
306 | return nil, err
307 | }
308 |
309 | cache = c
310 | return cache, nil
311 | }
312 |
313 | func contains(s []string, e string) bool {
314 | for _, a := range s {
315 | if a == e {
316 | return true
317 | }
318 | }
319 | return false
320 | }
321 |
322 | func isNumber(s string) bool {
323 | _, err := strconv.Atoi(s)
324 | return err == nil
325 | }
326 |
327 | type Hadith struct {
328 | CollectionID string `bson:"collection_id" json:"collection_id"`
329 | Collection string `bson:"collection" json:"collection"`
330 | HadithNo string `bson:"hadith_no" json:"hadith_no"`
331 | BookNo string `bson:"book_no" json:"book_no"`
332 | BookEn string `bson:"book_en" json:"book_en"`
333 | ChapterNo string `bson:"chapter_no" json:"chapter_no"`
334 | ChapterEn string `bson:"chapter_en" json:"chapter_en"`
335 | NarratorEn string `bson:"narrator_en" json:"narrator_en"`
336 | BodyEn string `bson:"body_en" json:"body_en"`
337 | BookRefNo string `bson:"book_ref_no" json:"book_ref_no"`
338 | HadithGrade string `bson:"hadith_grade" json:"hadith_grade"`
339 | Score float64 `bson:"score" json:"score"`
340 | }
341 |
342 | type MongoHadith struct {
343 | *Hadith `bson:",inline" json:",inline"`
344 | Highlights []MongoHighlight `bson:"highlights" json:"highlights"`
345 | }
346 |
347 | type HadithResponse struct {
348 | *Hadith `bson:",inline" json:",inline"`
349 | Highlights []string `json:"highlights"`
350 | }
351 |
352 | type MongoHighlight struct {
353 | Path string `bson:"path" json:"path"`
354 | Score float64 `bson:"score" json:"score"`
355 | Texts []MongoText `bson:"texts" json:"texts"`
356 | }
357 |
358 | type MongoText struct {
359 | Type string `bson:"type" json:"type"`
360 | Value string `bson:"value" json:"value"`
361 | }
362 |
363 | type GroupByResult struct {
364 | ID string `bson:"_id" json:"_id"`
365 | Count int `bson:"count" json:"count"`
366 | Collection string `bson:"collection" json:"collection"`
367 | }
368 |
369 | type MongoGroupByResult struct {
370 | *GroupByResult `bson:",inline" json:",inline"`
371 | Hadiths []MongoHadith `bson:"hadiths" json:"hadiths"`
372 | }
373 |
374 | type CollectionResponse struct {
375 | *GroupByResult `bson:",inline" json:",inline"`
376 | Hadiths []HadithResponse `bson:"hadiths" json:"hadiths"`
377 | }
378 |
379 | type SearchResponse struct {
380 | Data []CollectionResponse `json:"data"`
381 | FirstHadithBase64 string `json:"first_hadith_base64"`
382 | }
383 |
384 | func mongoHighlightToSimpleHighlight(highlight MongoHighlight) []string {
385 | var res []string
386 | for _, text := range highlight.Texts {
387 | if text.Type == "hit" {
388 | res = append(res, text.Value)
389 | }
390 | }
391 | return res
392 | }
393 |
394 | func mongoHadithToResp(hadith MongoHadith) HadithResponse {
395 | highlights := NewSet()
396 | for _, highlight := range hadith.Highlights {
397 | highlights.AddMulti(mongoHighlightToSimpleHighlight(highlight))
398 | }
399 | return HadithResponse{hadith.Hadith, highlights.ToSlice()}
400 | }
401 |
402 | func mongoResultToColResp(group MongoGroupByResult) CollectionResponse {
403 | var res []HadithResponse
404 | for i := range group.Hadiths {
405 | hadith := group.Hadiths[i]
406 | res = append(res, mongoHadithToResp(hadith))
407 | }
408 | return CollectionResponse{group.GroupByResult, res}
409 | }
410 |
411 | func colRespToSearchResp(colResps []CollectionResponse) SearchResponse {
412 | var firstHadithBase64 string
413 | if len(colResps) > 0 && len(colResps[0].Hadiths) > 0 {
414 | firstHadithBase64 = hadithToBase64(colResps[0].Hadiths[0])
415 | }
416 | return SearchResponse{colResps, firstHadithBase64}
417 | }
418 |
419 | func hadithToBase64(hadith HadithResponse) string {
420 | bytes, err := json.Marshal(hadith)
421 | if err != nil {
422 | return ""
423 | }
424 | return base64.URLEncoding.EncodeToString(bytes)
425 | }
426 |
427 | type Set map[string]struct{}
428 |
429 | func NewSet() Set {
430 | return make(map[string]struct{})
431 | }
432 |
433 | func (s Set) Add(v string) {
434 | s[v] = struct{}{}
435 | }
436 |
437 | func (s Set) AddMulti(v []string) {
438 | for _, vv := range v {
439 | s.Add(vv)
440 | }
441 | }
442 |
443 | func (s Set) ToSlice() []string {
444 | var result []string
445 | for k := range s {
446 | result = append(result, k)
447 | }
448 | return result
449 | }
450 |
--------------------------------------------------------------------------------
12 | 
15 |