command line:    zcli [options] <object> <action> [         ids list         ] [              param_body list              ]
zcli internally: zcli [options] <object> <action> [ids list] [ids_params list] [file_upload|download] [param_body list|json]

zcli <object> <action> [ids list] [ids_params list] [file_upload|download] [param_body list|json]
         |       |       |                 |               |                      |
         |       |       ---------------------------------------------------------------> They are ZAPI parameters
         -------------------------------------------------------------------------------> Defines ZAPI request

'command-obj' => {

    # action key used in ZCLI commands. There are reserved words in Define.pm module to be used here.
    'action' => {

        # 'uri' is the URI used for the ZAPI request. It can contain two kind of 'parameters' inside:
        #    '<id>' is a id parameter of the command and has to match with one element of the IDs tree of the load balancer.
        #        Those parameters are delemited for the characeters '<' and '>'
        #    '$Define::Uri_param_tag' is a id_param parameter of the command and it is not implemented in the IDs tree of the load balancer.
        #       The name for this value is in the key of this hash 'param_uri'.
        #       The string that defines this parameters is defined in the Define module of ZCLI.
        uri       => "/system/logs/<$K{LOG}>/lines/$Define::Uri_param_tag",

        # 'method' is the HTTP method used to do the ZAPI request.
        method       => 'PUT',

        # 'content_type' is the content_type header used to send the request parameters in PUT and POST requests.
        #       If this parameter is missing, the 'application/json' value will be used.
        content_type => 'application/gzip',

        # 'upload_file' is a flag to invoke the autocomplete subrutine and to require to upload a local file. It has the 'undef' value.
        upload_file  => undef,

        # 'download_file' is a flag to invoke the autocomplete subrutine and to require to upload a local file. It has the 'undef' value.
        download_file => undef,

        # 'param_uri' is the parameter name for 'ids_params'. This list is sort. Each element contains a 'name' and a 'desc' (description) field
        param_uri    => [
            {
                name => "name",
                desc => "the name which the backup will be saved",
            },
        ],

        # 'params' is a hash with pre-defined parameters. They are useful to create macros of command that does not need to modify
        #      its values as 'restart', 'stop'... Each element of this hash uses as key the parameter name and as value the value name.
        params => {
            'action' => 'stop',
        }

		# This field is used to parse the parameters as an array. Example: creating bonding
		params_arr => {
								'slaves' => 1,
						},

        # Optional parameters is a hash with API request parameters and the list of possible values.
        params_opt => {
			mode => ['drain','cut']
        },

        # The option 'enterprise' is set to '1' when that call is exclusive of EE
        enterprise => 1,

        # 'params_autocomplete' defines how to autocomplete a parameter
        params_autocomplete => {
                name =>        # name of the parameter to autocomplete
                    'ipds/blacklists',    # it is the information to look for the IDs to autocomplete. The keys of the id tree is separated by '/'.
        }

        # The 'params_complete' parameter is a flag not to extend the command autocompleting more parameters.
        # It is useful to create a command macro with a expecific configuration.
        # I.E. "ipds-package upgrade"
        params_complete => 1,

        # It is used to customized the parsing of the parameters for a command. There is an example in 'rbac-role set'.
        # If this parameter is used, previously only will be parsed the URI parameters.
        params_funct_parse => 'Objects::complete_rbac_roles',

        # It is used to customized the building of the parameters for a request body. There is an example in 'rbac-role set'
        params_funct_build => 'Objects::body_rbac_roles',
    }
}

'farms-services' => {
    $V{ CREATE } => {
                      uri    => "/farms/<$K{FARM}>/services",
                      method => 'POST',
    },
    $V{ SET } => {
                   uri    => "/farms/<$K{FARM}>/services/<$K{SRV}>",
                   method => 'PUT',
    },
},

'farms' => $V{ STOP } => {
                     uri    => "/farms/<$K{FARM}>/actions",
                     method => 'PUT',
                     params => {
                                 'action' => 'stop',
                     },
     },
},

'system-backups' => {
      $V{ DOWNLOAD } => {
                          uri    => "/system/backup/<$K{BACKUP}>",
                          method => 'GET',
                          download_file => undef,
      },
      $V{ UPLOAD } => {
              uri          => "/system/backup/$Define::Uri_param_tag",
              method       => 'PUT',
              content_type => 'application/gzip',
              upload_file  => undef,
              param_uri    => [
                    {
                        name => "name",
                        desc => "the name which the backup will be saved",
                    },
              ],
      },
},

-> reloadCmdStruct
-> createZcliCmd
-> createCmdObject add_ids(recursively) create a temporality description using 'create_description'
-> gen_act:
    |-> $def->{ desc } = getCmdDescription(): creates the command syntaxis for the input arguments.
    |-> $def->{ proc } = geCmdProccessCallback(): is the subrutine that executes the ZAPI request.
    |-> $def->{ args } = getCmdArgsCallBack() : parses the input parameters and autocomplete the next expected parameter.
                | ->completeArgsBodyParams(): autocompletes the next expected HTTP body parameter, checking between keys and values in the JSON.
                    |-> listParams(): Do a ZAPI request without parameters to get the list of possible body parameters.