{

# Variáveis locais

local _ERR_MESSAGE_ _ERR_ARG_VALUE_ _ERR_PARAM_ _ERR_CODE_ _DESCRIPTION_ _EXIT_

# A variável 'BASH_LINENO' é dinâmica e armazena o número da linha onde foi expandida.

# Quando chamada dentro de um subshell, passa ser instanciada como um array, armazenando diversos

# valores onde cada índice refere-se a um shell/subshell. As mesmas caracteristicas se aplicam a variável

# 'FUNCNAME', onde é armazenado o nome da função onde foi chamada.

local _LINE=${BASH_LINENO[1]} # Obtem o número da linha no shell pai.

local _FUNC=${FUNCNAME[1]} # Obtem o nome da função no shell pai.

# Lê o tipo de ocorrência do erro.

# TG - Erro externo, retornado pelo core do telegram

# API - Erro interno, gerado pela API ShellBot.

case $2 in

TG)

# Extrai as informações de erro no arquivo "update.json"

_ERR_CODE_=$(json $1 '.error_code')

_DESCRIPTION_=$(json $1 '.description')

_ERR_MESSAGE_="${_ERR_CODE_:-1}: ${_DESCRIPTION_:-Ocorreu um problema durante a tentativa de atualização.}"

;;

API)

# Define as variáveis com os valores passados na função "error.message"

_ERR_PARAM_="$4"

_ERR_ARG_VALUE_="$5"

# Insere um '-', caso o valor de '_ERR_PARAM_' e '_ERR_ARG_VALUE_' for nulo; Se não houver

# mensagem de erro, imprime 'Erro desconhecido'

_ERR_MESSAGE_="${_ERR_PARAM_:--}: ${_ERR_ARG_VALUE_:--}: ${3:-Erro desconhecido}"

_EXIT_=1

;;

esac

# Imprime mensagem de erro

echo "$_BOT_SCRIPT_: linha ${_LINE:--}: ${_FUNC:-NULL}: ${_ERR_MESSAGE_}" 1>&2

# Finaliza script em caso de erro interno, caso contrário retorna o valor $_STATUS_

[[ $_EXIT_ ]] && exit 1 || return 1

{

local _FUNCTION_ _CALLBACK_DATA_ _HANDLE_ _ARGS_

local _PARAM_=$(getopt --name $FUNCNAME --options 'f:a:d:' \

eval set -- "$_PARAM_"

while :

do

case $1 in

-f|--function)

# Verifica se a função especificada existe.

if ! declare -fp $2 &>/dev/null; then

message_error '' API "$_ERR_FUNCTION_NOT_FOUND_" "$1" "$2"

return 1

fi

_FUNCTION_="$2"

shift 2

;;

-a|--args)

_ARGS_="$2"

shift 2

;;

-d|--callback_data)

_CALLBACK_DATA_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

[[ $_FUNCTION_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-f, --function]"

[[ $_CALLBACK_DATA_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-d, --callback_data]"

# Testa se o indentificador armazenado em _HANDLE_ já existe. Caso já exista, repete

# o procedimento até que um handle válido seja gerado; Evitando sobreescrever handle's existentes.

until ! declare -fp $_HANDLE_ &>/dev/null; do

_HANDLE_=HandleID:$(tr -dc A-Za-z0-9_ < /dev/urandom | head -c15)

done

# Cria a função com o nome gerado e adiciona a chamada com os argumentos especificados.

# Anexa o novo handle a lista no índice associativo definindo em _CALLBACK_DATA_

eval "$_HANDLE_(){ $_FUNCTION_ $_ARGS_; }"

declare -Ag _LIST_REG_FUNC_HANDLE_

_LIST_REG_FUNC_HANDLE_[$_CALLBACK_DATA_]+="$_HANDLE_ "

return 0

{

local _CALLBACK_DATA_ \

_FUNC_HANDLE_ \

_PARAM_=$(getopt --name $FUNCNAME --options 'd' --longoptions 'callback_data' -- "$@")

eval set -- "$_PARAM_"

while :

do

case $1 in

-d|--callback_data)

shift 2

_CALLBACK_DATA_="$1"

;;

*)

shift

break

;;

esac

done

# O parâmetro callback_data é parcial, ou seja, Se o handle for válido, os elementos

# serão listados. Caso contrário a função é finalizada.

[[ $_CALLBACK_DATA_ ]] || return 1

# Lista todos os handles no índice _CALLBACK_DATA_ e executa-os

# consecutivamente. A ordem de execução das funções é determinada

# pela ordem de declaração.

for _FUNC_HANDLE_ in ${_LIST_REG_FUNC_HANDLE_[$_CALLBACK_DATA_]}; do

$_FUNC_HANDLE_; done # executa

# retorno

return 0

{

# Variável local

local _METHOD_=getWebhookInfo # Método

local _JSON_=$(getTMP $FUNCNAME)

# Chama o método getMe passando o endereço da API, seguido do nome do método.

eval $_GET_ $_API_TELEGRAM_/$_METHOD_ > $_JSON_

# Verifica o status de retorno do método

json_status $_JSON_ && {

# Retorna as informações armazenadas em "result".

json $_JSON_ '.result| .url,

.allowed_updates' | sed ':a;$!N;s/\n/|/;ta'

} || message_error $_JSON_ TG

return $?

{

# Variável local

local _METHOD_=deleteWebhook # Método

local _JSON_=$(getTMP $FUNCNAME)

# Chama o método getMe passando o endereço da API, seguido do nome do método.

eval $_POST_ $_API_TELEGRAM_/$_METHOD_ > $_JSON_

# Verifica o status de retorno do método

json_status $_JSON_ || message_error $_JSON_ TG

return $?

{

local _URL_ _CERTIFICATE_ _MAX_CONNECTIONS_ _ALLOWED_UPDATES_

local _METHOD_=setWebhook

local _JSON_=$(getTMP $FUNCNAME)

local _PARAM_=$(getopt --name $FUNCNAME --options 'u:c:m:a' \

eval set -- "$_PARAM_"

while :

do

case $1 in

-u|--url)

_URL_="$2"

shift 2

;;

-c|--certificate)

_CERTIFICATE_="$2"

shift 2

;;

-m|--max_connections)

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_MAX_CONNECTIONS_="$2"

shift 2

;;

-a|--allowed_updates)

_ALLOWED_UPDATES_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

[[ $_URL_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-u, --url]"

eval $_POST_ $_API_TELEGRAM_/$_METHOD_ ${_URL_:+-d url="'$_URL_'"} \

${_CERTIFICATE_:+-d certificate="'$_CERTIFICATE_'"} \

${_MAX_CONNECTIONS_:+-d max_connections="'$_MAX_CONNECTIONS_'"} \

${_ALLOWED_UPDATES_:+-d allowed_updates="'$_ALLOWED_UPDATES_'"} > $_JSON_

# Testa o retorno do método.

json_status $_JSON_ || message_error $_JSON_ TG

# Status

return $?

{

# Variável local

local _PARAM_=$(getopt --name $FUNCNAME --options 't:' \

# Define os parâmetros posicionais

eval set -- "$_PARAM_"

while :

do

case $1 in

-t|--token)

declare -gr _TOKEN_="$2" # TOKEN

# Visível em todo shell/subshell

declare -gr _API_TELEGRAM_=https://api.telegram.org/bot$_TOKEN_ # API

shift 2

;;

--)

shift

break

;;

esac

done

# Parâmetro obrigatório.

[[ $_TOKEN_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-t, --token]"

_BOT_INFO_=$(ShellBot.getMe 2>/dev/null) || message_error '' API "$_ERR_TOKEN_"

# Define o delimitador entre os campos.

IFSbkp=$IFS; IFS='|'

# Inicializa um array somente leitura contendo as informações do bot.

declare -gr _BOT_INFO_=($_BOT_INFO_)

# Restaura o delimitador

IFS=$IFSbkp

# Constroi as funções para as chamdas aos atributos do bot.

ShellBot.token() { echo "${_TOKEN_:-null}"; }

ShellBot.id() { echo "${_BOT_INFO_[0]:-null}"; }

ShellBot.username() { echo "${_BOT_INFO_[1]:-null}"; }

ShellBot.first_name() { echo "${_BOT_INFO_[2]:-null}"; }

ShellBot.last_name() { echo "${_BOT_INFO_[3]:-null}"; }

# Somente leitura.

declare -rf ShellBot.token

declare -rf ShellBot.id

declare -rf ShellBot.username

declare -rf ShellBot.first_name

declare -rf Shellbot.last_name

# status

return 0

{

# Variável local

local _METHOD_=getMe # Método

local _JSON_=$(getTMP $FUNCNAME)

# Chama o método getMe passando o endereço da API, seguido do nome do método.

eval $_GET_ $_API_TELEGRAM_/$_METHOD_ > $_JSON_

# Verifica o status de retorno do método

json_status $_JSON_ && {

# Retorna as informações armazenadas em "result".

json $_JSON_ '.result|.id,.username,.first_name,.last_name' | sed ':a;$!N;s/\n/|/;ta'

} || message_error $_JSON_ TG

return $?

{

local _BUTTON_ _LINE_ _TEXT_ _URL_ _CALLBACK_DATA_ \

_SWITCH_INLINE_QUERY_ _SWITCH_INLINE_QUERY_CURRENT_CHAT_ \

_DELM_

local _PARAM_=$(getopt --name $FUNCNAME --options 'b:l:t:u:c:q:s:' \

eval set -- "$_PARAM_"

while :

do

case $1 in

-b|--button)

# Ponteiro que recebe o endereço de "button" com as definições

# da configuração do botão inserido.

_BUTTON_="$2"

shift 2

;;

-l|--line)

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_LINE_="$2"

shift 2

;;

-t|--text)

_TEXT_="$2"

shift 2

;;

-u|--url)

_URL_="$2"

shift 2

;;

-c|--callback_data)

_CALLBACK_DATA_="$2"

shift 2

;;

-q|--switch_inline_query)

_SWITCH_INLINE_QUERY_="$2"

shift 2

;;

-s|--switch_inline_query_current_chat)

_SWITCH_INLINE_QUERY_CURRENT_CHAT_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

[[ $_BUTTON_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "-b, --button"

[[ $_TEXT_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "-t, --text"

[[ $_CALLBACK_DATA_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "-c, --callback_data"

[[ $_LINE_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "-l, --line"

# Inicializa a variável armazenada em _BUTTON_, definindo seu

# escopo como global, tornando-a visível em todo o projeto (source)

# O ponteiro _BUTTON_ recebe o endereço do botão armazenado.

declare -g $_BUTTON_

declare -n _BUTTON_ # Ponteiro

# Abre o array para receber o novo objeto

_BUTTON_[$_LINE_]="${_BUTTON_[$_LINE_]#[}"

_BUTTON_[$_LINE_]="${_BUTTON_[$_LINE_]%]}"

# Verifica se já existe um botão na linha especificada.

[[ ${_BUTTON_[$_LINE_]} ]] && _DELM_=','

# Salva as configurações do botão.

#

# Obrigatório: text, callback_data

# Opcional: url, switch_inline_query, switch_inline_query_current_chat

_BUTTON_[$_LINE_]+="${_DELM_}{

}" || return 1 # Erro ao salvar o botão.

# Fecha o array

_BUTTON_[$_LINE_]="${_BUTTON_[$_LINE_]/#/[}"

_BUTTON_[$_LINE_]="${_BUTTON_[$_LINE_]/%/]}"

# retorno

return 0

}

ShellBot.InlineKeyboardMarkup()

{

local _BUTTON_ _TEMP_KB_

local _PARAM_=$(getopt --name $FUNCNAME --options 'b:' --longoptions 'button:' -- "$@")

eval set -- "$_PARAM_"

while :

do

case $1 in

-b|--button)

# Ponteiro que recebe o endereço da variável "teclado" com as definições

# de configuração do botão inserido.

_BUTTON_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

[[ $_BUTTON_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "-b, --button"

# Ponteiro

declare -n _BUTTON_

# Salva todos elementos do array do teclado, convertendo-o em uma variável de índice 0.

# Cria-se uma estrutura do tipo 'inline_keyboard' e anexa os botões e fecha a estrutura.

# O ponteiro matriz é limpo para receber a nova estrutura contendo o layout do objeto.

# O tipo 'inline_keyboard' é definido, adicionando os botões separando-os pelo delimitador

# ',' vírgula. A posição dos botões é determinada pelo índice da linha na inicilização.

#

# Exemplo:

#

# Linha array

#

# 1 [inline_botao1] [inline_botao2] [inline_botao3]

# 2 [inline_botao4] [inline_botao5]

# 3 [inline_botao7]

_KEYBOARD_="${_BUTTON_[@]}" || return 1

# Cria estrutura do teclado

_KEYBOARD_="${_KEYBOARD_/#/{\"inline_keyboard\":[}"

_KEYBOARD_="${_KEYBOARD_//]/],}"

_KEYBOARD_="${_KEYBOARD_%,}"

_KEYBOARD_="${_KEYBOARD_/%/]\}}"

# Retorna a estrutura

echo $_KEYBOARD_

# status

return 0

}

ShellBot.answerCallbackQuery()

{

local _CALLBACK_QUERY_ID_ _TEXT_ _SHOW_ALERT_ _URL_ _CACHE_TIME_

local _METHOD_=answerCallbackQuery # Método

local _JSON_=$(getTMP $FUNCNAME)

local _PARAM_=$(getopt --name $FUNCNAME --options 'c:t:s:u:e:' \

eval set -- "$_PARAM_"

while :

do

case $1 in

-c|--callback_query_id)

_CALLBACK_QUERY_ID_="$2"

shift 2

;;

-t|--text)

_TEXT_="$2"

shift 2

;;

-s|--show_alert)

# boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_SHOW_ALERT_="$2"

shift 2

;;

-u|--url)

_URL_="$2"

shift 2

;;

-e|--cache_time)

# inteiro

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_CACHE_TIME_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

[[ $_CALLBACK_QUERY_ID_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "-c, --callback_query_id"

eval $_POST_ $_API_TELEGRAM_/$_METHOD_ ${_CALLBACK_QUERY_ID_:+-d callback_query_id="'$_CALLBACK_QUERY_ID_'"} \

${_TEXT_:+-d text="'$_TEXT_'"} \

${_SHOW_ALERT_:+-d show_alert="'$_SHOW_ALERT_'"} \

${_URL_:+-d url="'$_URL_'"} \

${_CACHE_TIME_:+-d cache_time="'$_CACHE_TIME_'"} > $_JSON_

json_status $_JSON_ || message_error $_JSON_ TG

return $?

}

ShellBot.ReplyKeyboardMarkup()

{

# Variáveis locais

local _BUTTON_ _RESIZE_KEYBOARD_ _ON_TIME_KEYBOARD_ _SELECTIVE_

# Lê os parâmetros da função.

local _PARAM_=$(getopt --name $FUNCNAME --options 'b:r:t:s:' \

# Transforma os parâmetros da função em parâmetros posicionais

#

# Exemplo:

# --param1 arg1 --param2 arg2 --param3 arg3 ...

# $1 $2 $3

eval set -- "$_PARAM_"

# Aguarda leitura dos parâmetros

while :

do

# Lê o parâmetro da primeira posição "$1"; Se for um parâmetro válido,

# salva o valor do argumento na posição '$2' e desloca duas posições a esquerda (shift 2); Repete o processo

# até que o valor de '$1' seja igual '--' e finaliza o loop.

case $1 in

-b|--button)

_BUTTON_="$2"

shift 2

;;

-r|--resize_keyboard)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_RESIZE_KEYBOARD_="$2"

shift 2

;;

-t|--one_time_keyboard)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_ON_TIME_KEYBOARD_="$2"

shift 2

;;

-s|--selective)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_SELECTIVE_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

# Imprime mensagem de erro se o parâmetro obrigatório for omitido.

[[ $_BUTTON_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "-b, --button"

# Ponteiro

declare -n _BUTTON_

# Constroi a estrutura dos objetos + array keyboard, define os valores e salva as configurações.

# Por padrão todos os valores são 'false', até que seja definido.

cat << _EOF

# status

return 0

}

ShellBot.sendMessage()

{

# Variáveis locais

local _CHAT_ID_ _TEXT_ _PARSE_MODE_ _DISABLE_WEB_PAGE_PREVIEW_ _DISABLE_NOTIFICATION_ _REPLY_TO_MESSAGE_ID_ _REPLY_MARKUP_

local _METHOD_=sendMessage # Método

local _JSON_=$(getTMP $FUNCNAME)

# Lê os parâmetros da função

local _PARAM_=$(getopt --name $FUNCNAME --options 'c:t:p:w:n:r:k:' \

# Define os parâmetros posicionais

eval set -- "$_PARAM_"

while :

do

case $1 in

-c|--chat_id)

_CHAT_ID_="$2"

shift 2

;;

-t|--text)

_TEXT_="$2"

shift 2

;;

-p|--parse_mode)

# Tipo: "markdown" ou "html"

[[ "$2" =~ ^(markdown|html)$ ]] || message_error '' API "$_ERR_TYPE_PARSE_MODE_" "$1" "$2"

_PARSE_MODE_="$2"

shift 2

;;

-w|--disable_web_page_preview)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_DISABLE_WEB_PAGE_PREVIEW_="$2"

shift 2

;;

-n|--disable_notification)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_DISABLE_NOTIFICATION_="$2"

shift 2

;;

-r|--reply_to_message_id)

# Tipo: inteiro

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_REPLY_TO_MESSAGE_ID_="$2"

shift 2

;;

-k|--reply_markup)

_REPLY_MARKUP_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

# Parâmetros obrigatórios.

[[ $_CHAT_ID_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-c, --chat_id]"

[[ $_TEXT_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-t, --text]"

# Chama o método da API, utilizando o comando request especificado; Os parâmetros

# e valores são passados no form e lidos pelo método. O retorno do método é redirecionado para o arquivo 'update.json'.

# Variáveis com valores nulos são ignoradas e consequentemente os respectivos parâmetros omitidos.

eval $_POST_ $_API_TELEGRAM_/$_METHOD_ ${_CHAT_ID_:+-d chat_id="'$_CHAT_ID_'"} \

${_TEXT_:+-d text="'$_TEXT_'"} \

${_PARSE_MODE_:+-d parse_mode="'$_PARSE_MODE_'"} \

${_DISABLE_WEB_PAGE_PREVIEW_:+-d disable_web_page_preview="'$_DISABLE_WEB_PAGE_PREVIEW_'"} \

${_DISABLE_NOTIFICATION_:+-d disable_notification="'$_DISABLE_NOTIFICATION_'"} \

${_REPLY_TO_MESSAGE_ID_:+-d reply_to_message_id="'$_REPLY_TO_MESSAGE_ID_'"} \

${_REPLY_MARKUP_:+-d reply_markup="'$_REPLY_MARKUP_'"} > $_JSON_

# Testa o retorno do método.

json_status $_JSON_ || message_error $_JSON_ TG

# Status

return $?

}

ShellBot.forwardMessage()

{

# Variáveis locais

local _CHAT_ID_ _FORM_CHAT_ID_ _DISABLE_NOTIFICATION_ _MESSAGE_ID_

local _JSON_=$(getTMP $FUNCNAME)

local _METHOD_=forwardMessage # Método

# Lê os parâmetros da função

local _PARAM_=$(getopt --name $FUNCNAME --options 'c:f:n:m:' \

# Define os parâmetros posicionais

eval set -- "$_PARAM_"

while :

do

case $1 in

-c|--chat_id)

_CHAT_ID_="$2"

shift 2

;;

-f|--from_chat_id)

_FROM_CHAT_ID_="$2"

shift 2

;;

-n|--disable_notification)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_DISABLE_NOTIFICATION_="$2"

shift 2

;;

-m|--message_id)

# Tipo: inteiro

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_MESSAGE_ID_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

# Parâmetros obrigatórios.

[[ $_CHAT_ID_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-c, --chat_id]"

[[ $_FROM_CHAT_ID_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-f, --from_chat_id]"

[[ $_MESSAGE_ID_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-m, --message_id]"

# Chama o método

eval $_POST_ $_API_TELEGRAM_/$_METHOD_ ${_CHAT_ID_:+-d chat_id="'$_CHAT_ID_'"} \

${_FROM_CHAT_ID_:+-d from_chat_id="'$_FROM_CHAT_ID_'"} \

${_DISABLE_NOTIFICATION_:+-d disable_notification="'$_DISABLE_NOTIFICATION_'"} \

${_MESSAGE_ID_:+-d message_id="'$_MESSAGE_ID_'"} > $_JSON_

# Retorno do método

json_status $_JSON_ || message_error $_JSON_ TG

# status

return $?

}

ShellBot.sendPhoto()

{

# Variáveis locais

local _CHAT_ID_ _PHOTO_ _CAPTION_ _DISABLE_NOTIFICATION_ _REPLY_TO_MESSAGE_ID_ _REPLY_MARKUP_

local _JSON_=$(getTMP $FUNCNAME)

local _METHOD_=sendPhoto # Método

# Lê os parâmetros da função

local _PARAM_=$(getopt --name $FUNCNAME --options 'c:p:t:n:r:k:' \

# Define os parâmetros posicionais

eval set -- "$_PARAM_"

while :

do

case $1 in

-c|--chat_id)

_CHAT_ID_="$2"

shift 2

;;

-p|--photo)

_PHOTO_="$2"

shift 2

;;

-t|--caption)

# Limite máximo de caracteres: 200

_CAPTION_="$2"

shift 2

;;

-n|--disable_notification)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_DISABLE_NOTIFICATION_="$2"

shift 2

;;

-r|--reply_to_message_id)

# Tipo: inteiro

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_REPLY_TO_MESSAGE_ID_="$2"

shift 2

;;

-k|--reply_markup)

_REPLY_MARKUP_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

# Parâmetros obrigatórios

[[ $_CHAT_ID_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-c, --chat_id]"

[[ $_PHOTO_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-p, --photo]"

# Chama o método

eval $_POST_ $_API_TELEGRAM_/$_METHOD_ ${_CHAT_ID_:+-F chat_id="'$_CHAT_ID_'"} \

${_PHOTO_:+-F photo="'$_PHOTO_'"} \

${_CAPTION_:+-F caption="'$_CAPTION_'"} \

${_DISABLE_NOTIFICATION_:+-F disable_notification="'$_DISABLE_NOTIFICATION_'"} \

${_REPLY_TO_MESSAGE_ID_:+-F reply_to_message_id="'$_REPLY_TO_MESSAGE_ID_'"} \

${_REPLY_MARKUP_:+-F reply_markup="'$_REPLY_MARKUP_'"} > $_JSON_

# Retorno do método

json_status $_JSON_ || message_error $_JSON_ TG

# Status

return $?

}

ShellBot.sendAudio()

{

# Variáveis locais

local _CHAT_ID_ _AUDIO_ _CAPTION_ _DURATION_ _PERFORMER_ _TITLE_ _DISABLE_NOTIFICATION_ _REPLY_TO_MESSAGE_ID_ _REPLY_MARKUP_

local _JSON_=$(getTMP $FUNCNAME)

local _METHOD_=sendAudio # Método

# Lê os parâmetros da função

local _PARAM_=$(getopt --name $FUNCNAME --options 'c:a:t:d:e:i:n:r:k' \

# Define os parâmetros posicionais

eval set -- "$_PARAM_"

while :

do

case $1 in

-c|--chat_id)

_CHAT_ID_="$2"

shift 2

;;

-a|--audio)

_AUDIO_="$2"

shift 2

;;

-t|--caption)

_CAPTION_="$2"

shift 2

;;

-d|--duration)

# Tipo: inteiro

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_DURATION_="$2"

shift 2

;;

-e|--performer)

_PERFORMER_="$2"

shift 2

;;

-i|--title)

_TITLE_="$2"

shift 2

;;

-n|--disable_notification)

# Tipo: boolean

[[ "$2" =~ ^(true|false)$ ]] || message_error '' API "$_ERR_TYPE_BOOL_" "$1" "$2"

_DISABLE_NOTIFICATION_="$2"

shift 2

;;

-r|--reply_to_message_id)

# Tipo: inteiro

[[ "$2" =~ ^[0-9]+$ ]] || message_error '' API "$_ERR_TYPE_INT_" "$1" "$2"

_REPLY_TO_MESSAGE_ID_="$2"

shift 2

;;

-k|--reply_markup)

_REPLY_MARKUP_="$2"

shift 2

;;

--)

shift

break

;;

esac

done

# Parâmetros obrigatórios

[[ $_CHAT_ID_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-c, --chat_id]"

[[ $_AUDIO_ ]] || message_error '' API "$_ERR_PARAM_REQUIRED_" "[-a, --audio]"

# Chama o método