func getLanguage(w http.ResponseWriter, r *http.Request) string { var preferred []language.Tag var err error save := false r.ParseForm() lang := r.Form.Get("lang") if lang != "" { preferred, _, err = language.ParseAcceptLanguage(lang) if err != nil { // log err } else { save = true } } if preferred == nil { cookie, err := r.Cookie("lang") if err == nil { preferred, _, err = language.ParseAcceptLanguage(cookie.Value) if err != nil { // log err } } } if preferred == nil { preferred, _, err = language.ParseAcceptLanguage(r.Header.Get("Accept-Language")) if err != nil { // log err } } matcher := language.NewMatcher([]language.Tag{ language.English, language.Italian, language.French, }) code, _, _ := matcher.Match(preferred...) base, _ := code.Base() if save { now := time.Now() expires := now.AddDate(1, 0, 0) http.SetCookie(w, &http.Cookie{ Name: "lang", Value: base.String(), Path: "/", Expires: expires, }) } return base.String() }
func localeFromRequest(request prago.Request) string { acceptHeader := request.Request().Header.Get("Accept-Language") t, _, _ := language.ParseAcceptLanguage(acceptHeader) tag, _, _ := languageMatcher.Match(t...) return tag.String() }
//SearchMessage parse Accept-Language header ,selects most-weighted(biggest q) //language ,reads the associated message file, and creates and returns message obj. func SearchMessage(acceptLanguage, filedir string) Message { const defaultLanguage = "en" // Language code (see RFC3066) var lang []string if strings.HasPrefix(acceptLanguage, "ja-") { acceptLanguage = "ja" } if acceptLanguage != "" { tags, _, err := language.ParseAcceptLanguage(acceptLanguage) if err != nil { log.Println(err) } else { for _, tag := range tags { lang = append(lang, tag.String()) } } } lang = append(lang, defaultLanguage) for _, l := range lang { slang := strings.Split(l, "-")[0] for _, j := range []string{l, slang} { if m, err := newMessage(filedir, "message-"+j+".txt"); err == nil { return m } } } log.Fatalf("no messages are found.") return nil }
//export preferredLanguageFromUseCString func preferredLanguageFromUseCString(cHttpAcceptLanguage *C.char) *C.char { httpAcceptLanguage := C.GoString(cHttpAcceptLanguage) tag, _, _ := language.ParseAcceptLanguage(httpAcceptLanguage) t, _, _ := mather.Match(tag...) return C.CString(t.String()) }
//export preferredLanguageFrom func preferredLanguageFrom(httpAcceptLanguage *string) *string { tag, _, _ := language.ParseAcceptLanguage(*httpAcceptLanguage) t, _, _ := mather.Match(tag...) l := t.String() return &l }
func ExampleParseAcceptLanguage() { // Tags are reordered based on their q rating. A missing q value means 1.0. fmt.Println(language.ParseAcceptLanguage(" nn;q=0.3, en-gb;q=0.8, en,")) m := language.NewMatcher([]language.Tag{language.Norwegian, language.Make("en-AU")}) t, _, _ := language.ParseAcceptLanguage("da, en-gb;q=0.8, en;q=0.7") fmt.Println(m.Match(t...)) // Danish is pretty close to Norwegian. t, _, _ = language.ParseAcceptLanguage(" da, nl") fmt.Println(m.Match(t...)) // Output: // [en en-GB nn] [1 0.8 0.3] <nil> // en-AU 1 High // no 0 High }
func parseAcceptLanguage(header string) string { tags, _, err := language.ParseAcceptLanguage(header) if err != nil { return "" } // Using the first Tag as Tags are sorted by highest weight first return tags[0].String() }
// Guess is kami middleware that examines Accept-Language and sets // the greeting to a better one if possible. func Guess(ctx context.Context, w http.ResponseWriter, r *http.Request) context.Context { if tag, _, err := language.ParseAcceptLanguage(r.Header.Get("Accept-Language")); err == nil { for _, t := range tag { if g, ok := greetings[t]; ok { ctx = WithContext(ctx, g) return ctx } } } return ctx }
// parse the locale based on Accept-Language header. If no header found or the values are invalid, // we fall back to en-US func (r *Request) parseLocale() { tags, _, err := language.ParseAcceptLanguage(r.Header.Get("Accept-Language")) if err != nil { logging.Warning("Could not parse accept lang header: %s", err) return } if len(tags) > 0 { logging.Debug("Locale for request: %s", tags[0]) r.Locale = tags[0].String() } }
func GetAcceptLanguageResponse(r *http.Request, mr *MainResponse) { httpAcceptLanguageHeader := strings.Join(r.Header["Accept-Language"], ",") languageTags, _, _ := language.ParseAcceptLanguage(httpAcceptLanguageHeader) languages := make([]string, len(languageTags)) for i := 0; i < len(languages); i++ { code := languageTags[i].String() languages[i] = code } mr.AcceptedLanguages = languages }
// CleanAcceptLanguage parses, cleans and returns the contents of a Accept-Language header. // If an error is encountered, the returned string is the same as given. func CleanAcceptLanguage(s string) (string, error) { tt, q, err := language.ParseAcceptLanguage(s) if err != nil { return s, err } s = "" for i := 0; i < len(tt); i++ { if i > 0 { s += "," } s += fmt.Sprintf("%s;q=%g", tt[i].String(), q[i]) } return s, nil }
// Detect Language from accept-language func DetectLanguage(ctx context.Context, w http.ResponseWriter, r *http.Request) context.Context { lang := "" if tags, _, err := language.ParseAcceptLanguage(r.Header.Get("Accept-Language")); err == nil { if len(tags) > 0 { t := tags[0] base, _, _ := t.Raw() // base, sscript, region if base == japaneseBase { lang = "ja-JP" } else if t == language.AmericanEnglish { lang = "en-US" } } } ctx = LangWithContext(lang, ctx) return ctx }
func (self *Installer) HandleInstallerGet(wr http.ResponseWriter, r *http.Request) { if !self.hasTranslations { t, _, _ := language.ParseAcceptLanguage(r.Header.Get("Accept-Language")) locale := "" if len(t) > 0 { locale = t[0].String() } InitI18n(locale, filepath.Join("contrib", "translations")) self.hasTranslations = true } if self.currentNode == nil { wr.WriteHeader(404) } else { m := self.currentNode.model(self.currentNode, self.currentErr, self.config) template.writeTemplate(self.currentNode.templateName, m, wr) } }
// PopulateTransactionLanguage populates transaction Language fields from request Accept-Language field, // choosing most-scored (q-ed) language base. // // WARNING: this method is NOT THREAD-SAFE, so shouldn't be called from unsynchronized threads // (transaction shouldn't be accessed/modified by other threads, while this method is running) func (engine *Engine) PopulateTransactionLanguage(transaction *Transaction) { if transaction.AcceptLanguage == "" { return } tags, _, err := language.ParseAcceptLanguage(transaction.AcceptLanguage) if err != nil { transaction.RegisterErrorMessage(fmt.Sprintf("Engine.PopulateTransactionLanguage(): language.ParseAcceptLanguage(): %v", err)) return } if len(tags) <= 0 { return } base, _ := tags[0].Base() transaction.LanguageCode = base.String() }
func (handler *LocaleHandler) determineLocalizedDir(locale string) string { tags, _, err := language.ParseAcceptLanguage(locale) if (err != nil) || (len(tags) == 0) { return defaultDir } for _, tag := range tags { matchedLocale := "" for _, l := range handler.SupportedLocales { base, _ := tag.Base() if l == base.String() { matchedLocale = l break } } localeDir := "./public/" + matchedLocale if matchedLocale != "" && handler.dirExists(localeDir) { return localeDir } } return defaultDir }
// handler is a http.HandlerFunc. func handler(w http.ResponseWriter, r *http.Request) { t, q, err := language.ParseAcceptLanguage(r.Header.Get("Accept-Language")) // We ignore the error: the default language will be selected for t == nil. tag, _, _ := matcher.Match(t...) fmt.Printf("%5v (t: %6v; q: %3v; err: %v)\n", tag, t, q, err) }
func Language(req *http.Request) language.Tag { tags, _, _ := language.ParseAcceptLanguage(req.Header.Get("Accept-Language")) tag, _, _ := SupportedLanguageMatcher.Match(tags...) return tag }
// MatchString parses string s and matches the first of the given tags to reach a certain confidence threshold with an available locale. // The string can be a single language tag or a list of language tags with preference values (from the Accept-Language header, for example). func MatchString(s string) (language.Tag, language.Confidence) { pref, _, _ := language.ParseAcceptLanguage(s) return Match(pref...) }