// Action - Creates and returns action.
func (cmd *Command) Action(ctx action.Map) *action.Action {
value := action.Format{Value: cmd.IAction}
// If value is a string it's action name
if name, ok := value.String(); ok {
return &action.Action{
Name: name,
Ctx: ctx,
}
}
// If value is a map it's action
if m, ok := value.Map(); ok {
// Get action name
name, _ := m.Get("name").String()
// Get action ctx
if c, ok := m.Get("ctx").Map(); ok {
c.Merge(ctx)
ctx = c
}
return &action.Action{
Name: name,
Ctx: ctx,
}
}
return nil
}
// toString - Formats interface to string and cuts to `MaxVariableLength`.
func toString(v interface{}) (res string) {
value := action.Format{v}
if m, ok := value.Map(); ok {
body, _ := m.JSON()
res = string(body)
} else if b, ok := value.Bytes(); ok {
res = string(b)
} else {
res = fmt.Sprintf("%v", value.Interface())
}
// Cut value at 100 characters
if len(res) >= MaxVariableLength {
res = res[:MaxVariableLength] + "..."
}
// Break by new line and trim every line
var lines []string
for _, line := range strings.Split(res, "\n") {
lines = append(lines, strings.TrimSpace(line))
}
// Join to one line
res = strings.Join(lines, "")
return
}
// trimFunc - Runs strings.TrimSpace on strings, lists and maps.
func trimFunc(in action.Format) interface{} {
// If it's a string just trim
if value, ok := in.String(); ok {
return strings.TrimSpace(value)
}
// If it's a list - deep trim all values
if value, ok := in.List(); ok {
for num, val := range value {
if result := trimFunc(action.Format{Value: val}); result != nil {
value[num] = result
}
}
return value
}
// If it's a map - deep trim all values
if value, ok := in.Map(); ok {
value.Transform(value.Keys(), trimFunc)
return value
}
// Not expected type - don't touch
return in.Value
}
// joinURL - joins query to uri
func joinURL(uri string, query action.Format) (u *url.URL, err error) {
u, err = url.Parse(uri)
if err != nil {
return
}
if query.IsNil() {
return
}
var urlQuery url.Values
if u.RawQuery == "" {
urlQuery = make(url.Values)
} else {
urlQuery, err = url.ParseQuery(u.RawQuery)
if err != nil {
return
}
}
// If request query is map
if q, ok := query.Map(); ok {
urlQuery = mapToQuery(urlQuery, q)
} else if q, ok := query.String(); ok { // or a string
urlQuery, err = strToQuery(urlQuery, q)
if err != nil {
return
}
}
u.RawQuery = urlQuery.Encode()
return
}
// IsSelector - Checks if value is a selector.
func IsSelector(value action.Format) bool {
// If value is a string it's a selector
if _, ok := value.String(); ok {
return true
}
// Maybe it's a map ?
m, ok := value.Map()
if !ok {
return false
}
// If we formatted this map save it
value.Value = m
// If map contains $path it's a selector
if !m.Get("$path").IsNil() {
return true
}
// If map contains $extract it's a selector
if !m.Get("$extract").IsNil() {
return true
}
return false
}
// encodeFunc - Encodes value to a JSON byte array.
func encodeFunc(val action.Format) interface{} {
// Try to format to a map and marshal (otherwise UnsupportedTypeError could appear on interface-interface map)
if m, ok := val.Map(); ok {
body, _ := json.Marshal(m)
return body
}
// Otherwise marshal interface
body, _ := json.Marshal(val.Value)
return body
}
// ToSelector - Transforms a value into a Selector.
// Accepts string and map values.
func ToSelector(value action.Format) selector.Extractor {
// Try to get string value
if path, ok := value.String(); ok {
return &selector.Selector{
Extractor: selector.TextExtractor,
Path: path,
}
}
// Maybe it's a map...
if m, ok := value.Map(); ok {
return mapToSelector(m)
}
return nil
}