Changeset 22 in code for trunk


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

Implemented Definitions and Translations in Web interface

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/engines/google.go

    r21 r22  
    121121        doc, err := goquery.NewDocumentFromReader(response.Body)
    122122
     123        translatedText := doc.Find(".result-container").Text()
     124
    123125        if err != nil {
    124126                return TranslationResult{}, err
    … …  
    165167                return TranslationResult{}, nil
    166168        }
    167 
    168         data := raw[0].([]interface{})[2].(string)
    169 
    170         var json_ []interface{}
    171         err = json.Unmarshal([]byte(data), &json_)
    172 
    173169        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))
     170        translations := make(map[string]map[string]map[string]interface{})
     171
     172        if len(raw) > 0 && raw[0] != nil &&
     173                len(raw[0].([]interface{})) > 2 && raw[0].([]interface{})[2] != nil {
     174                data := raw[0].([]interface{})[2].(string)
     175
     176                var json_ []interface{}
     177                err = json.Unmarshal([]byte(data), &json_)
     178
     179                if len(json_) > 3 && json_[3] != nil &&
     180                        len(json_[3].([]interface{})) > 1 && json_[3].([]interface{})[1] != nil &&
     181                        len(json_[3].([]interface{})[1].([]interface{})) > 0 && json_[3].([]interface{})[1].([]interface{})[0] != nil {
     182                        for x := 0; x < len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})); x++ {
     183                                if len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})) > 0 {
     184                                        definitionType := json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[0]
     185                                        if definitionType == nil {
     186                                                definitionType = "unknown"
     187                                        }
     188
     189                                        definitions[definitionType.(string)] = []map[string]interface{}{}
     190
     191                                        for i := 0; i < len(json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[1].([]interface{})); i++ {
     192                                                definitionBox := json_[3].([]interface{})[1].([]interface{})[0].([]interface{})[x].([]interface{})[1].([]interface{})[i].([]interface{})
     193                                                definitions[definitionType.(string)] = append(definitions[definitionType.(string)], map[string]interface{}{})
     194
     195                                                if len(definitionBox) > 4 && definitionBox[4] != nil &&
     196                                                        len(definitionBox[4].([]interface{})) > 0 && definitionBox[4].([]interface{})[0] != nil &&
     197                                                        len(definitionBox[4].([]interface{})[0].([]interface{})) > 0 && definitionBox[4].([]interface{})[0].([]interface{})[0] != nil {
     198                                                        definitions[definitionType.(string)][i]["dictionary"] = definitionBox[4].([]interface{})[0].([]interface{})[0]
     199                                                }
     200
     201                                                if len(definitionBox) > 0 && definitionBox[0] != nil {
     202                                                        definitions[definitionType.(string)][i]["definition"] = definitionBox[0]
     203                                                }
     204
     205                                                if len(definitionBox) > 1 && definitionBox[1] != nil {
     206                                                        definitions[definitionType.(string)][i]["use_in_sentence"] = definitionBox[1]
     207                                                }
     208
     209                                                if len(definitionBox) > 5 && definitionBox[5] != nil {
     210                                                        definitions[definitionType.(string)][i]["synonyms"] = map[string][]string{}
     211                                                        synonyms := definitionBox[5].([]interface{})
     212                                                        synonymsMap := make(map[string][]string)
     213
     214                                                        for _, synonymBox := range synonyms {
     215                                                                synonymType := ""
     216                                                                if len(synonymBox.([]interface{})) > 1 && synonymBox.([]interface{})[1] != nil &&
     217                                                                        len(synonymBox.([]interface{})[1].([]interface{})) > 0 && synonymBox.([]interface{})[1].([]interface{})[0] != nil {
     218                                                                        synonymType = synonymBox.([]interface{})[1].([]interface{})[0].([]interface{})[0].(string)
     219                                                                }
     220
     221                                                                if len(synonymBox.([]interface{})) > 0 && synonymBox.([]interface{})[0] != nil {
     222                                                                        synonymList := synonymBox.([]interface{})[0].([]interface{})
     223                                                                        synonymsMap[synonymType] = []string{}
     224                                                                        for _, synonymTypeWord := range synonymList {
     225                                                                                synonymsMap[synonymType] = append(synonymsMap[synonymType], synonymTypeWord.([]interface{})[0].(string))
     226                                                                        }
    222227                                                                }
    223228                                                        }
    224                                                 }
    225 
    226                                                 definitions[definitionType.(string)][i]["synonyms"] = synonymsMap
     229
     230                                                        definitions[definitionType.(string)][i]["synonyms"] = synonymsMap
     231                                                }
    227232                                        }
    228233                                }
    229234                        }
    230235                }
    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)
     236
     237                if len(json_) > 3 && json_[3] != nil &&
     238                        len(json_[3].([]interface{})) > 5 && json_[3].([]interface{})[5] != nil &&
     239                        len(json_[3].([]interface{})[5].([]interface{})) > 0 && json_[3].([]interface{})[5].([]interface{})[0] != nil {
     240                        translationBox := json_[3].([]interface{})[5].([]interface{})[0].([]interface{})
     241                        for x := 0; x < len(translationBox); x++ {
     242                                if len(translationBox[x].([]interface{})) > 0 {
     243                                        translationType := translationBox[x].([]interface{})[0]
     244                                        if translationType == nil {
     245                                                translationType = "unknown"
     246                                        }
     247                                        translations[translationType.(string)] = make(map[string]map[string]interface{})
     248
     249                                        if len(translationBox[x].([]interface{})) > 1 && translationBox[x].([]interface{})[1] != nil {
     250                                                translationNamesBox := translationBox[x].([]interface{})[1].([]interface{})
     251                                                for i := 0; i < len(translationNamesBox); i++ {
     252                                                        if len(translationNamesBox[i].([]interface{})) > 0 && translationNamesBox[i].([]interface{})[0] != nil {
     253                                                                translationName := translationNamesBox[i].([]interface{})[0].(string)
     254                                                                translations[translationType.(string)][translationName] = make(map[string]interface{})
     255                                                                if len(translationNamesBox[i].([]interface{})) > 3 && translationNamesBox[i].([]interface{})[3] != nil {
     256                                                                        frequency := fmt.Sprintf("%d", int(translationNamesBox[i].([]interface{})[3].(float64)))
     257                                                                        if frequency == "3" {
     258                                                                                frequency = "1"
     259                                                                        } else if frequency == "1" {
     260                                                                                frequency = "3"
     261                                                                        }
     262                                                                        translations[translationType.(string)][translationName]["frequency"] = frequency + "/3"
     263
     264                                                                        translations[translationType.(string)][translationName]["words"] = []string{}
     265                                                                        if len(translationNamesBox[i].([]interface{})) > 2 && translationNamesBox[i].([]interface{})[2] != nil {
     266                                                                                for z := 0; z < len(translationNamesBox[i].([]interface{})[2].([]interface{})); z++ {
     267                                                                                        word := translationNamesBox[i].([]interface{})[2].([]interface{})[z].(string)
     268                                                                                        translations[translationType.(string)][translationName]["words"] = append(translations[translationType.(string)][translationName]["words"].([]string), word)
     269                                                                                }
    266270                                                                        }
    267271                                                                }
    … …  
    278282                Definitions:    definitions,
    279283                Translations:   translations,
    280                 TranslatedText: doc.Find(".result-container").Text(),
     284                TranslatedText: translatedText,
    281285        }, nil
    282286}

  • trunk/web/main.go

    r20 r22  
    4040                ttsTo := ""
    4141
     42                var translation engines.TranslationResult
    4243                if c.Method() == "POST" {
    4344                        from = c.FormValue("from")
    … …  
    4849                        } else {
    4950                                translatedText = result.TranslatedText
     51                                translation = result
    5052                        }
    5153
    … …  
    9496                        "TargetLanguages": targetLanguages,
    9597                        "OriginalText":    originalText,
    96                         "TranslatedText":  translatedText,
     98                        "Translation":     translation,
    9799                        "From":            from,
    98100                        "To":              to,

  • trunk/web/views/index.html

    r20 r22  
    6767            <div class="item-wrapper">
    6868                <textarea id="output" class="translation item" dir="auto" placeholder="Translation"
    69                     readonly>{{.TranslatedText}}</textarea>
     69                    readonly>{{.Translation.TranslatedText}}</textarea>
    7070                {{if .TtsTo}}
    7171                <audio controls>
    … …  
    8282        </div>
    8383
     84        <br>
     85
     86        <div id="definitions_and_translations">
     87            {{ if .Translation.Definitions }}
     88            <div class="definitions">
     89                {{ range $type, $definitions :=.Translation.Definitions }}
     90                <span class="def_type">{{ $type }}</span>
     91                <ol>
     92                    {{ range $definition_item := $definitions }}
     93                    <li>
     94                        {{ $definition_item.definition }}
     95                        <br>
     96                        {{with $definition_item.use_in_sentence}}
     97                        <span class="use_in_sentence">"{{$definition_item.use_in_sentence}}"</span>
     98                        <br>
     99                        {{end}}
     100                        {{with $definition_item.synonyms}}
     101                        {{ range $synonym_type, $_ := $definition_item.synonyms }}
     102                        <span class="syn">
     103                            {{if $synonym_type }}
     104                            <br>
     105                            <span class="syn_type">{{$synonym_type}}: </span>{{end}}{{ range $index, $element := index
     106                            $definition_item.synonyms $synonym_type}}{{if $index}}, {{end}}{{$element}}{{end}}
     107                        </span>
     108                        {{end}}
     109                        {{end}}
     110                    </li>
     111                    {{end}}
     112                </ol>
     113                {{end}}
     114            </div>
     115            {{ end}}
     116
     117            {{ if .Translation.Translations }}
     118            <div class="translations">
     119                {{ range $def_type, $translations := .Translation.Translations }}
     120                <span class="def_type">{{ $def_type }}</span>
     121                <ul>
     122                    {{ range $word, $word_translations := $translations }}
     123                    <li>
     124                        <span class="syn_type">{{$word}}:</span>                       
     125                        <span class="syn">{{ range $index, $element := $word_translations.words}}{{if $index}}, {{end}}{{$element}}{{end}}</span>
     126                        <span class="syn_type">{{$word_translations.frequency}}</span>
     127                    </li>
     128                    <br>
     129                    {{end}}
     130                </ul>
     131                {{end}}
     132            </div>
     133            {{end}}
     134        </div>
     135
    84136    </form>
    85137    <script src="/static/script.js"></script>
Note: See TracChangeset for help on using the changeset viewer.