/
DictLookupEngineGlosbe.go
120 lines (101 loc) · 3.51 KB
/
DictLookupEngineGlosbe.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package wordShuffler
import (
"fmt"
"strings"
"github.com/Jeffail/gabs"
)
const KeyLangFrom = "key_lang_from"
const KeyLangTo = "key_lang_to"
const defaultLang = "eng"
type DLGlosbe struct {
url string
}
func NewGlosbeEngine() *DLGlosbe {
m := new(DLGlosbe)
// https://glosbe.com/gapi/translate?from=eng&dest=eng&format=json&phrase=blowjob&pretty=true
m.url = "https://glosbe.com/gapi/translate?from=%v&dest=%v&format=json&phrase=%v&pretty=false"
return m
}
func (d *DLGlosbe) Source() string {
return "glosbe api"
}
func (d *DLGlosbe) Lookup(word string, optionalParams map[string]interface{}) ([]DictionaryLookupResult, error) {
finalUrl := ""
if IsWordValid(word) == false {
return nil, fmt.Errorf("the given word is INVALID, probably an empty string [%v]", word)
}
// apply parameters to the api
if optionalParams != nil {
// only accept map object (might panic though)
langFrom := "eng"
langTo := "eng"
if v:=optionalParams[KeyLangFrom]; v != nil {
lang := v.(string)
if len(strings.TrimSpace(lang)) > 0 {
langFrom = lang
}
}
if v:=optionalParams[KeyLangTo]; v != nil {
lang := v.(string)
if len(strings.TrimSpace(lang)) > 0 {
langTo = lang
}
}
finalUrl = fmt.Sprintf(d.url, langFrom, langTo, word)
} else {
finalUrl = fmt.Sprintf(d.url, defaultLang, defaultLang, word)
}
// make an http request to get back the results (through the api)
resultJsonByteArr, err := RunHttpRequest(finalUrl)
if err != nil {
return nil, err
}
explanationList, err := GetArrayFromJsonByPath(resultJsonByteArr, "tuc")
if err != nil {
// ** probably because there is no explanation (invalid word)
if strings.Compare(err.Error(), "not an object or array") == 0 {
return nil, nil
}
return nil, err
}
// prepare the final list
finalList, err := d.prepareDictionaryLookupResult(explanationList)
if err != nil {
return nil, err
}
// try catch block
defer func() {
if r := recover(); r != nil {
fmt.Printf("recovered => %v\n", r)
}
}()
return finalList, nil
}
// prepare / convert the given explanation list into []DictionaryLookupResult
func (d *DLGlosbe) prepareDictionaryLookupResult(list []*gabs.Container) ([]DictionaryLookupResult, error) {
if list == nil {
return nil, fmt.Errorf("no VALID result returned")
}
finalList := make([]DictionaryLookupResult, 0)
for _, result := range list {
meanings := result.Search("meanings")
if meanings == nil {
// some might not contain any explanations at all
continue
}
meaningsList, err := meanings.Children()
if err != nil {
return nil, fmt.Errorf("could not get the meanings")
}
for _, meaning := range meaningsList {
switch meaning.Data().(type) {
case map[string]interface{}:
vMap := meaning.Data().(map[string]interface{})
finalList = append(finalList, NewDictionaryLookupResult(vMap["text"].(string), vMap["language"].(string)))
default:
return nil, fmt.Errorf("non support type met [%v]", meaning.Data())
}
}
} // end -- for (iteration from the given list, not yet reached the "meaning" clause yet)
return finalList, nil
}