bash.client.mustache Maven / Gradle / Ivy
#!/usr/bin/env bash
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# !
# ! Note:
# !
# ! THIS SCRIPT HAS BEEN AUTOMATICALLY GENERATED USING
# ! openapi-generator (https://openapi-generator.tech)
# ! FROM OPENAPI SPECIFICATION IN JSON.
# !
{{^hideGenerationTimestamp}}# ! Generated on: {{generatedDate}}
{{/hideGenerationTimestamp}}# !
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#
# This is a Bash client for {{appName}}.
#
# LICENSE:
# {{licenseUrl}}
#
# CONTACT:
# {{infoEmail}}
#
# MORE INFORMATION:
# {{#externalDocs}}{{url}}{{/externalDocs}}
#
# For improved pattern matching in case statemets
shopt -s extglob
###############################################################################
#
# Make sure Bash is at least in version 4.3
#
###############################################################################
if ! ( (("${BASH_VERSION:0:1}" == "4")) && (("${BASH_VERSION:2:1}" >= "3")) ) \
&& ! (("${BASH_VERSION:0:1}" >= "5")); then
echo ""
echo "Sorry - your Bash version is ${BASH_VERSION}"
echo ""
echo "You need at least Bash 4.3 to run this script."
echo ""
exit 1
fi
###############################################################################
#
# Global variables
#
###############################################################################
##
# The filename of this script for help messages
script_name=$(basename "$0")
##
# Map for headers passed after operation as KEY:VALUE
declare -A header_arguments
##
# Map for operation parameters passed after operation as PARAMETER=VALUE
# These will be mapped to appropriate path or query parameters
# The values in operation_parameters are arrays, so that multiple values
# can be provided for the same parameter if allowed by API specification
declare -A operation_parameters
##
# Declare colors with autodection if output is terminal
if [ -t 1 ]; then
RED="$(tput setaf 1)"
GREEN="$(tput setaf 2)"
YELLOW="$(tput setaf 3)"
BLUE="$(tput setaf 4)"
MAGENTA="$(tput setaf 5)"
CYAN="$(tput setaf 6)"
WHITE="$(tput setaf 7)"
BOLD="$(tput bold)"
OFF="$(tput sgr0)"
else
RED=""
GREEN=""
YELLOW=""
BLUE=""
MAGENTA=""
CYAN=""
WHITE=""
BOLD=""
OFF=""
fi
declare -a result_color_table=( "$WHITE" "$WHITE" "$GREEN" "$YELLOW" "$WHITE" "$MAGENTA" "$WHITE" )
##
# This array stores the minimum number of required occurrences for parameter
# 0 - optional
# 1 - required
declare -A operation_parameters_minimum_occurrences
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#operation}}
{{#allParams}}
operation_parameters_minimum_occurrences["{{operationId}}:::{{baseName}}"]={{#required}}{{#vendorExtensions}}{{#x-codegen-collection-min-items}}{{x-codegen-collection-min-items}}{{/x-codegen-collection-min-items}}{{^x-codegen-collection-min-items}}1{{/x-codegen-collection-min-items}}{{/vendorExtensions}}{{^vendorExtensions}}1{{/vendorExtensions}}{{/required}}{{^required}}0{{/required}}
{{/allParams}}
{{/operation}}
{{/operations}}
{{/apis}}
{{/apiInfo}}
##
# This array stores the maximum number of allowed occurrences for parameter
# 1 - single value
# 2 - 2 values
# N - N values
# 0 - unlimited
declare -A operation_parameters_maximum_occurrences
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#operation}}
{{#allParams}}
operation_parameters_maximum_occurrences["{{operationId}}:::{{baseName}}"]={{#vendorExtensions}}{{#x-codegen-collection-max-items}}{{x-codegen-collection-max-items}}{{/x-codegen-collection-max-items}}{{^x-codegen-collection-max-items}}0{{/x-codegen-collection-max-items}}{{/vendorExtensions}}{{^vendorExtensions}}0{{/vendorExtensions}}
{{/allParams}}
{{/operation}}
{{/operations}}
{{/apis}}
{{/apiInfo}}
##
# The type of collection for specifying multiple values for parameter:
# - multi, csv, ssv, tsv
declare -A operation_parameters_collection_type
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#operation}}
{{#allParams}}
operation_parameters_collection_type["{{operationId}}:::{{baseName}}"]={{#isContainer}}{{#vendorExtensions}}{{#x-codegen-collection-multi}}"multi"{{/x-codegen-collection-multi}}{{#x-codegen-collection-csv}}"csv"{{/x-codegen-collection-csv}}{{#x-codegen-collection-tsv}}"tsv"{{/x-codegen-collection-tsv}}{{#x-codegen-collection-ssv}}"ssv"{{/x-codegen-collection-ssv}}{{/vendorExtensions}}{{^vendorExtensions}}""{{/vendorExtensions}}{{/isContainer}}{{^isContainer}}""{{/isContainer}}
{{/allParams}}
{{/operation}}
{{/operations}}
{{/apis}}
{{/apiInfo}}
##
# Map for body parameters passed after operation as
# PARAMETER==STRING_VALUE or PARAMETER:=NUMERIC_VALUE
# These will be mapped to top level json keys ( { "PARAMETER": "VALUE" })
declare -A body_parameters
##
# These arguments will be directly passed to cURL
curl_arguments="{{x-codegen-curl-options}}"
##
# The host for making the request
host="{{#x-codegen-host-env}}${{x-codegen-host-env}}{{/x-codegen-host-env}}"
##
# The user credentials for basic authentication
basic_auth_credential="{{#x-codegen-basicauth-env}}${{x-codegen-basicauth-env}}{{/x-codegen-basicauth-env}}"
{{#hasAuthMethods}}
{{#authMethods}}
{{#isApiKey}}
{{#isKeyInHeader}}
##
# The user API key
apikey_auth_credential="{{#x-codegen-apikey-env}}${{x-codegen-apikey-env}}{{/x-codegen-apikey-env}}"
{{/isKeyInHeader}}
{{/isApiKey}}
{{/authMethods}}
{{/hasAuthMethods}}
##
# If true, the script will only output the actual cURL command that would be
# used
print_curl=false
##
# The operation ID passed on the command line
operation=""
##
# The provided Accept header value
header_accept=""
##
# The provided Content-type header value
header_content_type=""
##
# If there is any body content on the stdin pass it to the body of the request
body_content_temp_file=""
##
# If this variable is set to true, the request will be performed even
# if parameters for required query, header or body values are not provided
# (path parameters are still required).
force=false
##
# Declare some mime types abbreviations for easier content-type and accepts
# headers specification
declare -A mime_type_abbreviations
# text/*
mime_type_abbreviations["text"]="text/plain"
mime_type_abbreviations["html"]="text/html"
mime_type_abbreviations["md"]="text/x-markdown"
mime_type_abbreviations["csv"]="text/csv"
mime_type_abbreviations["css"]="text/css"
mime_type_abbreviations["rtf"]="text/rtf"
# application/*
mime_type_abbreviations["json"]="application/json"
mime_type_abbreviations["xml"]="application/xml"
mime_type_abbreviations["yaml"]="application/yaml"
mime_type_abbreviations["js"]="application/javascript"
mime_type_abbreviations["bin"]="application/octet-stream"
mime_type_abbreviations["rdf"]="application/rdf+xml"
# image/*
mime_type_abbreviations["jpg"]="image/jpeg"
mime_type_abbreviations["png"]="image/png"
mime_type_abbreviations["gif"]="image/gif"
mime_type_abbreviations["bmp"]="image/bmp"
mime_type_abbreviations["tiff"]="image/tiff"
##############################################################################
#
# Escape special URL characters
# Based on table at http://www.w3schools.com/tags/ref_urlencode.asp
#
##############################################################################
url_escape() {
local raw_url="$1"
value=$(sed -e 's/ /%20/g' \
-e 's/!/%21/g' \
-e 's/"/%22/g' \
-e 's/#/%23/g' \
-e 's/\&/%26/g' \
-e 's/'\''/%28/g' \
-e 's/(/%28/g' \
-e 's/)/%29/g' \
-e 's/:/%3A/g' \
-e 's/\t/%09/g' \
-e 's/?/%3F/g' <<<"$raw_url");
echo "$value"
}
##############################################################################
#
# Lookup the mime type abbreviation in the mime_type_abbreviations array.
# If not present assume the user provided a valid mime type
#
##############################################################################
lookup_mime_type() {
local mime_type="$1"
if [[ ${mime_type_abbreviations[$mime_type]} ]]; then
echo "${mime_type_abbreviations[$mime_type]}"
else
echo "$mime_type"
fi
}
##############################################################################
#
# Converts an associative array into a list of cURL header
# arguments (-H "KEY: VALUE")
#
##############################################################################
header_arguments_to_curl() {
local headers_curl=""
{{#hasAuthMethods}}
{{#authMethods}}
{{#isApiKey}}
{{#isKeyInHeader}}
local api_key_header=""
local api_key_header_in_cli=""
api_key_header="{{keyParamName}}"
{{/isKeyInHeader}}
{{/isApiKey}}
{{/authMethods}}
{{/hasAuthMethods}}
for key in "${!header_arguments[@]}"; do
headers_curl+="-H \"${key}: ${header_arguments[${key}]}\" "
{{#hasAuthMethods}}
{{#authMethods}}
{{#isApiKey}}
{{#isKeyInHeader}}
if [[ "${key}XX" == "${api_key_header}XX" ]]; then
api_key_header_in_cli="YES"
fi
{{/isKeyInHeader}}
{{/isApiKey}}
{{/authMethods}}
{{/hasAuthMethods}}
done
{{#hasAuthMethods}}
{{#authMethods}}
{{#isApiKey}}
{{#isKeyInHeader}}
#
# If the api_key was not provided in the header, try one from the
# environment variable
#
if [[ -z $api_key_header_in_cli && -n $apikey_auth_credential ]]; then
headers_curl+="-H \"${api_key_header}: ${apikey_auth_credential}\""
fi
{{/isKeyInHeader}}
{{/isApiKey}}
{{/authMethods}}
{{/hasAuthMethods}}
headers_curl+=" "
echo "${headers_curl}"
}
##############################################################################
#
# Converts an associative array into a simple JSON with keys as top
# level object attributes
#
# \todo Add conversion of more complex attributes using paths
#
##############################################################################
body_parameters_to_json() {
local body_json="-d '{"
local count=0
for key in "${!body_parameters[@]}"; do
if [[ $((count++)) -gt 0 ]]; then
body_json+=", "
fi
body_json+="\"${key}\": ${body_parameters[${key}]}"
done
body_json+="}'"
if [[ "${#body_parameters[@]}" -eq 0 ]]; then
echo ""
else
echo "${body_json}"
fi
}
##############################################################################
#
# Helper method for showing error because for example echo in
# build_request_path() is evaluated as part of command line not printed on
# output. Anyway better idea for resource clean up ;-).
#
##############################################################################
ERROR_MSG=""
function finish {
if [[ -n "$ERROR_MSG" ]]; then
echo >&2 "${OFF}${RED}$ERROR_MSG"
echo >&2 "${OFF}Check usage: '${script_name} --help'"
fi
}
trap finish EXIT
##############################################################################
#
# Validate and build request path including query parameters
#
##############################################################################
build_request_path() {
local path_template=$1
local -n path_params=$2
local -n query_params=$3
#
# Check input parameters count against minimum and maximum required
#
if [[ "$force" = false ]]; then
local was_error=""
for qparam in "${query_params[@]}" "${path_params[@]}"; do
local parameter_values
mapfile -t parameter_values < <(sed -e 's/'":::"'/\n/g' <<<"${operation_parameters[$qparam]}")
#
# Check if the number of provided values is not less than minimum required
#
if [[ ${#parameter_values[@]} -lt ${operation_parameters_minimum_occurrences["${operation}:::${qparam}"]} ]]; then
echo "ERROR: Too few values provided for '${qparam}' parameter."
was_error=true
fi
#
# Check if the number of provided values is not more than maximum
#
if [[ ${operation_parameters_maximum_occurrences["${operation}:::${qparam}"]} -gt 0 \
&& ${#parameter_values[@]} -gt ${operation_parameters_maximum_occurrences["${operation}:::${qparam}"]} ]]; then
echo "ERROR: Too many values provided for '${qparam}' parameter"
was_error=true
fi
done
if [[ -n "$was_error" ]]; then
exit 1
fi
fi
# First replace all path parameters in the path
for pparam in "${path_params[@]}"; do
local path_regex="(.*)(\\{$pparam\\})(.*)"
if [[ $path_template =~ $path_regex ]]; then
path_template=${BASH_REMATCH[1]}${operation_parameters[$pparam]}${BASH_REMATCH[3]}
fi
done
local query_request_part=""
for qparam in "${query_params[@]}"; do
if [[ "${operation_parameters[$qparam]}" == "" ]]; then
continue
fi
# Get the array of parameter values
local parameter_value=""
local parameter_values
mapfile -t parameter_values < <(sed -e 's/'":::"'/\n/g' <<<"${operation_parameters[$qparam]}")
{{#hasAuthMethods}}{{#authMethods}}{{#isApiKey}}{{#isKeyInQuery}}
if [[ ${qparam} == "{{keyParamName}}" ]]; then
if [[ -n "${parameter_values[*]}" ]]; then
parameter_value+="${qparam}=${parameter_values}"
{{#x-codegen-apikey-env}}
elif [[ -n "$MATRIX_API_KEY" ]]; then
parameter_value+="${qparam}=${{x-codegen-apikey-env}}"
{{/x-codegen-apikey-env}}
else
echo "Missing ApiKey!!! {{#x-codegen-apikey-env}}Define env variable {{x-codegen-apikey-env}} like 'export {{x-codegen-apikey-env}}=...' or{{/x-codegen-apikey-env}}{{^x-codegen-apikey-env}}You have to{{/x-codegen-apikey-env}} provide on command line option '{{keyParamName}}=...'"
exit 1
fi
continue
fi{{/isKeyInQuery}}{{/isApiKey}}{{/authMethods}}{{/hasAuthMethods}}
#
# Append parameters without specific cardinality
#
local collection_type="${operation_parameters_collection_type["${operation}:::${qparam}"]}"
if [[ "${collection_type}" == "" ]]; then
local vcount=0
for qvalue in "${parameter_values[@]}"; do
if [[ $((vcount++)) -gt 0 ]]; then
parameter_value+="&"
fi
parameter_value+="${qparam}=${qvalue}"
done
#
# Append parameters specified as 'mutli' collections i.e. param=value1¶m=value2&...
#
elif [[ "${collection_type}" == "multi" ]]; then
local vcount=0
for qvalue in "${parameter_values[@]}"; do
if [[ $((vcount++)) -gt 0 ]]; then
parameter_value+="&"
fi
parameter_value+="${qparam}=${qvalue}"
done
#
# Append parameters specified as 'csv' collections i.e. param=value1,value2,...
#
elif [[ "${collection_type}" == "csv" ]]; then
parameter_value+="${qparam}="
local vcount=0
for qvalue in "${parameter_values[@]}"; do
if [[ $((vcount++)) -gt 0 ]]; then
parameter_value+=","
fi
parameter_value+="${qvalue}"
done
#
# Append parameters specified as 'ssv' collections i.e. param="value1 value2 ..."
#
elif [[ "${collection_type}" == "ssv" ]]; then
parameter_value+="${qparam}="
local vcount=0
for qvalue in "${parameter_values[@]}"; do
if [[ $((vcount++)) -gt 0 ]]; then
parameter_value+=" "
fi
parameter_value+="${qvalue}"
done
#
# Append parameters specified as 'tsv' collections i.e. param="value1\tvalue2\t..."
#
elif [[ "${collection_type}" == "tsv" ]]; then
parameter_value+="${qparam}="
local vcount=0
for qvalue in "${parameter_values[@]}"; do
if [[ $((vcount++)) -gt 0 ]]; then
parameter_value+="\\t"
fi
parameter_value+="${qvalue}"
done
else
echo "Unsupported collection format \"${collection_type}\""
exit 1
fi
if [[ -n "${parameter_value}" ]]; then
if [[ -n "${query_request_part}" ]]; then
query_request_part+="&"
fi
query_request_part+="${parameter_value}"
fi
done
# Now append query parameters - if any
if [[ -n "${query_request_part}" ]]; then
path_template+="?${query_request_part}"
fi
echo "$path_template"
}
###############################################################################
#
# Print main help message
#
###############################################################################
print_help() {
cat <${OFF}]
[-ac|--accept ${GREEN}${OFF}] [-ct,--content-type ${GREEN}${OFF}]
[--host ${CYAN}${OFF}] [--dry-run] [-nc|--no-colors] ${YELLOW}${OFF} [-h|--help]
[${BLUE}${OFF}] [${MAGENTA}${OFF}] [${MAGENTA}${OFF}]
- ${CYAN}${OFF} - endpoint of the REST service without basepath
{{#x-codegen-host-env}} Can also be specified in {{x-codegen-host-env}} environment variable.{{/x-codegen-host-env}}
- ${RED}${OFF} - any valid cURL options can be passed before ${YELLOW}${OFF}
- ${GREEN}${OFF} - either full mime-type or one of supported abbreviations:
(text, html, md, csv, css, rtf, json, xml, yaml, js, bin,
rdf, jpg, png, gif, bmp, tiff)
- ${BLUE}${OFF} - HTTP headers can be passed in the form ${YELLOW}HEADER${OFF}:${BLUE}VALUE${OFF}
- ${MAGENTA}${OFF} - REST operation parameters can be passed in the following
forms:
* ${YELLOW}KEY${OFF}=${BLUE}VALUE${OFF} - path or query parameters
- ${MAGENTA}${OFF} - simple JSON body content (first level only) can be build
using the following arguments:
* ${YELLOW}KEY${OFF}==${BLUE}VALUE${OFF} - body parameters which will be added to body
JSON as '{ ..., "${YELLOW}KEY${OFF}": "${BLUE}VALUE${OFF}", ... }'
* ${YELLOW}KEY${OFF}:=${BLUE}VALUE${OFF} - body parameters which will be added to body
JSON as '{ ..., "${YELLOW}KEY${OFF}": ${BLUE}VALUE${OFF}, ... }'
EOF
{{#hasAuthMethods}}
echo -e "${BOLD}${WHITE}Authentication methods${OFF}"
echo -e ""
{{#authMethods}}
{{#isBasic}}
echo -e " - ${BLUE}Basic AUTH${OFF} - add '-u :' before ${YELLOW}${OFF}"
{{#x-codegen-basicauth-env}}echo -e " or export ${RED}{{x-codegen-basicauth-env}}=':'${OFF}"{{/x-codegen-basicauth-env}}
{{/isBasic}}
{{#isApiKey}}
{{#isKeyInHeader}}
echo -e " - ${BLUE}Api-key${OFF} - add '${RED}{{keyParamName}}:${OFF}' after ${YELLOW}${OFF}"
{{/isKeyInHeader}}
{{#isKeyInQuery}}
echo -e " - ${BLUE}Api-key${OFF} - add '${RED}{{keyParamName}}=${OFF}' after ${YELLOW}${OFF}"
{{/isKeyInQuery}}
{{#x-codegen-apikey-env}}echo -e " or export ${RED}{{x-codegen-apikey-env}}=''${OFF}"{{/x-codegen-apikey-env}}
{{/isApiKey}}
{{#isOAuth}}
echo -e " - ${MAGENTA}OAuth2 (flow: {{flow}})${OFF}"{{#authorizationUrl}}
echo -e " Authorization URL: "
echo -e " * {{authorizationUrl}}"{{/authorizationUrl}}{{#tokenUrl}}
echo -e " Token URL: "
echo -e " * {{tokenUrl}}"{{/tokenUrl}}
echo -e " Scopes:"
{{#scopes}}
echo -e " * {{scope}} - {{description}}"
{{/scopes}}
{{/isOAuth}}
{{/authMethods}}
echo ""
{{/hasAuthMethods}}
echo -e "${BOLD}${WHITE}Operations (grouped by tags)${OFF}"
{{#apiInfo}}
{{#apis}}
echo ""
echo -e "${BOLD}${WHITE}[{{classVarName}}]${OFF}"
read -r -d '' ops <${OFF}\\t\\t\\t\\tSpecify the host URL "
{{#openAPI}}
{{#host}}echo -e " \\t\\t\\t\\t(e.g. 'https://{{host}}')"{{/host}}
{{^host}}echo -e " \\t\\t\\t\\t(e.g. 'https://127.0.0.1:8080')"{{/host}}
{{/openAPI}}
echo -e " --force\\t\\t\\t\\tForce command invocation in spite of missing"
echo -e " \\t\\t\\t\\trequired parameters or wrong content type"
echo -e " --dry-run\\t\\t\\t\\tPrint out the cURL command without"
echo -e " \\t\\t\\t\\texecuting it"
echo -e " -nc,--no-colors\\t\\t\\tEnforce print without colors, otherwise autodected"
echo -e " -ac,--accept ${YELLOW}${OFF}\\t\\tSet the 'Accept' header in the request"
echo -e " -ct,--content-type ${YELLOW}${OFF}\\tSet the 'Content-type' header in "
echo -e " \\tthe request"
echo ""
}
##############################################################################
#
# Print REST service description
#
##############################################################################
print_about() {
echo ""
echo -e "${BOLD}${WHITE}{{appName}} command line client (API version {{#openAPI}}{{#info}}{{version}}{{/info}}{{/openAPI}})${OFF}"
echo ""
echo -e "License: {{#openAPI}}{{#info}}{{#license}}{{name}}{{/license}}{{/info}}{{/openAPI}}"
echo -e "Contact: {{#openAPI}}{{#info}}{{#contact}}{{email}}{{/contact}}{{/info}}{{/openAPI}}"
echo ""
read -r -d '' appdescription </dev/null 2>&1 || { echo >&2 "ERROR: You do not have 'cURL' installed."; exit 1; }
type sed >/dev/null 2>&1 || { echo >&2 "ERROR: You do not have 'sed' installed."; exit 1; }
type column >/dev/null 2>&1 || { echo >&2 "ERROR: You do not have 'bsdmainutils' installed."; exit 1; }
#
# Process command line
#
# Pass all arguments before 'operation' to cURL except the ones we override
#
take_user=false
take_host=false
take_accept_header=false
take_contenttype_header=false
for key in "$@"; do
# Take the value of -u|--user argument
if [[ "$take_user" = true ]]; then
basic_auth_credential="$key"
take_user=false
continue
fi
# Take the value of --host argument
if [[ "$take_host" = true ]]; then
host="$key"
take_host=false
continue
fi
# Take the value of --accept argument
if [[ "$take_accept_header" = true ]]; then
header_accept=$(lookup_mime_type "$key")
take_accept_header=false
continue
fi
# Take the value of --content-type argument
if [[ "$take_contenttype_header" = true ]]; then
header_content_type=$(lookup_mime_type "$key")
take_contenttype_header=false
continue
fi
case $key in
-h|--help)
if [[ "x$operation" == "x" ]]; then
print_help
exit 0
else
eval "print_${operation}_help"
exit 0
fi
;;
-V|--version)
print_version
exit 0
;;
--about)
print_about
exit 0
;;
-u|--user)
take_user=true
;;
--host)
take_host=true
;;
--force)
force=true
;;
-ac|--accept)
take_accept_header=true
;;
-ct|--content-type)
take_contenttype_header=true
;;
--dry-run)
print_curl=true
;;
-nc|--no-colors)
RED=""
GREEN=""
YELLOW=""
BLUE=""
MAGENTA=""
CYAN=""
WHITE=""
BOLD=""
OFF=""
result_color_table=( "" "" "" "" "" "" "" )
;;
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#operation}}
{{operationId}})
operation="{{operationId}}"
;;
{{/operation}}
{{/operations}}
{{/apis}}
{{/apiInfo}}
*==*)
# Parse body arguments and convert them into top level
# JSON properties passed in the body content as strings
if [[ "$operation" ]]; then
IFS='==' read -r body_key sep body_value <<< "$key"
body_parameters[${body_key}]="\"${body_value}\""
fi
;;
*:=*)
# Parse body arguments and convert them into top level
# JSON properties passed in the body content without qoutes
if [[ "$operation" ]]; then
# ignore error about 'sep' being unused
# shellcheck disable=SC2034
IFS=':=' read -r body_key sep body_value <<< "$key"
body_parameters[${body_key}]=${body_value}
fi
;;
+\([^=]\):*)
# Parse header arguments and convert them into curl
# only after the operation argument
if [[ "$operation" ]]; then
IFS=':' read -r header_name header_value <<< "$key"
{{#hasAuthMethods}}
{{#authMethods}}
{{#isApiKey}}
{{#isKeyInHeader}}
#
# If the header key is the same as the api_key expected by API in the
# header, override the ${apikey_auth_credential} variable
#
if [[ $header_name == "{{keyParamName}}" ]]; then
apikey_auth_credential=$header_value
fi
{{/isKeyInHeader}}
{{/isApiKey}}
{{/authMethods}}
{{/hasAuthMethods}}
header_arguments[$header_name]=$header_value
else
curl_arguments+=" $key"
fi
;;
-)
body_content_temp_file=$(mktemp)
cat - > "$body_content_temp_file"
;;
*=*)
# Parse operation arguments and convert them into curl
# only after the operation argument
if [[ "$operation" ]]; then
IFS='=' read -r parameter_name parameter_value <<< "$key"
if [[ -z "${operation_parameters[$parameter_name]+foo}" ]]; then
operation_parameters[$parameter_name]=$(url_escape "${parameter_value}")
else
operation_parameters[$parameter_name]+=":::"$(url_escape "${parameter_value}")
fi
else
curl_arguments+=" $key"
fi
;;
*)
# If we are before the operation, treat the arguments as cURL arguments
if [[ "x$operation" == "x" ]]; then
# Maintain quotes around cURL arguments if necessary
space_regexp="[[:space:]]"
if [[ $key =~ $space_regexp ]]; then
curl_arguments+=" \"$key\""
else
curl_arguments+=" $key"
fi
fi
;;
esac
done
# Check if user provided host name
if [[ -z "$host" ]]; then
ERROR_MSG="ERROR: No hostname provided!!! {{#x-codegen-host-env}}Define env variable {{x-codegen-host-env}} like 'export {{x-codegen-host-env}}=...' or{{/x-codegen-host-env}}{{^x-codegen-host-env}}You have to {{/x-codegen-host-env}} provide on command line option '--host ...'"
exit 1
fi
# Check if user specified operation ID
if [[ -z "$operation" ]]; then
ERROR_MSG="ERROR: No operation specified!!!"
exit 1
fi
# Run cURL command based on the operation ID
case $operation in
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#operation}}
{{operationId}})
call_{{operationId}}
;;
{{/operation}}
{{/operations}}
{{/apis}}
{{/apiInfo}}
*)
ERROR_MSG="ERROR: Unknown operation: $operation"
exit 1
esac
© 2015 - 2024 Weber Informatics LLC | Privacy Policy