Changeset 23 in code for trunk


Ignore:
Timestamp:
Sep 2, 2023, 12:15:30 PM (21 months ago)
Author:
manerakai
Message:

Improved code

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/engines/engine.go

    r21 r23  
    99
    1010type Engine interface {
    11         InternalName() string
    1211        DisplayName() string
    1312        SourceLanguages() (Language, error)
    1413        TargetLanguages() (Language, error)
    1514        Translate(text string, from, to string) (TranslationResult, error)
    16         DetectLanguage(text string) (string, error)
    1715        Tts(text, lang string) (string, error)
    1816}
    … …  
    2220var Engines = map[string]Engine{
    2321        "google": &GoogleTranslate{},
    24         // "icibia":   &ICIBA{},
     22        // "icibia": &ICIBA{},
    2523        // "libre":    &LibreTranslate{},
    2624        "reverseo": &Reverso{},

  • trunk/engines/google.go

    r22 r23  
    1616type GoogleTranslate struct{}
    1717
    18 func (_ *GoogleTranslate) InternalName() string { return "google" }
    19 
    2018func (_ *GoogleTranslate) DisplayName() string { return "Google" }
    2119
    … …  
    3028
    3129        default:
    32                 panic(fmt.Errorf("getLangs was passed an invalid language type: %s", langsType))
     30                return nil, fmt.Errorf("Invalid language type: %s", langsType)
    3331        }
    3432
    … …  
    9492        return requestURL.String(), nil
    9593}
    96 
    97 func (_ *GoogleTranslate) DetectLanguage(text string) (string, error) { return "", nil }
    9894
    9995func (_ *GoogleTranslate) Translate(text string, from, to string) (TranslationResult, error) {
    … …  
    276272                        }
    277273                }
     274
     275                if len(json_) > 0 && json_[0] != nil && len(json_[0].([]interface{})) > 2 && json_[0].([]interface{})[2] != nil {
     276                        from = json_[0].([]interface{})[2].(string)
     277                }
    278278        }
    279279

  • trunk/engines/iciba.go

    r20 r23  
    1212// ICIBA is an engine that fetches data from https://www.iciba.com.
    1313type ICIBA struct{}
    14 
    15 func (_ *ICIBA) InternalName() string { return "iciba" }
    1614
    1715func (_ *ICIBA) DisplayName() string { return "iCIBA" }
    … …  
    216214func (_ *ICIBA) TargetLanguages() (Language, error) { return icibaLanguages, nil }
    217215
    218 func (_ *ICIBA) DetectLanguage(text string) (string, error) { return "", nil }
    219 
    220 type icibaTranslateResponse struct {
    221         Content struct {
    222                 From string `json:"from"`
    223                 Out  string `json:"out"`
    224         } `json:"content"`
    225 }
    226 
    227216func (_ *ICIBA) Translate(text string, from, to string) (TranslationResult, error) {
    228217        requestURL, _ := url.Parse("https://ifanyi.iciba.com/index.php")
    … …  
    255244        }
    256245
    257         var responseJSON icibaTranslateResponse
     246        var responseJSON struct {
     247                Content struct {
     248                        From string `json:"from"`
     249                        Out  string `json:"out"`
     250                } `json:"content"`
     251        }
    258252
    259253        if err := json.NewDecoder(response.Body).Decode(&responseJSON); err != nil {

  • trunk/engines/libretranslate.go

    r20 r23  
    2323        APIKey string
    2424}
    25 
    26 func (_ *LibreTranslate) InternalName() string { return "libre" }
    2725
    2826func (_ *LibreTranslate) DisplayName() string { return "LibreTranslate" }
    … …  
    7169}
    7270
    73 func (e *LibreTranslate) DetectLanguage(text string) (string, error) {
     71func (e *LibreTranslate) detectLanguage(text string) (string, error) {
    7472        formData := map[string]string{"q": text}
    7573
    … …  
    125123}
    126124
    127 type libreTranslateResponse struct {
    128         TranslatedText string `json:"translatedText"`
    129 }
    130 
    131125func (e *LibreTranslate) Translate(text string, from, to string) (TranslationResult, error) {
    132126        formData := map[string]string{
    … …  
    158152        }
    159153
    160         var responseJSON libreTranslateResponse
     154        var responseJSON struct {
     155                TranslatedText string `json:"translatedText"`
     156        }
    161157
    162158        if err := json.NewDecoder(response.Body).Decode(&responseJSON); err != nil {
    … …  
    164160        }
    165161
    166         return TranslationResult{TranslatedText: responseJSON.TranslatedText}, nil
     162        if r, err := e.detectLanguage(text); err == nil {
     163                from = r
     164        }
     165
     166        return TranslationResult{
     167                TranslatedText: responseJSON.TranslatedText,
     168                SourceLanguage: from,
     169        }, nil
    167170}

  • trunk/engines/reverso.go

    r20 r23  
    1010// Reverso is an engine that fetches data from https://reverso.net.
    1111type Reverso struct{}
    12 
    13 func (_ *Reverso) InternalName() string { return "reverso" }
    1412
    1513func (_ *Reverso) DisplayName() string { return "Reverso" }
    … …  
    8482
    8583        request.Header.Set("Content-Type", "application/json")
    86         // Returns 403 with empty or no user agent.
    8784        request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; rv:110.0) Gecko/20100101 Firefox/110.0")
    8885
    … …  
    110107}
    111108
    112 func (e *Reverso) DetectLanguage(text string) (string, error) {
    113         // Any language pair works here, does not affect result
    114         r, err := e.callAPI(text, "ara", "chi")
    115 
    116         if err != nil {
    117                 return "", err
     109func (e *Reverso) Translate(text string, from, to string) (TranslationResult, error) {
     110        if from == "auto" || from == "" {
     111                from = "eng"
    118112        }
    119113
     114        var translation string
     115
     116        r, err := e.callAPI(text, from, to)
     117        if err != nil {
     118                return TranslationResult{}, err
     119        }
     120
     121        translation = r.Translation[0]
    120122        langCode := r.LanguageDetection.DetectedLanguage
    121123
    122124        for code := range reversoLangs {
    123125                if code == langCode {
    124                         return code, nil
     126                        from = code
    125127                }
    126         }
    127 
    128         return "", fmt.Errorf("language code \"%s\" is not in Reverso's language list", langCode)
    129 }
    130 
    131 func (e *Reverso) Translate(text string, from, to string) (TranslationResult, error) {
    132         if from == "auto" {
    133                 from_, err := e.DetectLanguage(text)
    134 
    135                 if err != nil {
    136                         return TranslationResult{}, err
    137                 }
    138 
    139                 from = from_
    140         }
    141 
    142         var translation string
    143 
    144         if from == to {
    145                 translation = text
    146         } else {
    147                 r, err := e.callAPI(text, from, to)
    148 
    149                 if err != nil {
    150                         return TranslationResult{}, err
    151                 }
    152 
    153                 translation = r.Translation[0]
    154128        }
    155129
    156130        return TranslationResult{
    157131                TranslatedText: translation,
     132                SourceLanguage: from,
    158133        }, nil
    159134}

  • trunk/web/main.go

    r22 r23  
    2121
    2222        app.All("/", func(c *fiber.Ctx) error {
    23                 engine := c.Query("engine")
    24                 if _, ok := engines.Engines[engine]; !ok || engine == "" {
     23                engine := c.Cookies("engine")
     24                if c.Query("engine") != "" {
     25                        engine = c.Query("engine")
     26                }
     27                if _, ok := engines.Engines[engine]; !ok {
    2528                        engine = "google"
    2629                }
    … …  
    5053                                translatedText = result.TranslatedText
    5154                                translation = result
     55                                from = result.SourceLanguage
    5256                        }
    5357
    … …  
    6973                        fromCookie.Name = "from"
    7074                        fromCookie.Value = from
    71                         fromCookie.Expires = time.Now().Add(24 * time.Hour * 365)
     75                        fromCookie.Expires = time.Now().Add(time.Hour * 24 * 365)
    7276                        c.Cookie(fromCookie)
    7377
    … …  
    7579                        toCookie.Name = "to"
    7680                        toCookie.Value = to
    77                         toCookie.Expires = time.Now().Add(24 * time.Hour * 365)
     81                        toCookie.Expires = time.Now().Add(time.Hour * 24 * 365)
    7882                        c.Cookie(toCookie)
    7983
     84                        engineCookie := new(fiber.Cookie)
     85                        engineCookie.Name = "engine"
     86                        engineCookie.Value = engine
     87                        engineCookie.Expires = time.Now().Add(time.Hour * 24 * 365)
     88                        c.Cookie(engineCookie)
    8089                } else if c.Method() == "GET" {
    8190                        from = c.Cookies("from")
    … …  
    185194                        }
    186195                }
    187 
    188196        })
    189197
Note: See TracChangeset for help on using the changeset viewer.