// Translate one or more strings of text from a source language to a target
// language. All inputs must be in the same language.
//
// The target parameter supplies the language to translate to. The supported
// languages are listed at
// https://cloud.google.com/translate/v2/translate-reference#supported_languages.
// You can also call the SupportedLanguages method.
//
// The returned Translations appear in the same order as the inputs.
func (c *Client) Translate(ctx context.Context, inputs []string, target language.Tag, opts *Options) ([]Translation, error) {
call := c.raw.Translations.List(inputs, target.String()).Context(ctx)
if opts != nil {
if s := opts.Source; s != language.Und {
call.Source(s.String())
}
if f := opts.Format; f != "" {
call.Format(string(f))
}
if m := opts.Model; m != "" {
call.Model(m)
}
}
res, err := call.Do()
if err != nil {
return nil, err
}
var ts []Translation
for _, t := range res.Translations {
var source language.Tag
if t.DetectedSourceLanguage != "" {
source, err = language.Parse(t.DetectedSourceLanguage)
if err != nil {
return nil, err
}
}
ts = append(ts, Translation{
Text: t.TranslatedText,
Source: source,
Model: t.Model,
})
}
return ts, nil
}
func (p *I18n) set(lng *language.Tag, code, message string) {
lang := lng.String()
if _, ok := p.Locales[lang]; !ok {
p.Locales[lang] = make(map[string]string)
}
p.Locales[lang][code] = message
}
//Get get locale
func (p *DatabaseProvider) Get(lng *language.Tag, code string) string {
var l Locale
if err := p.Db.Where("lang = ? AND code = ?", lng.String(), code).First(&l).Error; err != nil {
p.Logger.Error(err)
}
return l.Message
}
// Tailoring returns a Tailoring for the given locale. One should
// have completed all calls to Add before calling Tailoring.
func (b *Builder) Tailoring(loc language.Tag) *Tailoring {
t := &Tailoring{
id: loc.String(),
builder: b,
index: b.root.clone(),
}
t.index.id = t.id
b.locale = append(b.locale, t)
return t
}
//T translate by lang tag
func (p *I18n) T(lng *language.Tag, code string, args ...interface{}) string {
lang := lng.String()
msg := p.Provider.Get(lng, code)
if len(msg) == 0 {
if items, ok := p.Locales[lang]; ok {
msg = items[code]
}
}
return fmt.Sprintf(msg, args...)
}
//Set set locale
func (p *DatabaseProvider) Set(lng *language.Tag, code, message string) {
var l Locale
var err error
if p.Db.Where("lang = ? AND code = ?", lng.String(), code).First(&l).RecordNotFound() {
l.Lang = lng.String()
l.Code = code
l.Message = message
err = p.Db.Create(&l).Error
} else {
l.Message = message
err = p.Db.Save(&l).Error
}
if err != nil {
p.Logger.Error(err)
}
}
// SupportedLanguages returns a list of supported languages for translation.
// The target parameter is the language to use to return localized, human
// readable names of supported languages.
func (c *Client) SupportedLanguages(ctx context.Context, target language.Tag) ([]Language, error) {
call := c.raw.Languages.List().Context(ctx).Target(target.String())
res, err := call.Do()
if err != nil {
return nil, err
}
var ls []Language
for _, l := range res.Languages {
tag, err := language.Parse(l.Language)
if err != nil {
return nil, err
}
ls = append(ls, Language{
Name: l.Name,
Tag: tag,
})
}
return ls, nil
}
// identifier creates an identifier from the given tag.
func identifier(t language.Tag) string {
return strings.Replace(t.String(), "-", "", -1)
}
func (p *RedisProvider) key(lng *language.Tag, code string) string {
return fmt.Sprintf("locale://%s/%s", lng.String(), code)
}
// Gets the translation for the specified key in the language
// represented by tag
func (i18n JsonI18n) GetTranslation(key string, tag language.Tag) string {
if val, ok := i18n.translations[tag.String()]; ok {
return val[key]
}
return key
}
func (i18n JsonI18n) addTranslationMap(languageMap TranslationMap, tag language.Tag) error {
parent := tag.String()
i18n.translations[parent] = languageMap
return nil
}
//Keys list locale keys
func (p *DatabaseProvider) Keys(lng *language.Tag) ([]string, error) {
var keys []string
err := p.Db.Model(&Locale{}).Where("lang = ?", lng.String()).Pluck("code", &keys).Error
return keys, err
}
//Del del locale
func (p *DatabaseProvider) Del(lng *language.Tag, code string) {
if err := p.Db.Where("lang = ? AND code = ?", lng.String(), code).Delete(Locale{}).Error; err != nil {
p.Logger.Error(err)
}
}
