140 lines
2.8 KiB
Go
140 lines
2.8 KiB
Go
package connector
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
S_EVENT_JOIN = "join"
|
|
S_EVENT_LEAVE = "leave"
|
|
S_EVENT_MESSAGE = "message"
|
|
S_EVENT_ACTION = "action"
|
|
)
|
|
|
|
func (t EventType) MarshalText() ([]byte, error) {
|
|
switch t {
|
|
case EVENT_JOIN:
|
|
return []byte(S_EVENT_JOIN), nil
|
|
case EVENT_LEAVE:
|
|
return []byte(S_EVENT_LEAVE), nil
|
|
case EVENT_MESSAGE:
|
|
return []byte(S_EVENT_MESSAGE), nil
|
|
case EVENT_ACTION:
|
|
return []byte(S_EVENT_ACTION), nil
|
|
default:
|
|
return nil, fmt.Errorf("Invalid event type: %d", t)
|
|
}
|
|
}
|
|
|
|
func (t *EventType) UnmarshalText(text []byte) error {
|
|
switch string(text) {
|
|
case S_EVENT_JOIN:
|
|
*t = EVENT_JOIN
|
|
return nil
|
|
case S_EVENT_LEAVE:
|
|
*t = EVENT_LEAVE
|
|
return nil
|
|
case S_EVENT_MESSAGE:
|
|
*t = EVENT_MESSAGE
|
|
return nil
|
|
case S_EVENT_ACTION:
|
|
*t = EVENT_ACTION
|
|
return nil
|
|
default:
|
|
return fmt.Errorf("Invalid event type: %s", string(text))
|
|
}
|
|
}
|
|
|
|
// ----
|
|
|
|
type MediaObjectJSON struct {
|
|
Filename string `json:"filename"`
|
|
Mimetype string `json:"mime_type"`
|
|
Size int64 `json:"size"`
|
|
ImageSize *ImageSize `json:"image_size"`
|
|
Data string `json:"data"`
|
|
URL string `json:"url"`
|
|
}
|
|
|
|
func (mo SMediaObject) MarshalJSON() ([]byte, error) {
|
|
if mo.MediaObject == nil {
|
|
return []byte("null"), nil
|
|
}
|
|
|
|
mod := MediaObjectJSON{
|
|
Filename: mo.Filename(),
|
|
Mimetype: mo.Mimetype(),
|
|
Size: mo.Size(),
|
|
ImageSize: mo.ImageSize(),
|
|
URL: mo.URL(),
|
|
}
|
|
|
|
if mod.URL == "" {
|
|
// If we don't have a URL, the only way is to pass the blob itself
|
|
rd, err := mo.Read()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rd.Close()
|
|
buf := bytes.NewBuffer([]byte{})
|
|
_, err = io.Copy(buf, rd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
mod.Data = base64.StdEncoding.EncodeToString(buf.Bytes())
|
|
}
|
|
|
|
return json.Marshal(&mod)
|
|
}
|
|
|
|
func (mo *SMediaObject) UnmarshalJSON(jdata []byte) error {
|
|
if string(jdata) == "null" {
|
|
return nil
|
|
}
|
|
|
|
var d MediaObjectJSON
|
|
err := json.Unmarshal(jdata, &d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if d.URL != "" {
|
|
*mo = SMediaObject{&LazyBlobMediaObject{
|
|
ObjectFilename: d.Filename,
|
|
ObjectMimetype: d.Mimetype,
|
|
ObjectImageSize: d.ImageSize,
|
|
GetFn: func(o *LazyBlobMediaObject) error {
|
|
resp, err := http.Get(d.URL)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if o.ObjectMimetype == "" {
|
|
o.ObjectMimetype = strings.Join(resp.Header["Content-Type"], "")
|
|
}
|
|
o.ObjectData, err = ioutil.ReadAll(resp.Body)
|
|
return err
|
|
},
|
|
}}
|
|
return nil
|
|
}
|
|
|
|
bytes, err := base64.StdEncoding.DecodeString(d.Data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*mo = SMediaObject{&BlobMediaObject{
|
|
ObjectFilename: d.Filename,
|
|
ObjectMimetype: d.Mimetype,
|
|
ObjectImageSize: d.ImageSize,
|
|
ObjectData: bytes,
|
|
}}
|
|
return nil
|
|
}
|