293 lines
9.4 KiB
Go
293 lines
9.4 KiB
Go
package engines
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/url"
|
|
|
|
"encoding/json"
|
|
"regexp"
|
|
|
|
"github.com/PuerkitoBio/goquery"
|
|
)
|
|
|
|
type GoogleTranslate struct{}
|
|
|
|
func (_ *GoogleTranslate) DisplayName() string { return "Google Translate" }
|
|
|
|
func (_ *GoogleTranslate) getLangs(type_ string) (Language, error) {
|
|
var langsType string
|
|
switch type_ {
|
|
case "source":
|
|
langsType = "sl"
|
|
|
|
case "target":
|
|
langsType = "tl"
|
|
|
|
default:
|
|
return nil, fmt.Errorf("Invalid language type: %s", langsType)
|
|
}
|
|
|
|
requestURL, _ := url.Parse("https://translate.google.com/m")
|
|
|
|
query := url.Values{}
|
|
query.Add("mui", langsType)
|
|
query.Add("hl", "en-US")
|
|
requestURL.RawQuery = query.Encode()
|
|
|
|
response, err := http.Get(requestURL.String())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
defer response.Body.Close()
|
|
|
|
doc, err := goquery.NewDocumentFromReader(response.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var langs Language = make(Language)
|
|
|
|
doc.Find(".language-item").Each(func(_ int, s *goquery.Selection) {
|
|
a := s.Find("a").First()
|
|
|
|
href, exists := a.Attr("href")
|
|
if !exists {
|
|
return
|
|
}
|
|
|
|
langURL, err := url.Parse(href)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
langCode := langURL.Query()[langsType][0]
|
|
|
|
langs[langCode] = a.Text()
|
|
})
|
|
|
|
return langs, nil
|
|
}
|
|
|
|
func (e *GoogleTranslate) SourceLanguages() (Language, error) {
|
|
return e.getLangs("source")
|
|
}
|
|
|
|
func (e *GoogleTranslate) TargetLanguages() (Language, error) {
|
|
return e.getLangs("target")
|
|
}
|
|
|
|
func (e *GoogleTranslate) Tts(text, lang string) (string, error) {
|
|
requestURL, _ := url.Parse("https://translate.google.com/translate_tts")
|
|
|
|
query := url.Values{}
|
|
query.Add("tl", lang)
|
|
query.Add("q", text)
|
|
query.Add("client", "tw-ob")
|
|
requestURL.RawQuery = query.Encode()
|
|
|
|
return requestURL.String(), nil
|
|
}
|
|
|
|
func (_ *GoogleTranslate) Translate(text string, from, to string) (TranslationResult, error) {
|
|
requestURL, _ := url.Parse("https://translate.google.com/m")
|
|
|
|
if from == "" {
|
|
from = "auto"
|
|
}
|
|
|
|
query := url.Values{}
|
|
query.Add("sl", from)
|
|
query.Add("tl", to)
|
|
query.Add("hl", to)
|
|
query.Add("q", text)
|
|
requestURL.RawQuery = query.Encode()
|
|
|
|
response, err := http.Get(requestURL.String())
|
|
|
|
if err != nil {
|
|
return TranslationResult{}, err
|
|
}
|
|
|
|
defer response.Body.Close()
|
|
|
|
doc, err := goquery.NewDocumentFromReader(response.Body)
|
|
|
|
translatedText := doc.Find(".result-container").Text()
|
|
|
|
if err != nil {
|
|
return TranslationResult{}, err
|
|
}
|
|
|
|
url_ := "https://translate.google.com/_/TranslateWebserverUi/data/batchexecute?rpcids=MkEWBc&rt=c"
|
|
|
|
reqJSON := []interface{}{
|
|
[]interface{}{text, from, to, true},
|
|
[]interface{}{nil},
|
|
}
|
|
reqJSONString, err := json.Marshal(reqJSON)
|
|
if err != nil {
|
|
fmt.Println("Error:", err)
|
|
return TranslationResult{}, nil
|
|
}
|
|
|
|
req := []interface{}{[]interface{}{[]interface{}{"MkEWBc", string(reqJSONString), nil, "generic"}}}
|
|
|
|
JSONString, _ := json.Marshal(req)
|
|
|
|
body := "f.req=" + url.QueryEscape(string(JSONString))
|
|
|
|
resp, err := http.Post(url_, "application/x-www-form-urlencoded;charset=utf-8", bytes.NewBuffer([]byte(body)))
|
|
if err != nil {
|
|
fmt.Println("Error:", err)
|
|
return TranslationResult{}, nil
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
bodyBytes, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
fmt.Println("Error:", err)
|
|
return TranslationResult{}, nil
|
|
}
|
|
responseText := string(bodyBytes)
|
|
responseTextList := regexp.MustCompile(`\n\d+\n(.*)\n\d+\n`).FindStringSubmatch(responseText)
|
|
definitions := make(map[string][]map[string]interface{})
|
|
translations := make(map[string]map[string]map[string]interface{})
|
|
if len(responseTextList) > 0 {
|
|
responseText = responseTextList[1]
|
|
var raw []interface{}
|
|
err = json.Unmarshal([]byte(responseText), &raw)
|
|
if err != nil {
|
|
fmt.Println("Error:", err)
|
|
return TranslationResult{}, nil
|
|
}
|
|
|
|
if len(raw) > 0 && raw[0] != nil &&
|
|
len(raw[0].([]interface{})) > 2 && raw[0].([]interface{})[2] != nil {
|
|
data := raw[0].([]interface{})[2].(string)
|
|
|
|
var json_ []interface{}
|
|
err = json.Unmarshal([]byte(data), &json_)
|
|
|
|
if len(json_) > 3 && json_[3] != nil &&
|
|
len(json_[3].([]interface{})) > 1 && json_[3].([]interface{})[1] != nil &&
|
|
len(json_[3].([]interface{})[1].([]interface{})) > 0 && json_[3].([]interface{})[1].([]interface{})[0] != nil {
|
|
for x := 0; x < len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})); x++ {
|
|
if len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})) > 0 {
|
|
definitionType := json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[0]
|
|
if definitionType == nil {
|
|
definitionType = "unknown"
|
|
}
|
|
|
|
definitions[definitionType.(string)] = []map[string]interface{}{}
|
|
|
|
for i := 0; i < len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[1].([]interface{})); i++ {
|
|
definitionBox := json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[1].([]interface{})[i].([]interface{})
|
|
definitions[definitionType.(string)] = append(definitions[definitionType.(string)], map[string]interface{}{})
|
|
|
|
if len(definitionBox) > 4 && definitionBox[4] != nil &&
|
|
len(definitionBox[4].([]interface{})) > 0 && definitionBox[4].([]interface{})[0] != nil &&
|
|
len(definitionBox[4].([]interface{})[0].([]interface{})) > 0 && definitionBox[4].([]interface{})[0].([]interface{})[0] != nil {
|
|
definitions[definitionType.(string)][i]["dictionary"] = definitionBox[4].([]interface{})[0].([]interface{})[0]
|
|
}
|
|
|
|
if len(definitionBox) > 0 && definitionBox[0] != nil {
|
|
definitions[definitionType.(string)][i]["definition"] = definitionBox[0]
|
|
}
|
|
|
|
if len(definitionBox) > 1 && definitionBox[1] != nil {
|
|
definitions[definitionType.(string)][i]["use_in_sentence"] = definitionBox[1]
|
|
}
|
|
|
|
if len(definitionBox) > 5 && definitionBox[5] != nil {
|
|
definitions[definitionType.(string)][i]["synonyms"] = map[string][]string{}
|
|
synonyms := definitionBox[5].([]interface{})
|
|
synonymsMap := make(map[string][]string)
|
|
|
|
for _, synonymBox := range synonyms {
|
|
synonymType := ""
|
|
if len(synonymBox.([]interface{})) > 1 && synonymBox.([]interface{})[1] != nil &&
|
|
len(synonymBox.([]interface{})[1].([]interface{})) > 0 && synonymBox.([]interface{})[1].([]interface{})[0] != nil {
|
|
synonymType = synonymBox.([]interface{})[1].([]interface{})[0].([]interface{})[0].(string)
|
|
}
|
|
|
|
if len(synonymBox.([]interface{})) > 0 && synonymBox.([]interface{})[0] != nil {
|
|
synonymList := synonymBox.([]interface{})[0].([]interface{})
|
|
synonymsMap[synonymType] = []string{}
|
|
for _, synonymTypeWord := range synonymList {
|
|
synonymsMap[synonymType] = append(synonymsMap[synonymType], synonymTypeWord.([]interface{})[0].(string))
|
|
}
|
|
}
|
|
}
|
|
|
|
definitions[definitionType.(string)][i]["synonyms"] = synonymsMap
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(json_) > 3 && json_[3] != nil &&
|
|
len(json_[3].([]interface{})) > 5 && json_[3].([]interface{})[5] != nil &&
|
|
len(json_[3].([]interface{})[5].([]interface{})) > 0 && json_[3].([]interface{})[5].([]interface{})[0] != nil {
|
|
translationBox := json_[3].([]interface{})[5].([]interface{})[0].([]interface{})
|
|
for x := 0; x < len(translationBox); x++ {
|
|
if len(translationBox[x].([]interface{})) > 0 {
|
|
translationType := translationBox[x].([]interface{})[0]
|
|
if translationType == nil {
|
|
translationType = "unknown"
|
|
}
|
|
translations[translationType.(string)] = make(map[string]map[string]interface{})
|
|
|
|
if len(translationBox[x].([]interface{})) > 1 && translationBox[x].([]interface{})[1] != nil {
|
|
translationNamesBox := translationBox[x].([]interface{})[1].([]interface{})
|
|
for i := 0; i < len(translationNamesBox); i++ {
|
|
if len(translationNamesBox[i].([]interface{})) > 0 && translationNamesBox[i].([]interface{})[0] != nil {
|
|
translationName := translationNamesBox[i].([]interface{})[0].(string)
|
|
translations[translationType.(string)][translationName] = make(map[string]interface{})
|
|
if len(translationNamesBox[i].([]interface{})) > 3 && translationNamesBox[i].([]interface{})[3] != nil {
|
|
frequency := fmt.Sprintf("%d", int(translationNamesBox[i].([]interface{})[3].(float64)))
|
|
if frequency == "3" {
|
|
frequency = "1"
|
|
} else if frequency == "1" {
|
|
frequency = "3"
|
|
}
|
|
translations[translationType.(string)][translationName]["frequency"] = frequency + "/3"
|
|
|
|
translations[translationType.(string)][translationName]["words"] = []string{}
|
|
if len(translationNamesBox[i].([]interface{})) > 2 && translationNamesBox[i].([]interface{})[2] != nil {
|
|
for z := 0; z < len(translationNamesBox[i].([]interface{})[2].([]interface{})); z++ {
|
|
word := translationNamesBox[i].([]interface{})[2].([]interface{})[z].(string)
|
|
translations[translationType.(string)][translationName]["words"] = append(translations[translationType.(string)][translationName]["words"].([]string), word)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(json_) > 0 && json_[0] != nil && len(json_[0].([]interface{})) > 2 && json_[0].([]interface{})[2] != nil {
|
|
from = json_[0].([]interface{})[2].(string)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if from == "auto" {
|
|
from = ""
|
|
}
|
|
|
|
return TranslationResult{
|
|
SourceLanguage: from,
|
|
Definitions: definitions,
|
|
Translations: translations,
|
|
TranslatedText: translatedText,
|
|
}, nil
|
|
}
|