Encode array to base64 in go

Here is my complete code for a function I develop:

package main
import (
"database/sql"
"log"
"encoding/xml"
"github.com/gin-gonic/gin" //golang frameworks
_ "github.com/go-sql-driver/mysql"
"gopkg.in/gorp.v1"        //work with database(mysql, etc.)
)
type Genre struct {
Title string `xml:"genre"`
}
type GenreArray struct {
Auth_state int `xml:"auth_state"`
Count int64 `xml:"count"`
Item genreAPI `xml:"item"`
}
type UserPass struct {
Username string `xml:"username"`
Password string `xml:"password"`
}
type ErrorMessage struct {
XMLName xml.Name `xml:"error"`
Error string `xml:"error_code"`
Message string `xml:"message"`
}
type Auth struct {
XMLName xml.Name `xml:"config"`
Nas_SharingEmpty  int `xml:"nas_sharing>auth_state"`
}
type ConfigGenre struct {
XMLName xml.Name `xml:"config"`
Nas_Sharing  GenreArray `xml:"nas_sharing"`
}
type genreAPI []Genre
var dbmap = initDb()
func initDb() *gorp.DbMap {
db, err := sql.Open("mysql", "root@tcp(localhost:3306)/mymusic")
checkErr(err, "sql.Open failed")
dbmap := &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}
return dbmap
}
func checkErr(err error, msg string) {
if err != nil {
log.Fatalln(msg, err)
}
}
func main() {
r := gin.Default()
r.POST("/nas_sharing", myMusicXML)
r.Run(":9999")
}
func myMusicXML(c *gin.Context) {
c.Request.ParseForm()
cmd := c.Request.Form.Get("cmd")
usernamepost := c.Request.Form.Get("user")
passwordpost := c.Request.Form.Get("passwd")
if cmd == "36" {
//Music Genre List API
var genre []Genre
var userpass []UserPass
var count int64
var countAuth int64
//Query the post username and password
_, errAuth := dbmap.Select(&userpass, "SELECT username, password FROM user WHERE username=? and password=?", usernamepost, passwordpost)
//Check if post username and password exist
countAuth, errAuth = dbmap.SelectInt("select count(*) FROM user WHERE username=? and password=?", usernamepost, passwordpost)
if countAuth == 0 {
//If no rows detected, output a message
c.XML(404, Auth{Nas_SharingEmpty: 0})
}else{
//Check if query is valid
if errAuth == nil {
log.Println("auth_state :", countAuth)
}else{
c.XML(404, gin.H{"error": "sql query error found"})
}
//Query genre list
_, err := dbmap.Select(&genre, "SELECT Title FROM genre_cntr_tbl")
//Count genres
count, err = dbmap.SelectInt("select count(*) FROM genre_cntr_tbl")
if count == 0 {
//If no rows detected, output a message
c.XML(404, ErrorMessage{Error:"404", Message: "no genre found"})
}else{
//Check if query is valid
if err == nil {
log.Println("Genres :", genre)
c.XML(200, ConfigGenre{Nas_Sharing: GenreArray{Auth_state: 1, Count: count, Item: genre,}})
}else{
c.XML(404, gin.H{"error": "sql query error found"})
}
}
}
}else{
c.XML(404, ErrorMessage{Error:"404", Message: "command not found"})
}
}

And here is the output:

<config>
<nas_sharing>
<auth_state>1</auth_state>
<count>8</count>
<item>
<genre>Pop</genre>
</item>
<item>
<genre>Rock</genre>
</item>
<item>
<genre>Dance</genre>
</item>
<item>
<genre>Opera</genre>
</item>
<item>
<genre>Techno</genre>
</item>
<item>
<genre>Hip Hop</genre>
</item>
<item>
<genre>Jazz</genre>
</item>
<item>
<genre>Reggae</genre>
</item>
</nas_sharing>

</config>

Here is the value of genre of my output to log(note: It came from a database):

Genres : [{Pop} {Rock} {Dance} {Opera} {Techno} {Hiphop} {Jazz} {Reggae}]  

However, I would like to convert the output to base64 format. Here's a sample code for encoding to base64 but the data given to this is string unlike the one I develop that comes from an array. How could I achieve that output?

data := "/MyMusic/images/_albums/albums_nophoto.png"
sEnc := b64.StdEncoding.EncodeToString([]byte(data))
fmt.Println(sEnc)

Here is what output I expected

<config>
<nas_sharing>
<auth_state>1</auth_state>
<count>8</count>
<item>
<genre>UG9w</genre>
</item>
<item>
<genre>Um9jaw==</genre>
</item>
<item>
<genre>RGFuY2U=</genre>
</item>
<item>
<genre>T3BlcmE=</genre>
</item>
<item>
<genre>VGVjaG5v</genre>
</item>
etc...

Foreword: The first section answers the original question (encode array to Base64). If you just want individual string fields to appear as Base64 strings in the output, see the 2nd section.

Encoding a []string into Base64 format

Base64 is an encoding, a function used to convert an arbitrary sequence of bytes to a text using a small, well defined set of characters.

So you have to decide / come up with a way to convert your []string array or slice to a sequence of bytes.

An easy and convenient way is to convert your []string to JSON text which will also take care of escaping strings having a quotation mark " for example. The result string can be easily encoded using the method you described:

genre := []string{"Pop", "Rock", "Dance", "Opera", "Techno", "Hiphop", "Jazz", "Reggae"}
data, _ := json.Marshal(&genre)
fmt.Println(string(data))
sEnc := base64.StdEncoding.EncodeToString(data)
fmt.Println(sEnc)

Output (try it on the Go Playground):

["Pop","Rock","Dance","Opera","Techno","Hiphop","Jazz","Reggae"]
WyJQb3AiLCJSb2NrIiwiRGFuY2UiLCJPcGVyYSIsIlRlY2hubyIsIkhpcGhvcCIsIkphenoiLCJSZWdnYWUiXQ==

Decoding

Having such Base64 result, you can decode it like this:

data2, err := base64.StdEncoding.DecodeString(sEnc)
if err != nil {
panic(err)
}
var genre2 []string
if err = json.Unmarshal(data2, &genre2); err != nil {
panic(err)
}
fmt.Println(genre2)

Output:

[Pop Rock Dance Opera Techno Hiphop Jazz Reggae]

Notes:

Of course you may choose any other transformations to convert []string to a byte sequence. You could convert it to XML, or using the encoding/binary or anything else. I chose JSON because it is a one-liner, compact, fast, and is supported in almost every programming language, so it won't be a problem if another program has to decode it.

Making individual string fields to appear as Base64

You can do this by implementing the Marshaler interface on the type (or enclosing struct) like this:

func (g *Genre) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
g2 := *g
g2.Title = base64.StdEncoding.EncodeToString([]byte(g.Title))
return e.EncodeElement(g2, start)
}

Basically what this does is creates a copy of Genre, changes the value of the Title field (of the copy) to the Base64 representation of its original value and encodes this copy.

Output (partial), try it on the Go Playground:

<GenreArray>
<item>
<genre>UG9w</genre>
</item>
<item>
<genre>Um9jaw==</genre>
</item>
</GenreArray>