Changeset 21 in code for trunk


Ignore:
Timestamp:
Aug 31, 2023, 12:23:39 PM (22 months ago)
Author:
manerakai
Message:

Implemented Definitions and Translations for google

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/engines/engine.go

    r20 r21  
    22
    33type TranslationResult struct {
    4         SourceLanguage string `json:"source_language"`
    5         TranslatedText string `json:"translated_text"`
     4        SourceLanguage string      `json:"source_language"`
     5        Definitions    interface{} `json:"definitions"`
     6        Translations   interface{} `json:"translations"`
     7        TranslatedText string      `json:"translated_text"`
    68}
    79

  • trunk/engines/google.go

    r20 r21  
    22
    33import (
     4        "bytes"
    45        "fmt"
     6        "io/ioutil"
    57        "net/http"
    68        "net/url"
     9
     10        "encoding/json"
     11        "regexp"
    712
    813        "github.com/PuerkitoBio/goquery"
    … …  
    120125        }
    121126
     127        url_ := "https://translate.google.com/_/TranslateWebserverUi/data/batchexecute?rpcids=MkEWBc&rt=c"
     128
     129        reqJSON := []interface{}{
     130                []interface{}{text, from, to, true},
     131                []interface{}{nil},
     132        }
     133        reqJSONString, err := json.Marshal(reqJSON)
     134        if err != nil {
     135                fmt.Println("Error:", err)
     136                return TranslationResult{}, nil
     137        }
     138
     139        req := []interface{}{[]interface{}{[]interface{}{"MkEWBc", string(reqJSONString), nil, "generic"}}}
     140
     141        JSONString, _ := json.Marshal(req)
     142
     143        body := "f.req=" + url.QueryEscape(string(JSONString))
     144
     145        resp, err := http.Post(url_, "application/x-www-form-urlencoded;charset=utf-8", bytes.NewBuffer([]byte(body)))
     146        if err != nil {
     147                fmt.Println("Error:", err)
     148                return TranslationResult{}, nil
     149        }
     150        defer resp.Body.Close()
     151
     152        bodyBytes, err := ioutil.ReadAll(resp.Body)
     153        if err != nil {
     154                fmt.Println("Error:", err)
     155                return TranslationResult{}, nil
     156        }
     157        responseText := string(bodyBytes)
     158
     159        responseText = regexp.MustCompile(`\n\d+\n(.*)\n\d+\n`).FindStringSubmatch(responseText)[1]
     160
     161        var raw []interface{}
     162        err = json.Unmarshal([]byte(responseText), &raw)
     163        if err != nil {
     164                fmt.Println("Error:", err)
     165                return TranslationResult{}, nil
     166        }
     167
     168        data := raw[0].([]interface{})[2].(string)
     169
     170        var json_ []interface{}
     171        err = json.Unmarshal([]byte(data), &json_)
     172
     173        definitions := make(map[string][]map[string]interface{})
     174
     175        if len(json_) > 3 && json_[3] != nil &&
     176                len(json_[3].([]interface{})) > 1 && json_[3].([]interface{})[1] != nil &&
     177                len(json_[3].([]interface{})[1].([]interface{})) > 0 && json_[3].([]interface{})[1].([]interface{})[0] != nil {
     178                for x := 0; x < len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})); x++ {
     179                        if len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})) > 0 {
     180                                definitionType := json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[0]
     181                                if definitionType == nil {
     182                                        definitionType = "unknown"
     183                                }
     184
     185                                definitions[definitionType.(string)] = []map[string]interface{}{}
     186
     187                                for i := 0; i < len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[1].([]interface{})); i++ {
     188                                        definitionBox := json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[1].([]interface{})[i].([]interface{})
     189                                        definitions[definitionType.(string)] = append(definitions[definitionType.(string)], map[string]interface{}{})
     190
     191                                        if len(definitionBox) > 4 && definitionBox[4] != nil &&
     192                                                len(definitionBox[4].([]interface{})) > 0 && definitionBox[4].([]interface{})[0] != nil &&
     193                                                len(definitionBox[4].([]interface{})[0].([]interface{})) > 0 && definitionBox[4].([]interface{})[0].([]interface{})[0] != nil {
     194                                                definitions[definitionType.(string)][i]["dictionary"] = definitionBox[4].([]interface{})[0].([]interface{})[0]
     195                                        }
     196
     197                                        if len(definitionBox) > 0 && definitionBox[0] != nil {
     198                                                definitions[definitionType.(string)][i]["definition"] = definitionBox[0]
     199                                        }
     200
     201                                        if len(definitionBox) > 1 && definitionBox[1] != nil {
     202                                                definitions[definitionType.(string)][i]["use-in-sentence"] = definitionBox[1]
     203                                        }
     204
     205                                        if len(definitionBox) > 5 && definitionBox[5] != nil {
     206                                                definitions[definitionType.(string)][i]["synonyms"] = map[string][]string{}
     207                                                synonyms := definitionBox[5].([]interface{})
     208                                                synonymsMap := make(map[string][]string)
     209
     210                                                for _, synonymBox := range synonyms {
     211                                                        synonymType := ""
     212                                                        if len(synonymBox.([]interface{})) > 1 && synonymBox.([]interface{})[1] != nil &&
     213                                                                len(synonymBox.([]interface{})[1].([]interface{})) > 0 && synonymBox.([]interface{})[1].([]interface{})[0] != nil {
     214                                                                synonymType = synonymBox.([]interface{})[1].([]interface{})[0].([]interface{})[0].(string)
     215                                                        }
     216
     217                                                        if len(synonymBox.([]interface{})) > 0 && synonymBox.([]interface{})[0] != nil {
     218                                                                synonymList := synonymBox.([]interface{})[0].([]interface{})
     219                                                                synonymsMap[synonymType] = []string{}
     220                                                                for _, synonymTypeWord := range synonymList {
     221                                                                        synonymsMap[synonymType] = append(synonymsMap[synonymType], synonymTypeWord.([]interface{})[0].(string))
     222                                                                }
     223                                                        }
     224                                                }
     225
     226                                                definitions[definitionType.(string)][i]["synonyms"] = synonymsMap
     227                                        }
     228                                }
     229                        }
     230                }
     231        }
     232
     233        translations := make(map[string]map[string]map[string]interface{})
     234        if len(json_) > 3 && json_[3] != nil &&
     235                len(json_[3].([]interface{})) > 5 && json_[3].([]interface{})[5] != nil &&
     236                len(json_[3].([]interface{})[5].([]interface{})) > 0 && json_[3].([]interface{})[5].([]interface{})[0] != nil {
     237                translationBox := json_[3].([]interface{})[5].([]interface{})[0].([]interface{})
     238                for x := 0; x < len(translationBox); x++ {
     239                        if len(translationBox[x].([]interface{})) > 0 {
     240                                translationType := translationBox[x].([]interface{})[0]
     241                                if translationType == nil {
     242                                        translationType = "unknown"
     243                                }
     244                                translations[translationType.(string)] = make(map[string]map[string]interface{})
     245
     246                                if len(translationBox[x].([]interface{})) > 1 && translationBox[x].([]interface{})[1] != nil {
     247                                        translationNamesBox := translationBox[x].([]interface{})[1].([]interface{})
     248                                        for i := 0; i < len(translationNamesBox); i++ {
     249                                                if len(translationNamesBox[i].([]interface{})) > 0 && translationNamesBox[i].([]interface{})[0] != nil {
     250                                                        translationName := translationNamesBox[i].([]interface{})[0].(string)
     251                                                        translations[translationType.(string)][translationName] = make(map[string]interface{})
     252                                                        if len(translationNamesBox[i].([]interface{})) > 3 && translationNamesBox[i].([]interface{})[3] != nil {
     253                                                                frequency := fmt.Sprintf("%d", int(translationNamesBox[i].([]interface{})[3].(float64)))
     254                                                                if frequency == "3" {
     255                                                                        frequency = "1"
     256                                                                } else if frequency == "1" {
     257                                                                        frequency = "3"
     258                                                                }
     259                                                                translations[translationType.(string)][translationName]["frequency"] = frequency + "/3"
     260
     261                                                                translations[translationType.(string)][translationName]["words"] = []string{}
     262                                                                if len(translationNamesBox[i].([]interface{})) > 2 && translationNamesBox[i].([]interface{})[2] != nil {
     263                                                                        for z := 0; z < len(translationNamesBox[i].([]interface{})[2].([]interface{})); z++ {
     264                                                                                word := translationNamesBox[i].([]interface{})[2].([]interface{})[z].(string)
     265                                                                                translations[translationType.(string)][translationName]["words"] = append(translations[translationType.(string)][translationName]["words"].([]string), word)
     266                                                                        }
     267                                                                }
     268                                                        }
     269                                                }
     270                                        }
     271                                }
     272                        }
     273                }
     274        }
     275
    122276        return TranslationResult{
    123277                SourceLanguage: from,
     278                Definitions:    definitions,
     279                Translations:   translations,
    124280                TranslatedText: doc.Find(".result-container").Text(),
    125281        }, nil

  • trunk/web/static/LICENSE

    r16 r21  
    11favicon.ico, favicon.svg, favicon128x128.png
    2     Created by "joelchrono12" (https://https://joelchrono12.ml/)
    3     Creative Commons Attribution 4.0 International License (CC BY 4.0)
     2Created by "joelchrono12" (https://joelchrono12.ml/)
     3Creative Commons Attribution 4.0 International License (CC BY 4.0)
Note: See TracChangeset for help on using the changeset viewer.