func (p *Todo) NewTask(payload *spirit.Payload) (result interface{}, err error) {
reqTodo := Todo{}
payload.FillContentToObject(&reqTodo)
result = Todo{User: reqTodo.User, Task: "hello spirit task", IsDone: false, CreateTime: time.Now()}
return
}
func (p *TaskComponent) FinishTask(payload spirit.Payload) (result interface{}, err error) {
task := models.Task{}
if err = payload.DataToObject(&task); err != nil {
return
}
if err = p.TaskManager.FinishTask(task.Id); err != nil {
return
}
return
}
func (p *TaskComponent) NewTask(payload spirit.Payload) (result interface{}, err error) {
newTask := models.Task{}
if err = payload.DataToObject(&newTask); err != nil {
return
}
if result, err = p.TaskManager.NewTask(newTask); err != nil {
return
}
return
}
func (p *AuthComponent) CheckAuth(payload spirit.Payload) (result interface{}, err error) {
if result, err = payload.GetData(); err != nil {
return
}
var contexts interface{}
var headerExist bool
if contexts, headerExist = payload.GetContext(CtxHttpHeaders); !headerExist {
err = ErrAuthorizationHeaderNotExist.New()
return
}
if headers, ok := contexts.(map[string]interface{}); !ok {
err = ErrAuthorizationHeaderNotExist.New()
return
} else if v, exist := headers["Authorization"]; !exist {
err = ErrAuthorizationHeaderNotExist.New()
return
} else if authVal, ok := v.(string); !ok {
err = ErrAuthorizationHeaderNotExist.New()
return
} else {
authVal = strings.TrimLeft(authVal, "Basic ")
var val []byte
if val, err = base64.StdEncoding.DecodeString(authVal); err != nil {
return
}
account := strings.Split(string(val), ":")
if len(account) != 2 {
err = ErrAuthorizationHeaderFmtError.New()
return
}
if err = p.Auth.CheckAuth(account[0], account[1]); err != nil {
return
}
}
return
}
func (p *MNSEncodingComponent) Encode(payload spirit.Payload) (result interface{}, err error) {
var vData interface{}
if vData, err = payload.GetData(); err != nil {
return
}
dataKind := reflect.TypeOf(vData).Kind()
if dataKind == reflect.Ptr ||
dataKind == reflect.Struct {
var data []byte
data, result = xml.Marshal(vData)
result = data
} else {
err = ErrDataTypeIsNotStruct
return
}
return
}
func (p *MNSEncodingComponent) Decode(payload spirit.Payload) (result interface{}, err error) {
var vData interface{}
if vData, err = payload.GetData(); err != nil {
return
}
var resp interface{}
if p.conf.SingleMessage {
resp = &ali_mns.MessageReceiveResponse{}
} else {
resp = &ali_mns.BatchMessageReceiveResponse{}
}
switch data := vData.(type) {
case string:
{
err = xml.Unmarshal([]byte(data), &resp)
}
case []byte:
{
err = xml.Unmarshal(data, &resp)
}
case io.Reader:
{
reader := xml.NewDecoder(data)
err = reader.Decode(&resp)
}
default:
err = ErrDataTypeCouldNotBeDecode
return
}
if err == nil {
result = resp
}
return
}
func (p *HTTPAPIClient) Call(apiName string, payload spirit.Payload, v interface{}) (err error) {
apiName = strings.TrimSpace(apiName)
if apiName == "" {
err = ErrAPINameIsEmpty.New()
return
}
var payloadData interface{}
if payloadData, err = payload.GetData(); err != nil {
return
}
jsonPayload := JsonPayload{
Id: payload.Id(),
Data: payloadData,
Errors: payload.Errors(),
Context: payload.Context(),
}
var data []byte
if data, err = json.Marshal(jsonPayload); err != nil {
return
}
postBodyReader := bytes.NewReader(data)
var req *http.Request
if req, err = http.NewRequest("POST", p.url, postBodyReader); err != nil {
err = ErrAPIClientCreateNewRequestFailed.New().Append(err)
return
}
req.Header.Add(p.apiHeaderName, apiName)
req.Header.Add(HeaderForwardedPayload, "on")
var resp *http.Response
if resp, err = p.client.Do(req); err != nil {
err = ErrAPIClientSendFailed.New(errors.Params{"api": apiName, "url": p.url})
return
}
var body []byte
if resp != nil {
defer resp.Body.Close()
if bBody, e := ioutil.ReadAll(resp.Body); e != nil {
err = ErrAPIClientReadResponseBodyFailed.New(errors.Params{"api": apiName}).Append(e)
return
} else if resp.StatusCode != http.StatusOK {
err = ErrAPIClientBadStatusCode.New(errors.Params{"api": apiName, "code": resp.StatusCode})
return
} else {
body = bBody
}
if v == nil {
return
}
}
if v == nil {
return
}
var tmpResp struct {
Code uint64 `json:"code"`
ErrorId string `json:"error_id,omitempty"`
ErrorNamespace string `json:"error_namespace,omitempty"`
Message string `json:"message"`
Result interface{} `json:"result"`
}
tmpResp.Result = v
if e := json.Unmarshal(body, &tmpResp); e != nil {
err = ErrAPIClientResponseUnmarshalFailed.New(errors.Params{"api": apiName, "url": p.url}).Append(e)
return
}
if tmpResp.Code == 0 {
return
} else {
err = errors.NewErrorCode(tmpResp.ErrorId, tmpResp.Code, tmpResp.ErrorNamespace, tmpResp.Message, "", nil)
return
}
return
}
