// Parse command and flags and infer resource, action, href and params
func (a *Api) ParseCommandAndFlags(cmd, hrefPrefix string, values ActionCommands) (*CommandTarget, []string, error) {
resource, vars, err := a.parseResource(cmd, hrefPrefix, values)
if err != nil {
return nil, nil, err
}
var action *metadata.Action
elems := strings.Split(cmd, " ")
actionName := elems[len(elems)-1]
for _, a := range resource.Actions {
if a.Name == actionName {
action = a
break
}
}
if action == nil {
supported := make([]string, len(resource.Actions))
for i, a := range resource.Actions {
supported[i] = a.Name
}
return nil, nil, fmt.Errorf("Unknown %s action '%s'. Supported actions are: %s",
resource.Name, actionName, strings.Join(supported, ", "))
}
path, err := action.Url(vars)
if err != nil {
return nil, nil, err
}
flags := values[cmd]
return &CommandTarget{resource, action, path, flags.Href}, flags.Params, nil
}
// ActionPath computes the path to the given resource action. For example given the href
// "/api/servers/123" calling ActionPath with resource "servers" and action "clone" returns the path
// "/api/servers/123/clone" and verb POST.
// The algorithm consists of extracting the variables from the href by looking up a matching
// pattern from the resource metadata. The variables are then substituted in the action path.
// If there are more than one pattern that match the href then the algorithm picks the one that can
// substitute the most variables.
func (r *Href) ActionPath(rName, aName string) (*metadata.ActionPath, error) {
res, ok := GenMetadata[rName]
if !ok {
return nil, fmt.Errorf("No resource with name '%s'", rName)
}
var action *metadata.Action
for _, a := range res.Actions {
if a.Name == aName {
action = a
break
}
}
if action == nil {
return nil, fmt.Errorf("No action with name '%s' on %s", aName, rName)
}
vars, err := res.ExtractVariables(string(*r))
if err != nil {
return nil, err
}
return action.Url(vars)
}
// Out
url string
err error
// Test data
prefix = "/a/path/pattern/with/one/"
p1 = &metadata.PathPattern{"GET", prefix + "%s", []string{"a"}, nil}
p2 = &metadata.PathPattern{"GET", "%s%s", []string{"a", "b"}, nil}
a = metadata.PathVariable{"a", "1"}
b = metadata.PathVariable{"b", "2"}
)
JustBeforeEach(func() {
var p *metadata.ActionPath
p, err = action.Url(variables)
if err == nil {
url = p.Path
}
})
Context("with a single matching pattern", func() {
BeforeEach(func() {
action = &metadata.Action{
PathPatterns: []*metadata.PathPattern{p1},
}
variables = []*metadata.PathVariable{&a}
})
It("returns the URL", func() {
Ω(url).Should(Equal(prefix + a.Value))
