hunk.code_window: 	}
   	return nil
   }
   func (s SqlSystemStore) SaveOrUpdate(system *model.System) *model.AppError {
   	if err := s.GetReplica().SelectOne(&model.System{}, "SELECT * FROM Systems WHERE Name = :Name", map[string]interface{}{"Name": system.Name}); err == nil {
   		if _, err := s.GetMaster().Update(system); err != nil {
   			return model.NewAppError("SqlSystemStore.SaveOrUpdate", "store.sql_system.update.app_error", nil, err.Error(), http.StatusInternalServerError)
   		}
   	} else {
  
hunk.labels: keep keep keep keep keep replace keep keep keep keep
hunk.after_edit: 	if err := s.GetMaster().SelectOne(&model.System{}, "SELECT * FROM Systems WHERE Name = :Name", map[string]interface{}{"Name": system.Name}); err == nil {
  
hunk.file_path: store/sqlstore/system_store.go
hunk.type: replace
file: package translation
  
  import (
  	"github.com/mattermost/go-i18n/i18n/language"
  )
  
  type pluralTranslation struct {
  	id        string
  	templates map[language.Plural]*template
  }
  
  func (pt *pluralTranslation) MarshalInterface() interface{} {
  	return map[string]interface{}{
  		"id":          pt.id,
  		"translation": pt.templates,
  	}
  }
  
  func (pt *pluralTranslation) MarshalFlatInterface() interface{} {
  	return pt.templates
  }
  
  func (pt *pluralTranslation) ID() string {
  	return pt.id
  }
  
  func (pt *pluralTranslation) Template(pc language.Plural) *template {
  	return pt.templates[pc]
  }
  
  func (pt *pluralTranslation) UntranslatedCopy() Translation {
  	return &pluralTranslation{pt.id, make(map[language.Plural]*template)}
  }
  
  func (pt *pluralTranslation) Normalize(l *language.Language) Translation {
  	// Delete plural categories that don't belong to this language.
  	for pc := range pt.templates {
  		if _, ok := l.Plurals[pc]; !ok {
  			delete(pt.templates, pc)
  		}
  	}
  	// Create map entries for missing valid categories.
  	for pc := range l.Plurals {
  		if _, ok := pt.templates[pc]; !ok {
  			pt.templates[pc] = mustNewTemplate("")
  		}
  	}
  	return pt
  }
  
  func (pt *pluralTranslation) Backfill(src Translation) Translation {
  	for pc, t := range pt.templates {
  		if (t == nil || t.src == "") && src != nil {
  			pt.templates[pc] = src.Template(language.Other)
  		}
  	}
  	return pt
  }
  
  func (pt *pluralTranslation) Merge(t Translation) Translation {
  	other, ok := t.(*pluralTranslation)
  	if !ok || pt.ID() != t.ID() {
  		return t
  	}
  	for pluralCategory, template := range other.templates {
  		if template != nil && template.src != "" {
  			pt.templates[pluralCategory] = template
  		}
  	}
  	return pt
  }
  
  func (pt *pluralTranslation) Incomplete(l *language.Language) bool {
  	for pc := range l.Plurals {
  		if t := pt.templates[pc]; t == nil || t.src == "" {
  			return true
  		}
  	}
  	return false
  }
  
  var _ = Translation(&pluralTranslation{})
  