telegram-bot-bash/bashbot.sh

#!/bin/bash
##################################################################
#
# File: bashbot.sh 
# Note: DO NOT EDIT! this file will be overwritten on update
# shellcheck disable=SC2140,SC2031,SC2120,SC1091,SC1117,SC2059
#
# Description: bashbot, the Telegram bot written in bash.
#
#     Written by Drew (@topkecleon) KayM (@gnadelwartz).
#     Also contributed: Daniil Gentili (@danog), JuanPotato, BigNerd95,
#                       TiagoDanin, iicc1, dcoomber
#     https://github.com/topkecleon/telegram-bot-bash
#
#     This file is public domain in the USA and all free countries.
#     Elsewhere, consider it to be WTFPLv2. (wtfpl.net/txt/copying)
#
# Usage: bashbot.sh BOTCOMMAND
BOTCOMMANDS="-h  help  init  start  stop  status  suspendback  resumeback  killback"
#
# Exit Codes:
#     0 - success (hopefully)
#     1 - can't change to dir
#     2 - can't write to tmp, count or token
#     3 - user / command / file not found
#     4 - unknown command
#     5 - cannot start, stop or get status
#     6 - mandatory module not found
#     7 - can't get bottoken
#     8 - curl/wget missing
#     10 - not bash!
#
#### $$VERSION$$ v1.35-dev-2-g1fe22a0
##################################################################

# emmbeded system may claim bash but it is not
# check for bash like ARRAY handlung
if ! (unset a; set -A a a; eval "a=(a b)"; eval '[ -n "${a[1]}" ]'; ) > /dev/null 2>&1; then
	printf "Error: Current shell does not support ARRAY's, may be busybox ash shell. pls install a real bash!\n"
	exit 10
fi

# are we running in a terminal?
NN="\n"
if [ -t 1 ] && [ -n "${TERM}" ];  then
    INTERACTIVE='yes'
    RED='\e[31m'
    GREEN='\e[32m'
    ORANGE='\e[35m'
    GREY='\e[1;30m'
    NC='\e[0m'
    NN="${NC}\n"
fi

# telegram uses utf-8 characters, check if we have an utf-8 charset
if [ "${LANG}" = "${LANG%[Uu][Tt][Ff]*}" ]; then
	printf "${ORANGE}Warning: Telegram uses utf-8, but looks like you are using non utf-8 locale:${NC} ${LANG}\n"
fi

# we need some bash 4+ features, check for old bash by feature
if [ "$({ LC_ALL=C.utf-8 printf "%b" "\u1111"; } 2>/dev/null)" = "\u1111" ]; then
	printf "${ORANGE}Warning: Missing unicode '\uxxxx' support, missing C.utf-8 locale or to old bash version.${NN}"
fi


# in UTF-8 äöü etc. are part of [:alnum:] and ranges (e.g. a-z), but we want ASCII a-z ranges!
# for more information see  doc/4_expert.md#Character_classes
azazaz='abcdefghijklmnopqrstuvwxyz'	# a-z   :lower:
AZAZAZ='ABCDEFGHIJKLMNOPQRSTUVWXYZ'	# A-Z   :upper:
o9o9o9='0123456789'			# 0-9   :digit:
azAZaz="${azazaz}${AZAZAZ}"	# a-zA-Z	:alpha:
azAZo9="${azAZaz}${o9o9o9}"	# a-zA-z0-9	:alnum:

# some important helper functions
# returns true if command exist
_exists() {
	[ "$(type -t "$1")" = "file" ]
}
# execute function if exists
_exec_if_function() {
	[ "$(type -t "$1")" != "function" ] && return 1
	"$@"
}
# returns true if function exist
_is_function() {
	[ "$(type -t "$1")" = "function" ]
}
# round $1 in international notation! , returns float with $2 decimal digits
# if $2 is not given or is not a positive number zero is assumed
_round_float() {
	local digit="$2"; [[ "$2" =~ ^[${o9o9o9}]+$ ]] || digit="0"
	: "$(LC_ALL=C printf "%.${digit}f" "$1" 2>/dev/null)"
	printf "%s" "${_//,/.}"	# make more LANG independent
}
# date is external, printf is much faster
_date(){
	printf "%(%c)T\n" -1
}
setConfigKey() {
	[[ "$1" =~ ^[-${azAZo9},._]+$ ]] || return 3
	[ -z "${BOTCONFIG}" ] && return 1
	printf '["%s"]\t"%s"\n' "${1//,/\",\"}" "${2//\"/\\\"}" >>"${BOTCONFIG}.jssh"
}
getConfigKey() {
	[[ "$1" =~ ^[-${azAZo9},._]+$ ]] || return 3
	[ -r "${BOTCONFIG}.jssh" ] && sed -n 's/\["'"$1"'"\]\t*"\(.*\)"/\1/p' "${BOTCONFIG}.jssh" | tail -n 1
}
# escape / remove text characters for json strings, eg. " -> \" 
# $1 string
# output escaped string
JsonEscape(){
	sed 's/\([-"`´,§$%&/(){}#@!?*.\t]\)/\\\1/g' <<< "$1"
}
# check if $1 seems a valid token
# return true if token seems to be valid
check_token(){
	[[ "$1" =~ ^[${o9o9o9}]{8,10}:[${azAZo9}_-]{35}$ ]] && return 0
	return 1
}
# log $1 with date
log_error(){ printf "%(%c)T: %s\n" -1 "$*" >>"${ERRORLOG}"; }
log_debug(){ printf "%(%c)T: %s\n" -1 "$*" >>"${DEBUGLOG}"; }
log_update(){ printf "%(%c)T: %s\n" -1 "$*" >>"${UPDATELOG}"; }
# log $1 with date, special first \n
log_message(){ printf "\n%(%c)T: %s\n" -1 "${1/\\n/$'\n'}" >>"${MESSAGELOG}"; }
# curl is preferred, try detect curl even not in PATH
# sets BASHBOT_CURL to point to curl
DETECTED_CURL="curl"
detect_curl() {
	local file warn="Warning: Curl not detected, try fallback to wget! pls install curl or adjust BASHBOT_CURL/BASHBOT_WGET environment variables."
	# custom curl command
	[ -n "${BASHBOT_CURL}" ] && return 0
	# use wget
	[ -n "${BASHBOT_WGET}" ] && DETECTED_CURL="wget" && return 1
	# default use curl in PATH
	BASHBOT_CURL="curl"
	_exists curl && return 0
	# search in usual locations
	for file in /usr/bin /bin /usr/local/bin; do
		[ -x "${file}/curl" ] && BASHBOT_CURL="${file}/curl" && return 0
	done
	# curl not in PATH and not in usual locations
	DETECTED_CURL="wget"
	log_update "${warn}"; [ -n "${BASHBOTDEBUG}" ] && log_debug "${warn}"
	return 1
}

# additional tests if we run in debug mode
export BASHBOTDEBUG
[[ "${BASH_ARGV[0]}" == *"debug"* ]] && BASHBOTDEBUG="yes"

# $1 where $2 command $3 may debug 
# shellcheck disable=SC2094
debug_checks(){ {
	[  -z "${BASHBOTDEBUG}" ] && return
	local token where="$1"; shift
	printf "%(%c)T: debug_checks: %s: bashbot.sh %s\n" -1 "${where}" "${1##*/}"
	# shellcheck disable=SC2094
	[ -z "${DEBUGLOG}" ] && printf "%(%c)T: %s\n" -1 "DEBUGLOG not set! =========="
	token="$(getConfigKey "bottoken")"
	[ -z "${token}" ] && printf "%(%c)T: %s\n" -1 "Bot token is missing! =========="
	check_token "${token}" || printf "%(%c)T: %s\n%s\n" -1 "Invalid bot token! ==========" "${token}"
	[ -z "$(getConfigKey "botadmin")" ] && printf "%(%c)T: %s\n" -1 "Bot admin is missing! =========="
	# call user defined debug_checks if exists
	_exec_if_function my_debug_checks "$(_date)" "${where}" "$*"
	} >>"${DEBUGLOG}"
}

# some Linux distributions (e.g. Manjaro) doesn't seem to have C locale activated by default
if _exists locale && [ "$(locale -a | grep -c -e "^C$" -e "^C.[uU][tT][fF]")" -lt 2 ]; then
	printf "${ORANGE}Warning: locale ${NC}${GREY}C${NC}${ORANGE} and/or ${NC}${GREY}C.utf8${NC}${ORANGE} seems missing, use \"${NC}${GREY}locale -a${NC}${ORANGE}\" to show what locales are installed on your system.${NN}"
fi

# get location and name of bashbot.sh
SCRIPT="$0"
REALME="${BASH_SOURCE[0]}"
SCRIPTDIR="$(dirname "${REALME}")"
RUNDIR="$(dirname "$0")"

MODULEDIR="${SCRIPTDIR}/modules"

# adjust locations based on source and real name
[[ "${SCRIPT}" != "${REALME}" || "$1" == "source" ]] && SOURCE="yes"

if [ -n "${BASHBOT_HOME}" ]; then
	SCRIPTDIR="${BASHBOT_HOME}"
 else
	BASHBOT_HOME="${SCRIPTDIR}"
fi
[ -z "${BASHBOT_ETC}" ] && BASHBOT_ETC="${BASHBOT_HOME}"
[ -z "${BASHBOT_VAR}" ] && BASHBOT_VAR="${BASHBOT_HOME}"

ADDONDIR="${BASHBOT_ETC:-.}/addons"
RUNUSER="${USER}"	# USER is overwritten by bashbot array :-(, save original

# provide help
case "$1" in
	"") [ -z "${SOURCE}" ] && printf "${ORANGE}Available commands: ${GREY}${BOTCOMMANDS}${NN}" && exit
		;;
	"-h"*)	LOGO="${BASHBOT_HOME:-.}/doc/bashbot.ascii"
		{ [ -r "${LOGO}" ] && cat "${LOGO}"
		sed -nE -e '/(NOT EDIT)|(shellcheck)/d' -e '3,/###/p' "$0"; } | more
		exit;;
	"help") HELP="${BASHBOT_HOME:-.}/README"
		if [ -n "${INTERACTIVE}" ];then
			_exists w3m && w3m "${HELP}.html" && exit
			_exists lynx && lynx "${HELP}.html" && exit
			_exists less && less "${HELP}.txt" && exit
		fi
		cat "${HELP}.txt"
		exit;;
esac

# OK, ENVIRONMENT is set up, let's do some additional tests
if [[ -z "${SOURCE}" && -z "${BASHBOT_HOME}" ]] && ! cd "${RUNDIR}" ; then
	printf "${RED}ERROR: Can't change to ${RUNDIR} ...${NN}"
	exit 1
fi
RUNDIR="."
[ ! -w "." ] && printf "${ORANGE}WARNING: ${RUNDIR} is not writeable!${NN}"

# check if JSON.sh is available
JSONSHFILE="${BASHBOT_JSONSH:-${SCRIPTDIR}/JSON.sh/JSON.sh}"
[ ! -x "${JSONSHFILE}" ] &&\
	 printf "${RED}ERROR:${NC} ${JSONSHFILE} ${RED}does not exist, are we in dev environment?${NN}${GREY}%s${NN}\n"\
		"\$JSONSHFILE is set wrong or bashbot is not installed correctly, see doc/0_install.md" && exit 3

# file locations based on ENVIRONMENT
BOTCONFIG="${BASHBOT_ETC:-.}/botconfig"
BOTACL="${BASHBOT_ETC:-.}/botacl"
DATADIR="${BASHBOT_VAR:-.}/data-bot-bash"
BLOCKEDFILE="${BASHBOT_VAR:-.}/blocked"
COUNTFILE="${BASHBOT_VAR:-.}/count"

LOGDIR="${RUNDIR:-.}/logs"

# CREATE botconfig if not exist
# assume everything already set up correctly if TOKEN is set
if [ -z "${BOTTOKEN}" ]; then
  # BOTCONFIG does not exist, create
  [ ! -f "${BOTCONFIG}.jssh" ] && printf '["bot_config_key"]\t"config_key_value"\n' >>"${BOTCONFIG}.jssh"
  if [ -z "$(getConfigKey "bottoken")" ]; then
    # ask user for bot token
    if [ -z "${INTERACTIVE}" ] && [ "$1" != "init" ]; then
	printf "Running headless, set BOTTOKEN or run ${SCRIPT} init first!\n"
	exit 2 
    else
	printf "${RED}ENTER BOT TOKEN...${NN}${ORANGE}PLEASE WRITE YOUR TOKEN HERE OR PRESS CTRL+C TO ABORT${NN}"
	read -r token
	printf "\n"
    fi
    [ -n "${token}" ] && printf '["bottoken"]\t"%s"\n'  "${token}" >> "${BOTCONFIG}.jssh"
  fi
  # no botadmin, setup botadmin
  if [ -z "$(getConfigKey "botadmin")" ]; then
     # ask user for bot admin
     if [ -z "${INTERACTIVE}" ]; then
	printf "Running headless, set botadmin to AUTO MODE!\n"
     else
	printf "${RED}ENTER BOT ADMIN...${NN}${ORANGE}PLEASE WRITE YOUR TELEGRAM ID HERE OR PRESS ENTER\nTO MAKE FIRST USER TYPING '/start' BOT ADMIN${NN}?\b"
	read -r admin
     fi
     [ -z "${admin}" ] && admin='?'
     printf '["botadmin"]\t"%s"\n'  "${admin}" >> "${BOTCONFIG}.jssh"
  fi
  # setup botacl file
  if [ ! -f "${BOTACL}" ]; then
	printf "${GREY}Create initial ${BOTACL} file.${NN}"
	printf '\n' >"${BOTACL}"
  fi
  # check data dir file
  if [ ! -w "${DATADIR}" ]; then
	printf "${RED}ERROR: ${DATADIR} does not exist or is not writeable!.${NN}"
	exit 2
  fi
  # setup count file 
  if [ ! -f "${COUNTFILE}.jssh" ]; then
	printf '["counted_user_chat_id"]\t"num_messages_seen"\n' >> "${COUNTFILE}.jssh"
  elif [ ! -w "${COUNTFILE}.jssh" ]; then
	printf "${RED}ERROR: Can't write to ${COUNTFILE}!.${NN}"
	ls -l "${COUNTFILE}.jssh"
	exit 2
  fi
  # setup blocked file 
  if [ ! -f "${BLOCKEDFILE}.jssh" ]; then
	printf '["blocked_user_or_chat_id"]\t"name and reason"\n' >>"${BLOCKEDFILE}.jssh"
  fi
fi

if [[ ! -d "${LOGDIR}" || ! -w "${LOGDIR}" ]]; then
	LOGDIR="${RUNDIR:-.}"
fi
DEBUGLOG="${LOGDIR}/DEBUG.log"
ERRORLOG="${LOGDIR}/ERROR.log"
UPDATELOG="${LOGDIR}/BASHBOT.log"
MESSAGELOG="${LOGDIR}/MESSAGE.log"

# read BOTTOKEN from bot database if not set
if [ -z "${BOTTOKEN}" ]; then
    BOTTOKEN="$(getConfigKey "bottoken")"
    if [ -z "${BOTTOKEN}" ]; then
		BOTERROR="Warning: can't get bot token, try to recover working config..."
		printf "${ORANGE}${BOTERROR}${NC} "
		if [ -r "${BOTCONFIG}.jssh.ok" ]; then
			log_error "${BOTERROR}"
			mv "${BOTCONFIG}.jssh" "${BOTCONFIG}.jssh.bad"
			cp "${BOTCONFIG}.jssh.ok" "${BOTCONFIG}.jssh"; printf "OK\n"
			BOTTOKEN="$(getConfigKey "bottoken")"
		else
			printf "\n${RED}Error: Can't recover from missing bot token! Remove ${BOTCONFIG}.jssh and run${NC} bashbot.sh init\n"
			exit 7
		fi
    fi
fi

# BOTTOKEN format checks
if ! check_token "${BOTTOKEN}"; then
	printf "\n${ORANGE}Warning: Your bot token is incorrect, it should have the following format:${NC}\n%b%b"\
		"<your_bot_id>${RED}:${NC}<35_alphanumeric_characters-hash> ${RED}e.g. =>${NC} 123456789${RED}:${NC}Aa-Zz_0Aa-Zz_1Aa-Zz_2Aa-Zz_3Aa-Zz_4\n\n"\
		"${GREY}Your bot token: '${NC}${BOTTOKEN//:/${RED}:${NC}}'\n"

	if [[ ! "${BOTTOKEN}" =~ ^[${o9o9o9}]{8,10}: ]]; then
		printf "${GREY}\tHint: Bot id not a number or wrong len: ${NC}$(($(wc -c <<<"${BOTTOKEN%:*}")-1)) ${GREY}but should be${NC} 8-10\n"
		[ -n "$(getConfigKey "botid")" ] && printf "\t${GREEN}Did you mean: \"${NC}$(getConfigKey "botid")${GREEN}\" ?${NN}"
	fi
	[[ ! "${BOTTOKEN}" =~ :[${azAZo9}_-]{35}$ ]] &&\
		printf "${GREY}\tHint: Hash contains invalid character or has not len${NC} 35 ${GREY}, hash len is ${NC}$(($(wc -c <<<"${BOTTOKEN#*:}")-1))\n"
	printf "\n"
fi


##################
# here we start with the real stuff
BASHBOT_RETRY=""	# retry by default

URL="${BASHBOT_URL:-https://api.telegram.org/bot}${BOTTOKEN}"
ME_URL=${URL}'/getMe'

#################
# BASHBOT COMMON functions

declare -rx SCRIPT SCRIPTDIR MODULEDIR RUNDIR ADDONDIR BOTACL DATADIR COUNTFILE
declare -rx BOTTOKEN URL ME_URL

declare -ax CMD
declare -Ax UPD BOTSENT USER MESSAGE URLS CONTACT LOCATION CHAT FORWARD REPLYTO VENUE iQUERY iBUTTON
declare -Ax SERVICE NEWMEMBER LEFTMEMBER PINNED MIGRATE
export res CAPTION ME


###############
# load modules
for module in "${MODULEDIR:-.}"/*.sh ; do
	# shellcheck source=./modules/aliases.sh
	if ! _is_function "$(basename "${module}")" && [ -r "${module}" ]; then source "${module}" "source"; fi
done

##################
# read commands file if we are not sourced
COMMANDS="${BASHBOT_ETC:-.}/commands.sh"
if [  -r "${COMMANDS}" ]; then
	# shellcheck source=./commands.sh
	 source "${COMMANDS}" "source"
else
	[ -z "${SOURCE}" ] && printf "${RED}Warning: ${COMMANDS} does not exist or is not readable!.${NN}"
fi
debug_checks "start SOURCE=${SOURCE:-no}" "$@"


#####################
# BASHBOT INTERNAL functions
#

# do we have BSD sed
sed '1ia' </dev/null 2>/dev/null || printf "${ORANGE}Warning: You may run on a BSD style system without gnu utils ...${NN}"
#jsonDB is now mandatory
if ! _is_function jssh_newDB; then
	printf "${RED}ERROR: Mandatory module jsonDB is missing or not readable!${NN}"
	exit 6
fi

# $1 URL, $2 filename in DATADIR
# outputs final filename
download() {
	local empty="no.file" file="${2:-${empty}}"
	if [[ "${file}" = *"/"* ]] || [[ "${file}" = "."* ]]; then file="${empty}"; fi
	while [ -f "${DATADIR:-.}/${file}" ] ; do file="${RANDOM}-${file}"; done
	getJson "$1" >"${DATADIR:-.}/${file}" || return
	printf '%s\n' "${DATADIR:-.}/${file}"
}

# $1 postfix, e.g. chatid
# $2 prefix, back- or startbot-
procname(){
	printf '%s\n' "$2${ME}_$1"
}

# $1 string to search for programme incl. parameters
# returns a list of PIDs of all current bot processes matching $1
proclist() {
	# shellcheck disable=SC2009
	ps -fu "${UID}" | grep -F "$1" | grep -v ' grep'| grep -F "${ME}" | sed 's/\s\+/\t/g' | cut -f 2
}

# $1 string to search for programme to kill
killallproc() {
	local procid; procid="$(proclist "$1")"
	if [ -n "${procid}" ] ; then
		# shellcheck disable=SC2046
		kill $(proclist "$1")
		sleep 1
		procid="$(proclist "$1")"
		# shellcheck disable=SC2046
		[ -n "${procid}" ] && kill $(proclist -9 "$1")
	fi
	debug_checks "end killallproc" "$1"
}


# $ chat $2 msg_id $3 nolog
declare -xr DELETE_URL=${URL}'/deleteMessage'
delete_message() {
	[ -z "$3" ] && log_update "Delete Message CHAT=$1 MSG_ID=$2"
	sendJson "$1" '"message_id": '"$2"'' "${DELETE_URL}"
}

get_file() {
	[ -z "$1" ] && return
	sendJson ""  '"file_id": "'"$1"'"' "${URL}/getFile"
	printf "%s\n" "${URL}/${UPD["result,file_path"]}"
}

# iconv used to filter out broken utf characters, if not installed fake it
if ! _exists iconv; then
	log_update "Warning: iconv not installed, pls imstall iconv!"
	function iconv() { cat; }
fi

TIMEOUT="${BASHBOT_TIMEOUT:-20}"
[[ "${TIMEOUT}" =~ ^[${o9o9o9}]+$ ]] || TIMEOUT="20"

# usage: sendJson "chat" "JSON" "URL"
sendJson(){
	local json chat=""
	if [ -n "$1" ]; then
		 chat='"chat_id":'"$1"','
		 [[ "$1" == *[!${o9o9o9}-]* ]] && chat='"chat_id":"'"$1"' NAN",'	# chat id not a number!
	fi
	# compose final json
	json='{'"${chat} $(iconv -f utf-8 -t utf-8 -c <<<"$2")"'}'
	if [ -n "${BASHBOTDEBUG}" ] ; then
		log_update "sendJson (${DETECTED_CURL}) CHAT=${chat#*:} JSON=${2:0:100} URL=${3##*/}"
		log_message "DEBUG sendJson ==========\n$("${JSONSHFILE}" -b -n <<<"${json}" 2>&1)"
	fi
	# chat id not a number
	if [[ "${chat}" == *"NAN\"," ]]; then
		sendJsonResult "$(printf '["ok"]\tfalse\n["error_code"]\t400\n["description"]\t"Bad Request: chat id not a number"\n')"\
			"sendJson (NAN)" "$@"
		return
	fi
	# OK here we go ...
	# route to curl/wget specific function
	res="$(sendJson_do "${json}" "$3")"
	# check telegram response
	sendJsonResult "${res}" "sendJson (${DETECTED_CURL})" "$@"
	[ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "send" "${@}" &
}

#
# curl / wget specific functions
#
if detect_curl ; then
  # here we have curl ----
  [ -z "${BASHBOT_CURL}" ] && BASHBOT_CURL="curl"
  # $1 URL, $2 hack: log getJson if not ""
  getJson(){
	# shellcheck disable=SC2086
	"${BASHBOT_CURL}" -sL -k ${BASHBOT_CURL_ARGS} -m "${TIMEOUT}" "$1"
  }
  # curl variant for sendJson
  # usage: "JSON" "URL"
  sendJson_do(){
	# shellcheck disable=SC2086
	"${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} -m "${TIMEOUT}"\
		-d "$1" -X POST "$2" -H "Content-Type: application/json" | "${JSONSHFILE}" -b -n 2>/dev/null
  }
  #$1 Chat, $2 what, $3 file, $4 URL, $5 caption
  sendUpload() {
	[ "$#" -lt 4  ] && return
	if [ -n "$5" ]; then
		[ -n "${BASHBOTDEBUG}" ] &&\
			log_update "sendUpload CHAT=$1 WHAT=$2  FILE=$3 CAPT=$5"
		# shellcheck disable=SC2086
		res="$("${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} "$4" -F "chat_id=$1"\
			-F "$2=@$3;${3##*/}" -F "caption=$5" | "${JSONSHFILE}" -b -n 2>/dev/null )"
	else
		# shellcheck disable=SC2086
		res="$("${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} "$4" -F "chat_id=$1"\
			-F "$2=@$3;${3##*/}" | "${JSONSHFILE}" -b -n 2>/dev/null )"
	fi
	sendJsonResult "${res}" "sendUpload (curl)" "$@"
	[ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "upload" "$@" &
  }
else
  # NO curl, try wget
  if _exists wget; then
    getJson(){
	# shellcheck disable=SC2086
	wget --no-check-certificate -t 2 -T "${TIMEOUT}" ${BASHBOT_WGET_ARGS} -qO - "$1"
    }
    # curl variant for sendJson
    # usage: "JSON" "URL"
    sendJson_do(){
	# shellcheck disable=SC2086
	wget --no-check-certificate -t 2 -T "${TIMEOUT}" ${BASHBOT_WGET_ARGS} -qO - --post-data="$1" \
		--header='Content-Type:application/json' "$2" | "${JSONSHFILE}" -b -n 2>/dev/null
    }
    sendUpload() {
	log_error "Sorry, wget does not support file upload"
	BOTSENT[OK]="false"
	[ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "upload" "$@" &
    }
  else
	# ups, no curl AND no wget
	if [ -n "${BASHBOT_WGET}" ]; then
		printf "${RED}Error: You set BASHBOT_WGET but no wget found!${NN}"
	else
		printf "${RED}Error: curl and wget not found, install curl!${NN}"
	fi
	exit 8
  fi
fi 

# retry sendJson
# $1 function $2 sleep $3 ... $n arguments
sendJsonRetry(){
	local retry="$1"; shift
	[[ "$1" =~ ^\ *[${o9o9o9}.]+\ *$ ]] && sleep "$1"; shift
	printf "%(%c)T: RETRY %s %s %s\n" -1 "${retry}" "$1" "${2:0:60}"
	case "${retry}" in
		'sendJson'*)
			sendJson "$@"	
			;;
		'sendUpload'*)
			sendUpload "$@"	
			;;
		'send_album'*)
			send_album "$@"	
			;;
		*)
			log_error "Error: unknown function ${retry}, cannot retry"
			return
			;;
	esac
	[ "${BOTSENT[OK]}" = "true" ] && log_error "Retry OK:${retry} $1 ${2:0:60}"
} >>"${ERRORLOG}"

# process sendJson result
# stdout is written to ERROR.log
# $1 result $2 function $3 .. $n original arguments, $3 is Chat_id
sendJsonResult(){
	local offset=0
	BOTSENT=( )
	Json2Array 'UPD' <<<"$1"
	[ -n "${BASHBOTDEBUG}" ] && log_message "New Result ==========\n$1"
	BOTSENT[OK]="${UPD["ok"]}"
	if [ "${BOTSENT[OK]}" = "true" ]; then
		BOTSENT[ID]="${UPD["result,message_id"]}"
		BOTSENT[CHAT]="${UPD["result,chat,id"]}"
		[ -n "${UPD["result"]}" ] && BOTSENT[RESULT]="${UPD["result"]}"
		return
		# hot path everything OK!
	else
	    # oops something went wrong!
	    if [ -n "$1" ]; then
			BOTSENT[ERROR]="${UPD["error_code"]}"
			BOTSENT[DESCRIPTION]="${UPD["description"]}"
			[ -n "${UPD["parameters,retry_after"]}" ] && BOTSENT[RETRY]="${UPD["parameters,retry_after"]}"
	    else
			BOTSENT[OK]="false"
			BOTSENT[ERROR]="999"
			BOTSENT[DESCRIPTION]="Send to telegram not possible, timeout/broken/no connection"
	    fi
	    # log error
	    [[ "${BOTSENT[ERROR]}" = "400" && "${BOTSENT[DESCRIPTION]}" == *"starting at byte offset"* ]] &&\
			 offset="${BOTSENT[DESCRIPTION]%* }"
	    printf "%(%c)T: RESULT=%s FUNC=%s CHAT[ID]=%s ERROR=%s DESC=%s ACTION=%s\n" -1\
			"${BOTSENT[OK]}"  "$2" "$3" "${BOTSENT[ERROR]}" "${BOTSENT[DESCRIPTION]}" "${4:${offset}:100}"
	    # warm path, do not retry on error, also if we use wegt
	    [ -n "${BASHBOT_RETRY}${BASHBOT_WGET}" ] && return

	    # OK, we can retry sendJson, let's see what's failed
	    # throttled, telegram say we send too many messages
	    if [ -n "${BOTSENT[RETRY]}" ]; then
			BASHBOT_RETRY="$(( ++BOTSENT[RETRY] ))"
			printf "Retry %s in %s seconds ...\n" "$2" "${BASHBOT_RETRY}"
			sendJsonRetry "$2" "${BASHBOT_RETRY}" "${@:3}"
			unset BASHBOT_RETRY
			return
	    fi
	    # timeout, failed connection or blocked
	    if [ "${BOTSENT[ERROR]}" == "999" ];then
		# check if default curl and args are OK
			if ! curl -sL -k -m 2 "${URL}" >/dev/null 2>&1 ; then
				printf "%(%c)T: BASHBOT IP Address seems blocked!\n" -1
				# user provided function to recover or notify block
				if _exec_if_function bashbotBlockRecover; then
					BASHBOT_RETRY="2"
					printf "bashbotBlockRecover returned true, retry %s ...\n" "$2"
					sendJsonRetry "$2" "${BASHBOT_RETRY}" "${@:3}"
					unset BASHBOT_RETRY
				fi
		    return
			fi
	        # are not blocked, default curl and args are working
			if [ -n "${BASHBOT_CURL_ARGS}" ] || [ "${BASHBOT_CURL}" != "curl" ]; then
				printf "Problem with \"%s %s\"? retry %s with default config ...\n"\
					"${BASHBOT_CURL}" "${BASHBOT_CURL_ARGS}" "$2"
				BASHBOT_RETRY="2"; BASHBOT_CURL="curl"; BASHBOT_CURL_ARGS=""
				sendJsonRetry "$2" "${BASHBOT_RETRY}" "${@:3}"
				unset BASHBOT_RETRY
			fi
	    fi
	fi
} >>"${ERRORLOG}"

# convert common telegram entities to JSON
# title caption description markup inlinekeyboard
title2Json(){
	local title caption desc markup keyboard
	[ -n "$1" ] && title=',"title":"'$(JsonEscape "$1")'"'
	[ -n "$2" ] && caption=',"caption":"'$(JsonEscape "$2")'"'
	[ -n "$3" ] && desc=',"description":"'$(JsonEscape "$3")'"'
	[ -n "$4" ] && markup=',"parse_mode":"'"$4"'"'
	[ -n "$5" ] && keyboard=',"reply_markup":"'$(JsonEscape "$5")'"'
	printf '%s\n' "${title}${caption}${desc}${markup}${keyboard}"
}

# get bot name and id from telegram
getBotName() {
	declare -A BOTARRAY
	Json2Array 'BOTARRAY' <<<"$(getJson "${ME_URL}" | "${JSONSHFILE}" -b -n 2>/dev/null)"
	[ -z "${BOTARRAY["result","username"]}" ] && return 1
	# save botname and id
	setConfigKey "botname" "${BOTARRAY["result","username"]}"
	setConfigKey "botid" "${BOTARRAY["result","id"]}"
	printf "${BOTARRAY["result","username"]}\n"
}

# pure bash implementation, done by KayM (@gnadelwartz)
# see https://stackoverflow.com/a/55666449/9381171
JsonDecode() {
	local remain U out="$1"
	local regexp='(.*)\\u[dD]([0-9a-fA-F]{3})\\u[dD]([0-9a-fA-F]{3})(.*)'
	while [[ "${out}" =~ ${regexp} ]] ; do
	U=$(( ( (0xd${BASH_REMATCH[2]} & 0x3ff) <<10 ) | ( 0xd${BASH_REMATCH[3]} & 0x3ff ) + 0x10000 ))
			remain="$(printf '\\U%8.8x' "${U}")${BASH_REMATCH[4]}${remain}"
			out="${BASH_REMATCH[1]}"
	done
	printf "%b\n" "${out}${remain}"
}


################
# processing of updates starts here
process_updates() {
	local max num debug="$1"
	max="$(grep -F ',"update_id"]'  <<< "${UPDATE}" | tail -1 | cut -d , -f 2 )"
	Json2Array 'UPD' <<<"${UPDATE}"
	for ((num=0; num<=max; num++)); do
		process_client "${num}" "${debug}"
	done
}

process_client() {
	local num="$1" debug="$2" 
	pre_process_message "${num}"
	# log message on debug
	[[ -n "${debug}" ]] && log_message "New Message ==========\n$(grep -F '["result",'"${num}" <<<"${UPDATE}")"

	# check for users / groups to ignore
	jssh_updateArray_async "BASHBOTBLOCKED" "${BLOCKEDFILE}"
	[ -n "${USER[ID]}" ] && [[ -n "${BASHBOTBLOCKED[${USER[ID]}]}" || -n "${BASHBOTBLOCKED[${CHAT[ID]}]}" ]] && return

	# process per message type
	if [ -n "${iQUERY[ID]}" ]; then
		process_inline_query "${num}" "${debug}"
	        printf "%(%c)T: Inline Query update received FROM=%s iQUERY=%s\n" -1\
			"${iQUERY[USERNAME]:0:20} (${iQUERY[USER_ID]})" "${iQUERY[0]}" >>"${UPDATELOG}"
	elif [ -n "${iBUTTON[ID]}" ]; then
		process_inline_button "${num}" "${debug}"
	        printf "%(%c)T: Inline Button update received FROM=%s CHAT=%s CALLBACK=%s DATA:%s \n" -1\
			"${iBUTTON[USERNAME]:0:20} (${iBUTTON[USER_ID]})" "${iBUTTON[CHAT_ID]}" "${iBUTTON[ID]}" "${iBUTTON[DATA]}" >>"${UPDATELOG}"
	else
		if grep -qs -e '\["result",'"${num}"',"edited_message"' <<<"${UPDATE}"; then
			# edited message
			UPDATE="${UPDATE//,${num},\"edited_message\",/,${num},\"message\",}"
			Json2Array 'UPD' <<<"${UPDATE}"
			MESSAGE[0]="/_edited_message "
		fi
		process_message "${num}" "${debug}"
	        printf "%(%c)T: update received FROM=%s CHAT=%s CMD=%s\n" -1 "${USER[USERNAME]:0:20} (${USER[ID]})"\
			"${CHAT[USERNAME]:0:20}${CHAT[TITLE]:0:30} (${CHAT[ID]})"\
			"${MESSAGE:0:30}${CAPTION:0:30}${URLS[*]:0:30}" >>"${UPDATELOG}"
	fi
	#####
	# process inline and message events
	# first classic command dispatcher
	# shellcheck source=./commands.sh
	source "${COMMANDS}" "${debug}" &

	# then all registered addons
	if [ -z "${iQUERY[ID]}" ]; then
		event_message "${debug}"
	else
		event_inline "${debug}"
	fi

	# last count users
	jssh_countKeyDB_async "${CHAT[ID]}" "${COUNTFILE}"
}

declare -Ax BASHBOT_EVENT_INLINE BASHBOT_EVENT_MESSAGE BASHBOT_EVENT_CMD BASHBOT_EVENT_REPLYTO BASHBOT_EVENT_FORWARD BASHBOT_EVENT_SEND
declare -Ax BASHBOT_EVENT_CONTACT BASHBOT_EVENT_LOCATION BASHBOT_EVENT_FILE BASHBOT_EVENT_TEXT BASHBOT_EVENT_TIMER BASHBOT_BLOCKED

start_timer(){
	# send alarm every ~60 s
	while :; do
		sleep 59.5
    		kill -ALRM $$
	done;
}

EVENT_SEND="0"
event_send() {
	# max recursion level 5 to avoid fork bombs
	(( EVENT_SEND++ )); [ "${EVENT_SEND}" -gt "5" ] && return
	# shellcheck disable=SC2153
	for key in "${!BASHBOT_EVENT_SEND[@]}"
	do
		_exec_if_function "${BASHBOT_EVENT_SEND[${key}]}" "$@"
	done
}

EVENT_TIMER="0"
event_timer() {
	local key timer debug="$1"
	(( EVENT_TIMER++ ))
	# shellcheck disable=SC2153
	for key in "${!BASHBOT_EVENT_TIMER[@]}"
	do
		timer="${key##*,}"
		[[ ! "${timer}" =~ ^-*[1-9][0-9]*$ ]] && continue
		if [ "$(( EVENT_TIMER % timer ))" = "0" ]; then
			_exec_if_function "${BASHBOT_EVENT_TIMER[${key}]}" "timer" "${key}" "${debug}"
			[ "$(( EVENT_TIMER % timer ))" -lt "0" ] && \
				unset BASHBOT_EVENT_TIMER["${key}"]
		fi
	done
}

event_inline() {
	local key debug="$1"
	# shellcheck disable=SC2153
	for key in "${!BASHBOT_EVENT_INLINE[@]}"
	do
		_exec_if_function "${BASHBOT_EVENT_INLINE[${key}]}" "inline" "${key}" "${debug}"
	done
}
event_message() {
	local key debug="$1"
	# ${MESSAEG[*]} event_message
	# shellcheck disable=SC2153
	for key in "${!BASHBOT_EVENT_MESSAGE[@]}"
	do
		 _exec_if_function "${BASHBOT_EVENT_MESSAGE[${key}]}" "message" "${key}" "${debug}"
	done
	
	# ${TEXT[*]} event_text
	if [ -n "${MESSAGE[0]}" ]; then
		# shellcheck disable=SC2153
		for key in "${!BASHBOT_EVENT_TEXT[@]}"
		do
			_exec_if_function "${BASHBOT_EVENT_TEXT[${key}]}" "text" "${key}" "${debug}"
		done

		# ${CMD[*]} event_cmd
		if [ -n "${CMD[0]}" ]; then
			# shellcheck disable=SC2153
			for key in "${!BASHBOT_EVENT_CMD[@]}"
			do
				_exec_if_function "${BASHBOT_EVENT_CMD[${key}]}" "command" "${key}" "${debug}"
			done
		fi
	fi
	# ${REPLYTO[*]} event_replyto
	if [ -n "${REPLYTO[UID]}" ]; then
		# shellcheck disable=SC2153
		for key in "${!BASHBOT_EVENT_REPLYTO[@]}"
		do
			_exec_if_function "${BASHBOT_EVENT_REPLYTO[${key}]}" "replyto" "${key}" "${debug}"
		done
	fi

	# ${FORWARD[*]} event_forward
	if [ -n "${FORWARD[UID]}" ]; then
		# shellcheck disable=SC2153
		for key in "${!BASHBOT_EVENT_FORWARD[@]}"
		do
			 _exec_if_function && "${BASHBOT_EVENT_FORWARD[${key}]}" "forward" "${key}" "${debug}"
		done
	fi

	# ${CONTACT[*]} event_contact
	if [ -n "${CONTACT[FIRST_NAME]}" ]; then
		# shellcheck disable=SC2153
		for key in "${!BASHBOT_EVENT_CONTACT[@]}"
		do
			_exec_if_function "${BASHBOT_EVENT_CONTACT[${key}]}" "contact" "${key}" "${debug}"
		done
	fi

	# ${VENUE[*]} event_location
	# ${LOCATION[*]} event_location
	if [ -n "${LOCATION[LONGITUDE]}" ] || [ -n "${VENUE[TITLE]}" ]; then
		# shellcheck disable=SC2153
		for key in "${!BASHBOT_EVENT_LOCATION[@]}"
		do
			_exec_if_function "${BASHBOT_EVENT_LOCATION[${key}]}" "location" "${key}" "${debug}"
		done
	fi

	# ${URLS[*]} event_file
	# NOTE: compare again #URLS -1 blanks!
	if [[ "${URLS[*]}" != "     " ]]; then
		# shellcheck disable=SC2153
		for key in "${!BASHBOT_EVENT_FILE[@]}"
		do
			_exec_if_function "${BASHBOT_EVENT_FILE[${key}]}" "file" "${key}" "${debug}"
		done
	fi

}
pre_process_message(){
	local num="$1"
	# unset everything to not have old values
	CMD=( ); iQUERY=( ); iBUTTON=(); MESSAGE=(); CHAT=(); USER=(); CONTACT=(); LOCATION=(); unset CAPTION
	REPLYTO=( ); FORWARD=( ); URLS=(); VENUE=( ); SERVICE=( ); NEWMEMBER=( ); LEFTMEMBER=( ); PINNED=( ); MIGRATE=( )
	iQUERY[ID]="${UPD["result,${num},inline_query,id"]}"
	iBUTTON[ID]="${UPD["result,${num},callback_query,id"]}"
	CHAT[ID]="${UPD["result,${num},message,chat,id"]}"
	USER[ID]="${UPD["result,${num},message,from,id"]}"
	[ -z "${CHAT[ID]}" ] && CHAT[ID]="${UPD["result,${num},edited_message,chat,id"]}"
	[ -z "${USER[ID]}" ] && USER[ID]="${UPD["result,${num},edited_message,from,id"]}"
	# always true
	return 0
}
process_inline_query() {
	local num="$1"
	iQUERY[0]="$(JsonDecode "${UPD["result,${num},inline_query,query"]}")"
	iQUERY[USER_ID]="${UPD["result,${num},inline_query,from,id"]}"
	iQUERY[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},inline_query,from,first_name"]}")"
	iQUERY[LAST_NAME]="$(JsonDecode "${UPD["result,${num},inline_query,from,last_name"]}")"
	iQUERY[USERNAME]="$(JsonDecode "${UPD["result,${num},inline_query,from,username"]}")"
	# always true
	return 0
}
process_inline_button() {
# debugging for impelemetation
	local num="$1"
	iBUTTON[DATA]="${UPD["result,${num},callback_query,data"]}"
	#iBUTTON[CHAT_INSTANCE]="${UPD["result,${num},callback_query,chat_instance"]}"
	#iBUTTON[INLINE_ID]="${UPD["result,${num},callback_query,inline_message_id"]}"
	iBUTTON[CHAT_ID]="${UPD["result,${num},callback_query,message,chat,id"]}"
	iBUTTON[MESSAGE_ID]="${UPD["result,${num},callback_query,message,message_id"]}"
	iBUTTON[MEESSAGE]="$(JsonDecode "${UPD["result,${num},callback_query,message,text"]}")"
# XXX should we give back pressed button, all buttons or nothing?
	iBUTTON[USER_ID]="${UPD["result,${num},callback_query,from,id"]}"
	iBUTTON[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},callback_query,from,first_name"]}")"
	iBUTTON[LAST_NAME]="$(JsonDecode "${UPD["result,${num},callback_query,from,last_name"]}")"
	iBUTTON[USERNAME]="$(JsonDecode "${UPD["result,${num},callback_query,from,username"]}")"
	# always true
	return 0
}
process_message() {
	local num="$1"
	# Message
	MESSAGE[0]+="$(JsonDecode "${UPD["result,${num},message,text"]}" | sed 's|\\/|/|g')"
	MESSAGE[ID]="${UPD["result,${num},message,message_id"]}"

	# Chat ID is now parsed when update is received
	CHAT[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,chat,last_name"]}")"
	CHAT[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,chat,first_name"]}")"
	CHAT[USERNAME]="$(JsonDecode "${UPD["result,${num},message,chat,username"]}")"
	# set real name as username if empty
	[ -z "${CHAT[USERNAME]}" ] && CHAT[USERNAME]="${CHAT[FIRST_NAME]} ${CHAT[LAST_NAME]}"
	CHAT[TITLE]="$(JsonDecode "${UPD["result,${num},message,chat,title"]}")"
	CHAT[TYPE]="$(JsonDecode "${UPD["result,${num},message,chat,type"]}")"
	CHAT[ALL_ADMIN]="${UPD["result,${num},message,chat,all_members_are_administrators"]}"

	# user ID is now parsed when update is received
	USER[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,from,first_name"]}")"
	USER[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,from,last_name"]}")"
	USER[USERNAME]="$(JsonDecode "${UPD["result,${num},message,from,username"]}")"
	# set real name as username if empty
	[ -z "${USER[USERNAME]}" ] && USER[USERNAME]="${USER[FIRST_NAME]} ${USER[LAST_NAME]}"

	# in reply to message from
	if [ -n "${UPD["result,${num},message,reply_to_message,from,id"]}" ]; then
	   REPLYTO[UID]="${UPD["result,${num},message,reply_to_message,from,id"]}"
	   REPLYTO[0]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,text"]}")"
	   REPLYTO[ID]="${UPD["result,${num},message,reply_to_message,message_id"]}"
	   REPLYTO[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,from,first_name"]}")"
	   REPLYTO[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,from,last_name"]}")"
	   REPLYTO[USERNAME]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,from,username"]}")"
	fi

	# forwarded message from
	if [ -n "${UPD["result,${num},message,forward_from,id"]}" ]; then
	   FORWARD[UID]="${UPD["result,${num},message,forward_from,id"]}"
	   FORWARD[ID]="${MESSAGE[ID]}"	# same as message ID
	   FORWARD[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,forward_from,first_name"]}")"
	   FORWARD[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,forward_from,last_name"]}")"
	   FORWARD[USERNAME]="$(JsonDecode "${UPD["result,${num},message,forward_from,username"]}")"
	fi

	# get file URL from telegram, check for any of them!
	if grep -qs -e '\["result",'"${num}"',"message","[avpsd].*,"file_id"\]' <<<"${UPDATE}"; then
	    URLS[AUDIO]="$(get_file "${UPD["result,${num},message,audio,file_id"]}")"
	    URLS[DOCUMENT]="$(get_file "${UPD["result,${num},message,document,file_id"]}")"
	    URLS[PHOTO]="$(get_file "${UPD["result,${num},message,photo,0,file_id"]}")"
	    URLS[STICKER]="$(get_file "${UPD["result,${num},message,sticker,file_id"]}")"
	    URLS[VIDEO]="$(get_file "${UPD["result,${num},message,video,file_id"]}")"
	    URLS[VOICE]="$(get_file "${UPD["result,${num},message,voice,file_id"]}")"
	fi
	# Contact, must have phone_number
	if [ -n "${UPD["result,${num},message,contact,phone_number"]}" ]; then
		CONTACT[USER_ID]="$(JsonDecode  "${UPD["result,${num},message,contact,user_id"]}")"
		CONTACT[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,contact,first_name"]}")"
		CONTACT[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,contact,last_name"]}")"
		CONTACT[NUMBER]="${UPD["result,${num},message,contact,phone_number"]}"
		CONTACT[VCARD]="${UPD["result,${num},message,contact,vcard"]}"
	fi

	# venue, must have a position
	if [ -n "${UPD["result,${num},message,venue,location,longitude"]}" ]; then
		VENUE[TITLE]="$(JsonDecode "${UPD["result,${num},message,venue,title"]}")"
		VENUE[ADDRESS]="$(JsonDecode "${UPD["result,${num},message,venue,address"]}")"
		VENUE[LONGITUDE]="${UPD["result,${num},message,venue,location,longitude"]}"
		VENUE[LATITUDE]="${UPD["result,${num},message,venue,location,latitude"]}"
		VENUE[FOURSQUARE]="${UPD["result,${num},message,venue,foursquare_id"]}"
	fi

	# Caption
	CAPTION="$(JsonDecode "${UPD["result,${num},message,caption"]}")"

	# Location
	LOCATION[LONGITUDE]="${UPD["result,${num},message,location,longitude"]}"
	LOCATION[LATITUDE]="${UPD["result,${num},message,location,latitude"]}"

	# service messages, group or channel only!
	if [[ "${CHAT[ID]}" == "-"* ]] ; then
	    # new chat member
	    if [ -n "${UPD["result,${num},message,new_chat_member,id"]}" ]; then
		SERVICE[NEWMEMBER]="${UPD["result,${num},message,new_chat_member,id"]}"
		NEWMEMBER[ID]="${SERVICE[NEWMEMBER]}"
		NEWMEMBER[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,new_chat_member,first_name"]}")"
		NEWMEMBER[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,new_chat_member,last_name"]}")"
		NEWMEMBER[USERNAME]="$(JsonDecode "${UPD["result,${num},message,new_chat_member,username"]}")"
		NEWMEMBER[ISBOT]="${UPD["result,${num},message,new_chat_member,is_bot"]}"
		[ -z "${MESSAGE[0]}" ] &&\
		MESSAGE[0]="/_new_chat_member ${NEWMEMBER[ID]} ${NEWMEMBER[USERNAME]:=${NEWMEMBER[FIRST_NAME]} ${NEWMEMBER[LAST_NAME]}}"
	    fi
	    # left chat member
	    if [ -n "${UPD["result,${num},message,left_chat_member,id"]}" ]; then
		SERVICE[LEFTMEMBER]="${UPD["result,${num},message,left_chat_member,id"]}"
		LEFTMEMBER[ID]="${SERVICE[LEFTMEBER]}"
		LEFTMEMBER[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,left_chat_member,first_name"]}")"
		LEFTMEMBER[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,left_chat_member,last_name"]}")"
		LEFTMEBER[USERNAME]="$(JsonDecode "${UPD["result,${num},message,left_chat_member,username"]}")"
		LEFTMEMBER[ISBOT]="${UPD["result,${num},message,left_chat_member,is_bot"]}"
		[ -z "${MESSAGE[0]}" ] &&\
		MESSAGE[0]="/_left_chat_member ${LEFTMEMBER[ID]} ${LEFTMEMBER[USERNAME]:=${LEFTMEMBER[FIRST_NAME]} ${LEFTMEMBER[LAST_NAME]}}"
	    fi
	    # chat title / photo, check for any of them!
	    if grep -qs -e '\["result",'"${num}"',"message","new_chat_[tp]' <<<"${UPDATE}"; then
		SERVICE[NEWTITLE]="$(JsonDecode "${UPD["result,${num},message,new_chat_title"]}")"
		[ -z "${MESSAGE[0]}" ] && [ -n "${SERVICE[NEWTITLE]}" ] &&\
			MESSAGE[0]="/_new_chat_title ${USER[ID]} ${SERVICE[NEWTITLE]}"
		SERVICE[NEWPHOTO]="$(get_file "${UPD["result,${num},message,new_chat_photo,0,file_id"]}")"
		[ -z "${MESSAGE[0]}" ] && [ -n "${SERVICE[NEWPHOTO]}" ] &&\
			 MESSAGE[0]="/_new_chat_photo ${USER[ID]} ${SERVICE[NEWPHOTO]}"
	    fi
	    # pinned message
	    if [ -n "${UPD["result,${num},message,pinned_message,message_id"]}" ]; then
		SERVICE[PINNED]="${UPD["result,${num},message,pinned_message,message_id"]}"
		PINNED[ID]="${SERVICE[PINNED]}"
		PINNED[MESSAGE]="$(JsonDecode "${UPD["result,${num},message,pinned_message,text"]}")"
		[ -z "${MESSAGE[0]}" ] &&\
			MESSAGE[0]="/_new_pinned_message ${USER[ID]} ${PINNED[ID]} ${PINNED[MESSAGE]}"
	    fi
	    # migrate to super group
	    if [ -n "${UPD["result,${num},message,migrate_to_chat_id"]}" ]; then
		MIGRATE[TO]="${UPD["result,${num},message,migrate_to_chat_id"]}"
		MIGRATE[FROM]="${UPD["result,${num},message,migrate_from_chat_id"]}"
		# CHAT is already migrated, so set new chat id
		[ "${CHAT[ID]}" = "${MIGRATE[FROM]}" ] && CHAT[ID]="${MIGRATE[FROM]}"
		SERVICE[MIGRATE]="${MIGRATE[FROM]} ${MIGRATE[TO]}"
		[ -z "${MESSAGE[0]}" ] &&\
			MESSAGE[0]="/_migrate_group ${SERVICE[MIGRATE]}"
	    fi
	    # set SERVICE to yes if a service message was received
	    [[ "${SERVICE[*]}" =~  ^[[:blank:]]*$ ]] || SERVICE[0]="yes"
	fi

	# split message in command and args
	[[ "${MESSAGE[0]}" == "/"* ]] && read -r CMD <<<"${MESSAGE[0]}" &&  CMD[0]="${CMD[0]%%@*}"
	# everything went well
	return 0
}

#########################
# main get updates loop, should never terminate
declare -A BASHBOTBLOCKED
start_bot() {
	local DEBUGMSG OFFSET=0
	# adaptive sleep defaults
	local nextsleep="100"
	local stepsleep="${BASHBOT_SLEEP_STEP:-100}"
	local maxsleep="${BASHBOT_SLEEP:-5000}"
	# startup message
	DEBUGMSG="Start BASHBOT updates in Mode \"${1:-normal}\" =========="
	log_update "${DEBUGMSG}"
	# redirect to Debug.log
	[[ "$1" == *"debug" ]] && exec &>>"${DEBUGLOG}"
	log_debug "${DEBUGMSG}"; DEBUGMSG="$1"
	[[ "${DEBUGMSG}" == "xdebug"* ]] && set -x
	# cleaup old pipes and empty logfiles
	find "${DATADIR}" -type p -delete
	find "${DATADIR}" -size 0 -name "*.log" -delete
	# load addons on startup
	for addons in "${ADDONDIR:-.}"/*.sh ; do
		# shellcheck source=./modules/aliases.sh
		[ -r "${addons}" ] && source "${addons}" "startbot" "${DEBUGMSG}"
	done
	# shellcheck source=./commands.sh
	source "${COMMANDS}" "startbot"
	# start timer events
	if [ -n "${BASHBOT_START_TIMER}" ] ; then
		# shellcheck disable=SC2064
		trap "event_timer ${DEBUGMSG}" ALRM
		start_timer &
		# shellcheck disable=SC2064
		trap "kill -9 $!; exit" EXIT INT HUP TERM QUIT 
	fi
	# cleanup countfile on startup
	jssh_deleteKeyDB "CLEAN_COUNTER_DATABASE_ON_STARTUP" "${COUNTFILE}"
        [ -f "${COUNTFILE}.jssh.flock" ] && rm -f "${COUNTFILE}.jssh.flock"
	# store start time and cleanup botconfig on startup
	jssh_updateKeyDB "startup" "$(_date)" "${BOTCONFIG}"
        [ -f "${BOTCONFIG}.jssh.flock" ] && rm -f "${BOTCONFIG}.jssh.flock"
	# read blocked users
	jssh_readDB_async "BASHBOTBLOCKED" "${BLOCKEDFILE}"
	# inform botadmin about start
	send_normal_message "$(getConfigKey "botadmin")" "Bot $(getConfigKey "botname") started ..." &
	##########
	# bot is ready, start processing updates ...
	while true; do
		# adaptive sleep in ms rounded to next 0.1 s
		sleep "$(_round_float "${nextsleep}e-3" "1")"
		# get next update
		UPDATE="$(getJson "${URL}/getUpdates?offset=${OFFSET}" 2>/dev/null | "${JSONSHFILE}" -b -n 2>/dev/null | iconv -f utf-8 -t utf-8 -c)"
		# did we get an response?
		if [ -n "${UPDATE}" ]; then
			# we got something, do processing
			[ "${OFFSET}" = "-999" ] && [ "${nextsleep}" -gt "$((maxsleep*2))" ] &&\
				log_error "Recovered from timeout/broken/no connection, continue with telegram updates"
			# escape bash $ expansion bug
			((nextsleep+= stepsleep , nextsleep= nextsleep>maxsleep ?maxsleep:nextsleep))
			UPDATE="${UPDATE//$/\\$}"
			# Offset
			OFFSET="$(grep <<< "${UPDATE}" '\["result",[0-9]*,"update_id"\]' | tail -1 | cut -f 2)"
			((OFFSET++))

			if [ "${OFFSET}" != "1" ]; then
				nextsleep="100"
				process_updates "${DEBUGMSG}"
			fi
		else
			# oops, something bad happened, wait maxsleep*10
			(( nextsleep=nextsleep*2 , nextsleep= nextsleep>maxsleep*10 ?maxsleep*10:nextsleep ))
			# second time, report problem
			if [ "${OFFSET}" = "-999" ]; then
			    log_error "Repeated timeout/broken/no connection on telegram update, sleep $(_round_float "${nextsleep}e-3")s"
			    # try to recover
			    if _is_function bashbotBlockRecover && [ -z "$(getJson "${ME_URL}")" ]; then
				log_error "Try to recover, calling bashbotBlockRecover ..."
				bashbotBlockRecover >>"${ERRORLOG}"
			    fi
			fi
			OFFSET="-999"
		fi
	done
}

# initialize bot environment, user and permissions
bot_init() {
	[ -n "${BASHBOT_HOME}" ] && cd "${BASHBOT_HOME}" || exit 1
	local runuser chown touser botname DEBUG="$1"
	# upgrade from old version
	# currently no action
	printf "Check for Update actions ...\n"
	printf "Done.\n"
	# load addons on startup
	printf "Initialize modules and addons ...\n"
	for addons in "${ADDONDIR:-.}"/*.sh ; do
		# shellcheck source=./modules/aliases.sh
		[ -r "${addons}" ] && source "${addons}" "init" "${DEBUG}"
	done
	printf "Done.\n"
	# ask for bashbot user
	runuser="${RUNUSER}"; [ "${UID}" = "0" ] && runuser="nobody"
	printf "Enter User to run bashbot [${runuser}]: "
	read -r chown
	[ -z "${chown}" ] && chown="${runuser}"; touser="${chown%:*}"
	# check user ...
	if ! id "${touser}" &>/dev/null; then
		printf "${RED}User \"${touser}\" does not exist!${NN}"
		exit 3
	elif [[ "${UID}" != "0" && "${touser}" != "${runuser}" ]]; then
		# different user but not root ...
		printf "${ORANGE}You are not root, adjusting permissions may fail. Try \"sudo ./bashbot.sh init\"${NN}Press <CTRL+C> to stop or <Enter> to continue..." 1>&2
		[ -n "${INTERACTIVE}" ] && read -r runuser
	fi
	# adjust permissions
	printf "Adjusting files and permissions for user \"${touser}\" ...\n"
	chmod 711 .
	chmod -R o-w ./*
	chmod -R u+w "${COUNTFILE}"* "${BLOCKEDFILE}"* "${DATADIR}" logs "${LOGDIR}/"*.log 2>/dev/null
	chmod -R o-r,o-w "${COUNTFILE}"* "${BLOCKEDFILE}"* "${DATADIR}" "${BOTACL}" 2>/dev/null
	# jsshDB must writeable by owner
	find . -name '*.jssh*' -exec chmod u+w \{\} +
	chown -Rf "${chown}" . ./*
	printf "Done.\n"
	# adjust values in bashbot.rc
	if [ -w "bashbot.rc" ]; then
		printf "Adjust user and botname in bashbot.rc ...\n"
		sed -i '/^[# ]*runas=/ s|runas=.*$|runas="'"${touser}"'"|' "bashbot.rc"
		sed -i '/^[# ]*bashbot=/ s|bashbot=.*$|bashbot="cd '"${PWD}"'; '"${PWD}"'/'"${0##*/}"'"|' "bashbot.rc"
		botname="$(getConfigKey "botname")"
		[ -n "${botname}" ] && sed -i '/^[# ]*name=/ s|name=.*$|name="'"${botname}"'"|' "bashbot.rc"
		printf "Done.\n"
	fi
	# ask to check bottoken online
	if [ -z "$(getConfigKey "botid")" ]; then
		printf "Seems to be your first init. Should I verify your bot token online? (y/N) N\b"
		read -r ANSWER
		if [[ "${ANSWER}" =~ ^[Yy] ]]; then
			printf "${GREEN}Contacting telegram to verify your bot token ...${NN}"
			$0 botname
		fi 
	fi
	# check if botconf seems valid
	printf "${GREEN}This is your bot config:${NN}"
	sed 's/^/\t/' "${BOTCONFIG}.jssh" | grep -vF '["bot_config_key"]'
	if check_token "$(getConfigKey "bottoken")" && [[ "$(getConfigKey "botadmin")" =~ ^[${o9o9o9}]+$ ]]; then
		printf "Bot config seems to be valid. Should I make a backup copy? (Y/n) Y\b"
		read -r ANSWER
		if [[ -z "${ANSWER}" || "${ANSWER}" =~ ^[^Nn] ]]; then
			printf "Copy bot config to ${BOTCONFIG}.jssh.ok ...\n"
			cp "${BOTCONFIG}.jssh" "${BOTCONFIG}.jssh.ok"
		fi 
	else
		printf "${ORANGE}Bot config may incomplete, pls check.${NN}"
	fi
	# show result
	ls -ld "${DATADIR}" "${LOGDIR}" ./*.jssh* ./*.sh 2>/dev/null
}

if ! _is_function send_message ; then
	printf "${RED}ERROR: send_message is not available, did you deactivate ${MODULEDIR}/sendMessage.sh?${NN}"
	exit 1
fi

# check if JSON.awk exist and has x flag
JSONAWKFILE="${JSONSHFILE%.sh}.awk"
if [ -x "${JSONAWKFILE}" ] && _exists awk ; then
	JSONSHFILE="JsonAwk"; JsonAwk() { "${JSONAWKFILE}" -v "BRIEF=8" -v "STRICT=0" -; }
fi

# source the script with source as param to use functions in other scripts
# do not execute if read from other scripts

if [ -z "${SOURCE}" ]; then
  ##############
  # internal options only for use from bashbot and developers
  # shellcheck disable=SC2221,SC2222
  case "$1" in
	# update botname when starting only
	"botname"|"start"*)
		ME="$(getBotName)"
		if [ -n "${ME}" ]; then
			# ok we have a connection and got botname, save it
			[ -n "${INTERACTIVE}" ] && printf "${GREY}Bottoken is valid ...${NN}"
			jssh_updateKeyDB "botname" "${ME}" "${BOTCONFIG}"
			rm -f "${BOTCONFIG}.jssh.flock"
		else
			printf "${GREY}Info: Can't get Botname from Telegram, try cached one ...${NN}"
			ME="$(getConfigKey "botname")"
			if [ -z "${ME}" ]; then
			    printf "${RED}ERROR: No cached botname, can't continue! ...${NN}"
			    exit 1
			fi
		fi
		[ -n "${INTERACTIVE}" ] && printf "Bot Name: %s\n" "${ME}"
		[ "$1" = "botname" ] && exit
		;;&
	# used to send output of background and interactive to chats
	"outproc")	# $2 chat_id $3 identifier of job, internal use only!
		[ -z "$3" ] && printf "No job identifier\n" && exit 3
		[ -z "$2"  ] && printf "No chat to send to\n" && exit 3
		ME="$(getConfigKey "botname")"
		# read until terminated
		while read -r line ;do
			[ -n "${line}" ] && send_message "$2" "${line}"
		done 
		# cleanup datadir, keep logfile if not empty
		rm -f -r "${DATADIR:-.}/$3"
		[ -s "${DATADIR:-.}/$3.log" ] || rm -f "${DATADIR:-.}/$3.log"
		debug_checks "end outproc" "$@"
		exit
		;;
	# finally starts the read update loop, internal use only1
	"startbot" )
		start_bot "$2"
		debug_checks "end startbot" "$@"
		exit
		;;
	# run after every update to update files and adjust permissions
	"init") 
		bot_init "$2"
		debug_checks "end init" "$@"
		exit
		;;
	# stats deprecated
	"stats"|"count")
		printf "${ORANGE}Stats is a separate command now, see bin/bashbot_stats.sh --help${NN}"
		"${BASHBOT_HOME:-.}"/bin/bashbot_stats.sh --help
		exit
		;;
	# broadcast deprecated
	'broadcast')
		printf "${ORANGE}Broadcast is a separate command now, see bin/send_broadcast.sh --help${NN}"
		"${BASHBOT_HOME:-.}"/bin/send_broadcast.sh --help
		exit
		;;
	# does what it says
	"status")
		ME="$(getConfigKey "botname")"
		SESSION="${ME:-_bot}-startbot"
		BOTPID="$(proclist "${SESSION}")"
		if [ -n "${BOTPID}" ]; then
			printf "${GREEN}Bot is running with UID ${RUNUSER}.${NN}"
			exit
		else
			printf "${ORANGE}No Bot running with UID ${RUNUSER}.${NN}"
			exit 5
		fi
		debug_checks "end status" "$@"
		;;
		 
	# start bot as background job and check if bot is running
	"start")
		# shellcheck disable=SC2086
		SESSION="${ME:-_bot}-startbot"
		BOTPID="$(proclist "${SESSION}")"
		# shellcheck disable=SC2086
		[ -n "${BOTPID}" ] && kill ${BOTPID}
		nohup "${SCRIPT}" "startbot" "$2" "${SESSION}" &>/dev/null &
		printf "Session Name: %s\n" "${SESSION}"
		sleep 1
		if [ -n "$(proclist "${SESSION}")" ]; then
		 	printf "${GREEN}Bot started successfully.${NN}"
		else
			printf "${RED}An error occurred while starting the bot.${NN}"
			exit 5
		fi
		debug_checks "end start" "$@"
		;;
	# does what it says
	"stop")
		ME="$(getConfigKey "botname")"
		SESSION="${ME:-_bot}-startbot"
		BOTPID="$(proclist "${SESSION}")"
		if [ -n "${BOTPID}" ]; then
			# shellcheck disable=SC2086
			if kill ${BOTPID}; then
				# inform botadmin about stop
				send_normal_message "$(getConfigKey "botadmin")" "Bot ${ME} stopped ..." &
				printf "${GREEN}OK. Bot stopped successfully.${NN}"
			else
				printf "${RED}An error occurred while stopping bot.${NN}"
				exit 5
			fi
		else
			printf "${ORANGE}No Bot running with UID ${RUNUSER}.${NN}"
		fi
		debug_checks "end stop" "$@"
		exit
		;;
	# suspend, resume or kill background jobs
	"suspendb"*|"resumeb"*|"killb"*)
  		_is_function job_control || { printf "${RED}Module background is not available!${NN}"; exit 3; }
		ME="$(getConfigKey "botname")"
		job_control "$1"
		debug_checks "end background $1" "$@"
		;;
	*)
		printf "${RED}${REALME##*/}: unknown command${NN}"
		printf "${ORANGE}Available commands: ${GREY}${BOTCOMMANDS}${NN}" && exit
		exit 4
		;;
  esac

  # warn if root
  if [[ "${UID}" -eq "0" ]] ; then
	printf "\n${ORANGE}WARNING: ${SCRIPT} was started as ROOT (UID 0)!${NN}"
	printf "${ORANGE}You are at HIGH RISK when running a Telegram BOT with root privileges!${NN}"
  fi
fi # end source
-												Starting to work on interactive commands
											
										
										
											2016-01-02 19:35:15 +00:00
+								#!/bin/bash
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								##################################################################
 								#
 								# File: bashbot.sh
 								# Note: DO NOT EDIT! this file will be overwritten on update
-												rework help, provide option -h --help

											
										
										
											2021-01-01 20:36:48 +00:00
+								# shellcheck disable=SC2140,SC2031,SC2120,SC1091,SC1117,SC2059
 								#
 								# Description: bashbot, the Telegram bot written in bash.
-												prepare for v0.5, add version numbers to files

											
										
										
											2019-03-28 15:51:33 +00:00
+								#
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								#     Written by Drew (@topkecleon) KayM (@gnadelwartz).
-												credits to dcoomber

											
										
										
											2021-01-02 09:18:58 +00:00
+								#     Also contributed: Daniil Gentili (@danog), JuanPotato, BigNerd95,
 								#                       TiagoDanin, iicc1, dcoomber
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								#     https://github.com/topkecleon/telegram-bot-bash
 								#
 								#     This file is public domain in the USA and all free countries.
 								#     Elsewhere, consider it to be WTFPLv2. (wtfpl.net/txt/copying)
-												some typo, specify exit codes

											
										
										
											2019-04-01 10:52:25 +00:00
+								#
-												some minor improvments

											
										
										
											2021-01-15 18:05:53 +00:00
+								# Usage: bashbot.sh BOTCOMMAND
-												mycommands: factor out config and messages

											
										
										
											2021-01-09 06:46:46 +00:00
+								BOTCOMMANDS="-h  help  init  start  stop  status  suspendback  resumeback  killback"
-												rework help, provide option -h --help

											
										
										
											2021-01-01 20:36:48 +00:00
+								#
-												some typo, specify exit codes

											
										
										
											2019-04-01 10:52:25 +00:00
+								# Exit Codes:
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								#     0 - success (hopefully)
 								#     1 - can't change to dir
 								#     2 - can't write to tmp, count or token
 								#     3 - user / command / file not found
 								#     4 - unknown command
-												error code 5 description

											
										
										
											2021-01-01 18:56:19 +00:00
+								#     5 - cannot start, stop or get status
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								#     6 - mandatory module not found
 								#     7 - can't get bottoken
 								#     8 - curl/wget missing
 								#     10 - not bash!
 								#
-												iBUTTON: infrastructe seems to work

											
										
										
											2021-01-24 12:04:20 +00:00
+								#### $$VERSION$$ v1.35-dev-2-g1fe22a0
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								##################################################################
-												make bashbot more failsave on startup

											
										
										
											2019-03-22 16:47:36 +00:00
-												Merging with topkecleon-develop

											
										
										
											2020-09-27 18:24:15 +00:00
+								# emmbeded system may claim bash but it is not
 								# check for bash like ARRAY handlung
 								if ! (unset a; set -A a a; eval "a=(a b)"; eval '[ -n "${a[1]}" ]'; ) > /dev/null 2>&1; then
-												fix typo's provided by @dcoomber

											
										
										
											2021-01-01 21:00:46 +00:00
+									printf "Error: Current shell does not support ARRAY's, may be busybox ash shell. pls install a real bash!\n"
-												Merging with topkecleon-develop

											
										
										
											2020-09-27 18:24:15 +00:00
+									exit 10
 								fi
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+								# are we running in a terminal?
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+								NN="\n"
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								if [ -t 1 ] && [ -n "${TERM}" ];  then
-												CLEAR -> INTERACTIVE

											
										
										
											2020-12-27 10:26:38 +00:00
+								    INTERACTIVE='yes'
-												make bashbot.sh not output colors and clear when not interactive

											
										
										
											2019-03-28 13:24:08 +00:00
+								    RED='\e[31m'
 								    GREEN='\e[32m'
 								    ORANGE='\e[35m'
-												add some bot token warnings

											
										
										
											2020-05-18 12:57:53 +00:00
+								    GREY='\e[1;30m'
-												make bashbot.sh not output colors and clear when not interactive

											
										
										
											2019-03-28 13:24:08 +00:00
+								    NC='\e[0m'
-												fix NN

											
										
										
											2020-12-27 11:38:52 +00:00
+								    NN="${NC}\n"
-												make bashbot.sh not output colors and clear when not interactive

											
										
										
											2019-03-28 13:24:08 +00:00
+								fi
-												check for utf-8 locale

											
										
										
											2020-12-24 08:19:54 +00:00
+								# telegram uses utf-8 characters, check if we have an utf-8 charset
 								if [ "${LANG}" = "${LANG%[Uu][Tt][Ff]*}" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${ORANGE}Warning: Telegram uses utf-8, but looks like you are using non utf-8 locale:${NC} ${LANG}\n"
-												check for utf-8 locale

											
										
										
											2020-12-24 08:19:54 +00:00
+								fi
-												Merging with topkecleon-develop

											
										
										
											2020-09-27 18:24:15 +00:00
+								# we need some bash 4+ features, check for old bash by feature
-												finally eliminate echo ...

											
										
										
											2021-01-01 16:14:59 +00:00
+								if [ "$({ LC_ALL=C.utf-8 printf "%b" "\u1111"; } 2>/dev/null)" = "\u1111" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${ORANGE}Warning: Missing unicode '\uxxxx' support, missing C.utf-8 locale or to old bash version.${NN}"
-												Merging with topkecleon-develop

											
										
										
											2020-09-27 18:24:15 +00:00
+								fi
-												check for locale C

											
										
										
											2020-12-07 14:50:56 +00:00
-												bashbot.sh implement new a-z soluition

											
										
										
											2021-01-04 15:03:53 +00:00
+								# in UTF-8 äöü etc. are part of [:alnum:] and ranges (e.g. a-z), but we want ASCII a-z ranges!
 								# for more information see  doc/4_expert.md#Character_classes
 								azazaz='abcdefghijklmnopqrstuvwxyz'	# a-z   :lower:
 								AZAZAZ='ABCDEFGHIJKLMNOPQRSTUVWXYZ'	# A-Z   :upper:
-												replace R090909 -> o9o9o9 , better readable

											
										
										
											2021-01-04 15:10:43 +00:00
+								o9o9o9='0123456789'			# 0-9   :digit:
-												bashbot.sh implement new a-z soluition

											
										
										
											2021-01-04 15:03:53 +00:00
+								azAZaz="${azazaz}${AZAZAZ}"	# a-zA-Z	:alpha:
-												replace R090909 -> o9o9o9 , better readable

											
										
										
											2021-01-04 15:10:43 +00:00
+								azAZo9="${azAZaz}${o9o9o9}"	# a-zA-z0-9	:alnum:
-												bashbot.sh implement new a-z soluition

											
										
										
											2021-01-04 15:03:53 +00:00
-												fix BOTTOKEN check

											
										
										
											2020-05-14 19:31:52 +00:00
+								# some important helper functions
 								# returns true if command exist
-												use function _round_float for converting ms to s

											
										
										
											2020-06-10 09:11:42 +00:00
+								_exists() {
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									[ "$(type -t "$1")" = "file" ]
-												fix BOTTOKEN check

											
										
										
											2020-05-14 19:31:52 +00:00
+								}
 								# execute function if exists
 								_exec_if_function() {
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									[ "$(type -t "$1")" != "function" ] && return 1
-												cache botconfig, optimze updateArray

											
										
										
											2020-06-15 07:09:08 +00:00
+									"$@"
-												fix BOTTOKEN check

											
										
										
											2020-05-14 19:31:52 +00:00
+								}
 								# returns true if function exist
-												use function _round_float for converting ms to s

											
										
										
											2020-06-10 09:11:42 +00:00
+								_is_function() {
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									[ "$(type -t "$1")" = "function" ]
-												use function _round_float for converting ms to s

											
										
										
											2020-06-10 09:11:42 +00:00
+								}
 								# round $1 in international notation! , returns float with $2 decimal digits
-												some more comment polishing

											
										
										
											2020-08-01 09:37:32 +00:00
+								# if $2 is not given or is not a positive number zero is assumed
-												use function _round_float for converting ms to s

											
										
										
											2020-06-10 09:11:42 +00:00
+								_round_float() {
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									local digit="$2"; [[ "$2" =~ ^[${o9o9o9}]+$ ]] || digit="0"
-												make _round_float more LANG independent (C not installed)

											
										
										
											2021-01-18 20:09:30 +00:00
+									: "$(LC_ALL=C printf "%.${digit}f" "$1" 2>/dev/null)"
-												dev: adjust make-standalone

											
										
										
											2021-01-20 18:50:19 +00:00
+									printf "%s" "${_//,/.}"	# make more LANG independent
-												fix BOTTOKEN check

											
										
										
											2020-05-14 19:31:52 +00:00
+								}
-												internal: printf date is 100 times faster

											
										
										
											2021-01-06 07:48:25 +00:00
+								# date is external, printf is much faster
 								_date(){
 									printf "%(%c)T\n" -1
 								}
-												create setconfigKey, clean botconfig on update startup

											
										
										
											2020-06-13 19:39:52 +00:00
+								setConfigKey() {
-												replace R090909 -> o9o9o9 , better readable

											
										
										
											2021-01-04 15:10:43 +00:00
+									[[ "$1" =~ ^[-${azAZo9},._]+$ ]] || return 3
-												avoid unintended file overwrite

											
										
										
											2020-06-20 18:12:36 +00:00
+									[ -z "${BOTCONFIG}" ] && return 1
-												rename BOTDATABASE to BOTCONFIG

											
										
										
											2020-06-19 10:49:18 +00:00
+									printf '["%s"]\t"%s"\n' "${1//,/\",\"}" "${2//\"/\\\"}" >>"${BOTCONFIG}.jssh"
-												use jsshDB internally, e.g. block / count users, it's working well now

											
										
										
											2020-06-01 07:54:35 +00:00
+								}
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+								getConfigKey() {
-												replace R090909 -> o9o9o9 , better readable

											
										
										
											2021-01-04 15:10:43 +00:00
+									[[ "$1" =~ ^[-${azAZo9},._]+$ ]] || return 3
-												sed/grep no redirect from file

											
										
										
											2021-01-16 10:20:29 +00:00
+									[ -r "${BOTCONFIG}.jssh" ] && sed -n 's/\["'"$1"'"\]\t*"\(.*\)"/\1/p' "${BOTCONFIG}.jssh" | tail -n 1
-												use jsshDB internally, e.g. block / count users, it's working well now

											
										
										
											2020-06-01 07:54:35 +00:00
+								}
-												move JsonEscape up before sourcing other files

											
										
										
											2021-01-23 13:06:55 +00:00
+								# escape / remove text characters for json strings, eg. " -> \"
 								# $1 string
 								# output escaped string
 								JsonEscape(){
 									sed 's/\([-"`´,§$%&/(){}#@!?*.\t]\)/\\\1/g' <<< "$1"
 								}
-												some more comment polishing

											
										
										
											2020-08-01 09:37:32 +00:00
+								# check if $1 seems a valid token
-												start using log_error

											
										
										
											2020-06-27 08:43:08 +00:00
+								# return true if token seems to be valid
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+								check_token(){
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									[[ "$1" =~ ^[${o9o9o9}]{8,10}:[${azAZo9}_-]{35}$ ]] && return 0
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+									return 1
 								}
-												fix log_message, log_updates do not interpret \n\t etc

											
										
										
											2020-12-30 09:03:23 +00:00
+								# log $1 with date
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+								log_error(){ printf "%(%c)T: %s\n" -1 "$*" >>"${ERRORLOG}"; }
 								log_debug(){ printf "%(%c)T: %s\n" -1 "$*" >>"${DEBUGLOG}"; }
 								log_update(){ printf "%(%c)T: %s\n" -1 "$*" >>"${UPDATELOG}"; }
-												fix log_error, log_update do not interpret \n\t etc

											
										
										
											2020-12-30 09:07:10 +00:00
+								# log $1 with date, special first \n
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+								log_message(){ printf "\n%(%c)T: %s\n" -1 "${1/\\n/$'\n'}" >>"${MESSAGELOG}"; }
-												move detect_curl to common functions

											
										
										
											2021-01-14 21:15:32 +00:00
+								# curl is preferred, try detect curl even not in PATH
 								# sets BASHBOT_CURL to point to curl
 								DETECTED_CURL="curl"
 								detect_curl() {
 									local file warn="Warning: Curl not detected, try fallback to wget! pls install curl or adjust BASHBOT_CURL/BASHBOT_WGET environment variables."
 									# custom curl command
 									[ -n "${BASHBOT_CURL}" ] && return 0
 									# use wget
 									[ -n "${BASHBOT_WGET}" ] && DETECTED_CURL="wget" && return 1
 									# default use curl in PATH
 									BASHBOT_CURL="curl"
 									_exists curl && return 0
 									# search in usual locations
 									for file in /usr/bin /bin /usr/local/bin; do
 										[ -x "${file}/curl" ] && BASHBOT_CURL="${file}/curl" && return 0
 									done
 									# curl not in PATH and not in usual locations
 									DETECTED_CURL="wget"
 									log_update "${warn}"; [ -n "${BASHBOTDEBUG}" ] && log_debug "${warn}"
 									return 1
 								}
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+								# additional tests if we run in debug mode
-												rework BASHBOTDEBUG is always global

											
										
										
											2020-06-30 05:26:16 +00:00
+								export BASHBOTDEBUG
-												debug should always last argument

											
										
										
											2020-07-10 06:39:33 +00:00
+								[[ "${BASH_ARGV[0]}" == *"debug"* ]] && BASHBOTDEBUG="yes"
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
-												debug should always last argument

											
										
										
											2020-07-10 06:39:33 +00:00
+								# $1 where $2 command $3 may debug
-												fix DEBUGLOG not set

											
										
										
											2020-07-11 06:34:57 +00:00
+								# shellcheck disable=SC2094
-												try to avoid empty DEBUG.log file

											
										
										
											2020-12-15 16:19:09 +00:00
+								debug_checks(){ {
-												move old logfiles to logs on init

											
										
										
											2020-07-09 20:31:58 +00:00
+									[  -z "${BASHBOTDEBUG}" ] && return
-												bashbot.sh: jsonDecode: use printf

											
										
										
											2021-01-15 12:09:32 +00:00
+									local token where="$1"; shift
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+									printf "%(%c)T: debug_checks: %s: bashbot.sh %s\n" -1 "${where}" "${1##*/}"
-												fix DEBUGLOG not set

											
										
										
											2020-07-11 06:34:57 +00:00
+									# shellcheck disable=SC2094
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+									[ -z "${DEBUGLOG}" ] && printf "%(%c)T: %s\n" -1 "DEBUGLOG not set! =========="
-												internal: printf date is 100 times faster

											
										
										
											2021-01-06 07:48:25 +00:00
+									token="$(getConfigKey "bottoken")"
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+									[ -z "${token}" ] && printf "%(%c)T: %s\n" -1 "Bot token is missing! =========="
 									check_token "${token}" || printf "%(%c)T: %s\n%s\n" -1 "Invalid bot token! ==========" "${token}"
 									[ -z "$(getConfigKey "botadmin")" ] && printf "%(%c)T: %s\n" -1 "Bot admin is missing! =========="
-												move individual debug checks to mycommands.sh part 2

											
										
										
											2020-07-02 15:24:56 +00:00
+									# call user defined debug_checks if exists
-												internal: printf date is 100 times faster

											
										
										
											2021-01-06 07:48:25 +00:00
+									_exec_if_function my_debug_checks "$(_date)" "${where}" "$*"
-												try to avoid empty DEBUG.log file

											
										
										
											2020-12-15 16:19:09 +00:00
+									} >>"${DEBUGLOG}"
 								}
-												fix BOTTOKEN check

											
										
										
											2020-05-14 19:31:52 +00:00
-												Standardised usage of Linux and Unix

											
										
										
											2021-01-02 05:17:02 +00:00
+								# some Linux distributions (e.g. Manjaro) doesn't seem to have C locale activated by default
-												Bashbot Version 1.21 (cleanup release)

											
										
										
											2021-01-03 21:39:36 +00:00
+								if _exists locale && [ "$(locale -a | grep -c -e "^C$" -e "^C.[uU][tT][fF]")" -lt 2 ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${ORANGE}Warning: locale ${NC}${GREY}C${NC}${ORANGE} and/or ${NC}${GREY}C.utf8${NC}${ORANGE} seems missing, use \"${NC}${GREY}locale -a${NC}${ORANGE}\" to show what locales are installed on your system.${NN}"
-												check for locale C

											
										
										
											2020-12-07 14:50:56 +00:00
+								fi
-												implement ENV varible usage

											
										
										
											2019-04-23 11:07:20 +00:00
+								# get location and name of bashbot.sh
 								SCRIPT="$0"
-												autodetect sourcing, add CURL and WGET options, e.g. for using tor

											
										
										
											2019-05-23 17:40:15 +00:00
+								REALME="${BASH_SOURCE[0]}"
 								SCRIPTDIR="$(dirname "${REALME}")"
 								RUNDIR="$(dirname "$0")"
 								MODULEDIR="${SCRIPTDIR}/modules"
-												optimze sourcing of modules

											
										
										
											2020-05-14 17:47:37 +00:00
+								# adjust locations based on source and real name
-												combine printf

											
										
										
											2021-01-01 20:48:59 +00:00
+								[[ "${SCRIPT}" != "${REALME}" || "$1" == "source" ]] && SOURCE="yes"
-												Add BASHBOT_HOME, commandline examples

											
										
										
											2019-05-23 10:26:53 +00:00
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								if [ -n "${BASHBOT_HOME}" ]; then
 									SCRIPTDIR="${BASHBOT_HOME}"
-												fix wrong json.sh location if included from other location

											
										
										
											2020-06-04 14:10:58 +00:00
+								 else
 									BASHBOT_HOME="${SCRIPTDIR}"
-												Add BASHBOT_HOME, commandline examples

											
										
										
											2019-05-23 10:26:53 +00:00
+								fi
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								[ -z "${BASHBOT_ETC}" ] && BASHBOT_ETC="${BASHBOT_HOME}"
 								[ -z "${BASHBOT_VAR}" ] && BASHBOT_VAR="${BASHBOT_HOME}"
-												Add BASHBOT_HOME, commandline examples

											
										
										
											2019-05-23 10:26:53 +00:00
-												fix addon dir if BASHBOT_HOME is set

											
										
										
											2020-06-06 07:21:56 +00:00
+								ADDONDIR="${BASHBOT_ETC:-.}/addons"
-												dev: adjust make-standalone

											
										
										
											2021-01-20 18:50:19 +00:00
+								RUNUSER="${USER}"	# USER is overwritten by bashbot array :-(, save original
-												check if we can change to bashbot dir

											
										
										
											2019-03-31 10:52:11 +00:00
-												rework help, provide option -h --help

											
										
										
											2021-01-01 20:36:48 +00:00
+								# provide help
 								case "$1" in
-												dev: move ascii art to bin/

											
										
										
											2021-01-08 21:32:05 +00:00
+									"") [ -z "${SOURCE}" ] && printf "${ORANGE}Available commands: ${GREY}${BOTCOMMANDS}${NN}" && exit
-												fix source without arg source

											
										
										
											2021-01-01 23:40:42 +00:00
+										;;
-												doc: move bashbot.ascii

											
										
										
											2021-01-09 21:25:15 +00:00
+									"-h"*)	LOGO="${BASHBOT_HOME:-.}/doc/bashbot.ascii"
-												some minor improvments

											
										
										
											2021-01-15 18:05:53 +00:00
+										{ [ -r "${LOGO}" ] && cat "${LOGO}"
-												sed/grep no redirect from file

											
										
										
											2021-01-16 10:20:29 +00:00
+										sed -nE -e '/(NOT EDIT)|(shellcheck)/d' -e '3,/###/p' "$0"; } | more
-												rework help, provide option -h --help

											
										
										
											2021-01-01 20:36:48 +00:00
+										exit;;
 									"help") HELP="${BASHBOT_HOME:-.}/README"
 										if [ -n "${INTERACTIVE}" ];then
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+											_exists w3m && w3m "${HELP}.html" && exit
 											_exists lynx && lynx "${HELP}.html" && exit
 											_exists less && less "${HELP}.txt" && exit
-												rework help, provide option -h --help

											
										
										
											2021-01-01 20:36:48 +00:00
+										fi
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+										cat "${HELP}.txt"
-												rework help, provide option -h --help

											
										
										
											2021-01-01 20:36:48 +00:00
+										exit;;
 								esac
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								# OK, ENVIRONMENT is set up, let's do some additional tests
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								if [[ -z "${SOURCE}" && -z "${BASHBOT_HOME}" ]] && ! cd "${RUNDIR}" ; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${RED}ERROR: Can't change to ${RUNDIR} ...${NN}"
-												check if we can change to bashbot dir

											
										
										
											2019-03-31 10:52:11 +00:00
+									exit 1
-												make bashbot more failsave on startup

											
										
										
											2019-03-22 16:47:36 +00:00
+								fi
-												some test optimisations

											
										
										
											2021-01-01 23:11:23 +00:00
+								RUNDIR="."
 								[ ! -w "." ] && printf "${ORANGE}WARNING: ${RUNDIR} is not writeable!${NN}"
-												add possibility to execute multiple background scripts

											
										
										
											2019-03-18 13:45:19 +00:00
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								# check if JSON.sh is available
 								JSONSHFILE="${BASHBOT_JSONSH:-${SCRIPTDIR}/JSON.sh/JSON.sh}"
 								[ ! -x "${JSONSHFILE}" ] &&\
-												check for JSON.sh executable only

											
										
										
											2021-01-01 20:40:51 +00:00
+									 printf "${RED}ERROR:${NC} ${JSONSHFILE} ${RED}does not exist, are we in dev environment?${NN}${GREY}%s${NN}\n"\
-												some test optimisations

											
										
										
											2021-01-01 23:11:23 +00:00
+										"\$JSONSHFILE is set wrong or bashbot is not installed correctly, see doc/0_install.md" && exit 3
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
 								# file locations based on ENVIRONMENT
-												rename BOTDATABASE to BOTCONFIG

											
										
										
											2020-06-19 10:49:18 +00:00
+								BOTCONFIG="${BASHBOT_ETC:-.}/botconfig"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								BOTACL="${BASHBOT_ETC:-.}/botacl"
 								DATADIR="${BASHBOT_VAR:-.}/data-bot-bash"
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+								BLOCKEDFILE="${BASHBOT_VAR:-.}/blocked"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								COUNTFILE="${BASHBOT_VAR:-.}/count"
-												place DEBUG anf ERROR log in ./logs if exist

											
										
										
											2020-06-06 12:48:01 +00:00
+								LOGDIR="${RUNDIR:-.}/logs"
-												no more autoatic download of JSON.sh

											
										
										
											2020-12-27 13:53:00 +00:00
+								# CREATE botconfig if not exist
-												some more comment polishing

											
										
										
											2020-08-01 09:37:32 +00:00
+								# assume everything already set up correctly if TOKEN is set
-												data-bot-bash is created while installing

											
										
										
											2021-01-01 18:01:26 +00:00
+								if [ -z "${BOTTOKEN}" ]; then
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
+								  # BOTCONFIG does not exist, create
-												data-bot-bash is created while installing

											
										
										
											2021-01-01 18:01:26 +00:00
+								  [ ! -f "${BOTCONFIG}.jssh" ] && printf '["bot_config_key"]\t"config_key_value"\n' >>"${BOTCONFIG}.jssh"
 								  if [ -z "$(getConfigKey "bottoken")" ]; then
 								    # ask user for bot token
 								    if [ -z "${INTERACTIVE}" ] && [ "$1" != "init" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "Running headless, set BOTTOKEN or run ${SCRIPT} init first!\n"
-												user_is_botadmin final

											
										
										
											2019-04-12 09:27:20 +00:00
+									exit 2
-												data-bot-bash is created while installing

											
										
										
											2021-01-01 18:01:26 +00:00
+								    else
-												combine printf

											
										
										
											2021-01-01 20:48:59 +00:00
+									printf "${RED}ENTER BOT TOKEN...${NN}${ORANGE}PLEASE WRITE YOUR TOKEN HERE OR PRESS CTRL+C TO ABORT${NN}"
-												create setconfigKey, clean botconfig on update startup

											
										
										
											2020-06-13 19:39:52 +00:00
+									read -r token
-												better messages when entering bot token and bot admin

											
										
										
											2020-12-27 11:51:19 +00:00
+									printf "\n"
-												data-bot-bash is created while installing

											
										
										
											2021-01-01 18:01:26 +00:00
+								    fi
 								    [ -n "${token}" ] && printf '["bottoken"]\t"%s"\n'  "${token}" >> "${BOTCONFIG}.jssh"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								  fi
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+								  # no botadmin, setup botadmin
-												create setconfigKey, clean botconfig on update startup

											
										
										
											2020-06-13 19:39:52 +00:00
+								  if [ -z "$(getConfigKey "botadmin")" ]; then
-												no more convert old config

											
										
										
											2020-12-27 13:58:34 +00:00
+								     # ask user for bot admin
 								     if [ -z "${INTERACTIVE}" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "Running headless, set botadmin to AUTO MODE!\n"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								     else
-												combine printf

											
										
										
											2021-01-01 20:48:59 +00:00
+									printf "${RED}ENTER BOT ADMIN...${NN}${ORANGE}PLEASE WRITE YOUR TELEGRAM ID HERE OR PRESS ENTER\nTO MAKE FIRST USER TYPING '/start' BOT ADMIN${NN}?\b"
-.80-pre, adjust doc, convert echo with parameters to fprint

											
										
										
											2019-05-20 08:50:51 +00:00
+									read -r admin
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								     fi
-												create setconfigKey, clean botconfig on update startup

											
										
										
											2020-06-13 19:39:52 +00:00
+								     [ -z "${admin}" ] && admin='?'
-												rename BOTDATABASE to BOTCONFIG

											
										
										
											2020-06-19 10:49:18 +00:00
+								     printf '["botadmin"]\t"%s"\n'  "${admin}" >> "${BOTCONFIG}.jssh"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								  fi
 								  # setup botacl file
 								  if [ ! -f "${BOTACL}" ]; then
-												some minor text changes

											
										
										
											2020-12-27 20:17:39 +00:00
+									printf "${GREY}Create initial ${BOTACL} file.${NN}"
-.80-pre, adjust doc, convert echo with parameters to fprint

											
										
										
											2019-05-20 08:50:51 +00:00
+									printf '\n' >"${BOTACL}"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								  fi
-												data-bot-bash is created while installing

											
										
										
											2021-01-01 18:01:26 +00:00
+								  # check data dir file
 								  if [ ! -w "${DATADIR}" ]; then
-												tests: adapt data-bot-bash created at installation

											
										
										
											2021-01-01 18:25:25 +00:00
+									printf "${RED}ERROR: ${DATADIR} does not exist or is not writeable!.${NN}"
-												some typo, specify exit codes

											
										
										
											2019-04-01 10:52:25 +00:00
+									exit 2
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								  fi
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+								  # setup count file
 								  if [ ! -f "${COUNTFILE}.jssh" ]; then
-												avoid unintended file overwrite

											
										
										
											2020-06-20 18:12:36 +00:00
+									printf '["counted_user_chat_id"]\t"num_messages_seen"\n' >> "${COUNTFILE}.jssh"
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+								  elif [ ! -w "${COUNTFILE}.jssh" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${RED}ERROR: Can't write to ${COUNTFILE}!.${NN}"
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+									ls -l "${COUNTFILE}.jssh"
-												some typo, specify exit codes

											
										
										
											2019-04-01 10:52:25 +00:00
+									exit 2
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								  fi
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+								  # setup blocked file
 								  if [ ! -f "${BLOCKEDFILE}.jssh" ]; then
-												avoid unintended file overwrite

											
										
										
											2020-06-20 18:12:36 +00:00
+									printf '["blocked_user_or_chat_id"]\t"name and reason"\n' >>"${BLOCKEDFILE}.jssh"
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+								  fi
-												make bashbot more failsave on startup

											
										
										
											2019-03-22 16:47:36 +00:00
+								fi
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
-												try to avoid empty DEBUG.log file

											
										
										
											2020-12-15 16:19:09 +00:00
+								if [[ ! -d "${LOGDIR}" || ! -w "${LOGDIR}" ]]; then
-												create log dir on init

											
										
										
											2020-07-09 11:41:09 +00:00
+									LOGDIR="${RUNDIR:-.}"
 								fi
 								DEBUGLOG="${LOGDIR}/DEBUG.log"
 								ERRORLOG="${LOGDIR}/ERROR.log"
 								UPDATELOG="${LOGDIR}/BASHBOT.log"
-												sendJson check chat is a number

											
										
										
											2020-12-15 09:12:18 +00:00
+								MESSAGELOG="${LOGDIR}/MESSAGE.log"
-												create log dir on init

											
										
										
											2020-07-09 11:41:09 +00:00
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+								# read BOTTOKEN from bot database if not set
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
+								if [ -z "${BOTTOKEN}" ]; then
 								    BOTTOKEN="$(getConfigKey "bottoken")"
-												process help at beginning

											
										
										
											2020-06-19 11:15:50 +00:00
+								    if [ -z "${BOTTOKEN}" ]; then
-												fix recover botconfig

											
										
										
											2020-12-18 14:24:21 +00:00
+										BOTERROR="Warning: can't get bot token, try to recover working config..."
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										printf "${ORANGE}${BOTERROR}${NC} "
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+										if [ -r "${BOTCONFIG}.jssh.ok" ]; then
 											log_error "${BOTERROR}"
-												save corrupt bot config on recover

											
										
										
											2020-12-27 12:12:38 +00:00
+											mv "${BOTCONFIG}.jssh" "${BOTCONFIG}.jssh.bad"
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											cp "${BOTCONFIG}.jssh.ok" "${BOTCONFIG}.jssh"; printf "OK\n"
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											BOTTOKEN="$(getConfigKey "bottoken")"
 										else
-												save corrupt bot config on recover

											
										
										
											2020-12-27 12:12:38 +00:00
+											printf "\n${RED}Error: Can't recover from missing bot token! Remove ${BOTCONFIG}.jssh and run${NC} bashbot.sh init\n"
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											exit 7
 										fi
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
+								    fi
-												add some bot token warnings

											
										
										
											2020-05-18 12:57:53 +00:00
+								fi
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
-												install gnu utils on BSD and MacOS ...

											
										
										
											2020-05-19 12:58:29 +00:00
+								# BOTTOKEN format checks
-												fix missing copy botconfig

											
										
										
											2020-06-27 10:43:46 +00:00
+								if ! check_token "${BOTTOKEN}"; then
-												multiline printf

											
										
										
											2021-01-01 20:55:13 +00:00
+									printf "\n${ORANGE}Warning: Your bot token is incorrect, it should have the following format:${NC}\n%b%b"\
 										"<your_bot_id>${RED}:${NC}<35_alphanumeric_characters-hash> ${RED}e.g. =>${NC} 123456789${RED}:${NC}Aa-Zz_0Aa-Zz_1Aa-Zz_2Aa-Zz_3Aa-Zz_4\n\n"\
 										"${GREY}Your bot token: '${NC}${BOTTOKEN//:/${RED}:${NC}}'\n"
-												better messages for invalid bot token

											
										
										
											2020-12-27 11:34:39 +00:00
-												replace R090909 -> o9o9o9 , better readable

											
										
										
											2021-01-04 15:10:43 +00:00
+									if [[ ! "${BOTTOKEN}" =~ ^[${o9o9o9}]{8,10}: ]]; then
-												multiline printf

											
										
										
											2021-01-01 20:55:13 +00:00
+										printf "${GREY}\tHint: Bot id not a number or wrong len: ${NC}$(($(wc -c <<<"${BOTTOKEN%:*}")-1)) ${GREY}but should be${NC} 8-10\n"
-												better messages for invalid bot token

											
										
										
											2020-12-27 11:34:39 +00:00
+										[ -n "$(getConfigKey "botid")" ] && printf "\t${GREEN}Did you mean: \"${NC}$(getConfigKey "botid")${GREEN}\" ?${NN}"
-												bottoken starts with bot id

											
										
										
											2020-12-05 13:11:21 +00:00
+									fi
-												replace R090909 -> o9o9o9 , better readable

											
										
										
											2021-01-04 15:10:43 +00:00
+									[[ ! "${BOTTOKEN}" =~ :[${azAZo9}_-]{35}$ ]] &&\
-												multiline printf

											
										
										
											2021-01-01 20:55:13 +00:00
+										printf "${GREY}\tHint: Hash contains invalid character or has not len${NC} 35 ${GREY}, hash len is ${NC}$(($(wc -c <<<"${BOTTOKEN#*:}")-1))\n"
-												better messages for invalid bot token

											
										
										
											2020-12-27 11:34:39 +00:00
+									printf "\n"
-												add some bot token warnings

											
										
										
											2020-05-18 12:57:53 +00:00
+								fi
-												make bashbot more failsave on startup

											
										
										
											2019-03-22 16:47:36 +00:00
-												extended JsonEscape for V2

											
										
										
											2020-05-20 14:38:56 +00:00
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+								##################
 								# here we start with the real stuff
-												dev: adjust make-standalone

											
										
										
											2021-01-20 18:50:19 +00:00
+								BASHBOT_RETRY=""	# retry by default
-												revert some optimizations

											
										
										
											2019-04-12 18:49:58 +00:00
-												revert and redo fixed last commit

											
										
										
											2020-06-10 06:20:48 +00:00
+								URL="${BASHBOT_URL:-https://api.telegram.org/bot}${BOTTOKEN}"
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								ME_URL=${URL}'/getMe'
-												revert some optimizations

											
										
										
											2019-04-12 18:49:58 +00:00
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+								#################
 								# BASHBOT COMMON functions
-												remove unneeded BOTADMIN TOKENFILE variables

											
										
										
											2020-12-31 17:02:31 +00:00
+								declare -rx SCRIPT SCRIPTDIR MODULEDIR RUNDIR ADDONDIR BOTACL DATADIR COUNTFILE
-												remove URLs used once

											
										
										
											2021-01-14 16:47:06 +00:00
+								declare -rx BOTTOKEN URL ME_URL
-												make some globals readonly

											
										
										
											2019-05-28 19:12:02 +00:00
-												use declare -x

											
										
										
											2019-05-28 18:50:19 +00:00
+								declare -ax CMD
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+								declare -Ax UPD BOTSENT USER MESSAGE URLS CONTACT LOCATION CHAT FORWARD REPLYTO VENUE iQUERY iBUTTON
-												detect supergroup migration

											
										
										
											2020-12-13 11:00:18 +00:00
+								declare -Ax SERVICE NEWMEMBER LEFTMEMBER PINNED MIGRATE
-												option to ignore commands for other bots if admin

											
										
										
											2020-12-14 19:35:45 +00:00
+								export res CAPTION ME
-												revert some optimizations

											
										
										
											2019-04-12 18:49:58 +00:00
-												final _exec_if_function, fix env_test

											
										
										
											2019-05-26 19:25:01 +00:00
-												load modules before commands.sh

											
										
										
											2021-01-20 17:20:03 +00:00
+								###############
 								# load modules
 								for module in "${MODULEDIR:-.}"/*.sh ; do
 									# shellcheck source=./modules/aliases.sh
 									if ! _is_function "$(basename "${module}")" && [ -r "${module}" ]; then source "${module}" "source"; fi
 								done
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+								##################
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+								# read commands file if we are not sourced
-												add debug mode, remove old test mode

											
										
										
											2019-05-10 09:33:41 +00:00
+								COMMANDS="${BASHBOT_ETC:-.}/commands.sh"
-												some test optimisations

											
										
										
											2021-01-01 23:11:23 +00:00
+								if [  -r "${COMMANDS}" ]; then
 									# shellcheck source=./commands.sh
 									 source "${COMMANDS}" "source"
 								else
 									[ -z "${SOURCE}" ] && printf "${RED}Warning: ${COMMANDS} does not exist or is not readable!.${NN}"
-												add debug mode, remove old test mode

											
										
										
											2019-05-10 09:33:41 +00:00
+								fi
-												internal: printf date is 100 times faster

											
										
										
											2021-01-06 07:48:25 +00:00
+								debug_checks "start SOURCE=${SOURCE:-no}" "$@"
-												add debug mode, remove old test mode

											
										
										
											2019-05-10 09:33:41 +00:00
-												revert and redo fixed last commit

											
										
										
											2020-06-10 06:20:48 +00:00
 								#####################
 								# BASHBOT INTERNAL functions
 								#
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+								# do we have BSD sed
-												some test optimisations

											
										
										
											2021-01-01 23:11:23 +00:00
+								sed '1ia' </dev/null 2>/dev/null || printf "${ORANGE}Warning: You may run on a BSD style system without gnu utils ...${NN}"
-												revert and redo fixed last commit

											
										
										
											2020-06-10 06:20:48 +00:00
+								#jsonDB is now mandatory
-												revert jsshDB optimisation

											
										
										
											2021-01-01 23:32:32 +00:00
+								if ! _is_function jssh_newDB; then
 									printf "${RED}ERROR: Mandatory module jsonDB is missing or not readable!${NN}"
 									exit 6
 								fi
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
-												TMPDIR is used from BASH -> DATADIR

											
										
										
											2019-05-28 18:44:40 +00:00
+								# $1 URL, $2 filename in DATADIR
-												function download(), downloads URL to file in data-bot-bash

											
										
										
											2019-05-20 16:42:21 +00:00
+								# outputs final filename
 								download() {
 									local empty="no.file" file="${2:-${empty}}"
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+									if [[ "${file}" = *"/"* ]] || [[ "${file}" = "."* ]]; then file="${empty}"; fi
 									while [ -f "${DATADIR:-.}/${file}" ] ; do file="${RANDOM}-${file}"; done
-												TMPDIR is used from BASH -> DATADIR

											
										
										
											2019-05-28 18:44:40 +00:00
+									getJson "$1" >"${DATADIR:-.}/${file}" || return
 									printf '%s\n' "${DATADIR:-.}/${file}"
-												function download(), downloads URL to file in data-bot-bash

											
										
										
											2019-05-20 16:42:21 +00:00
+								}
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+								# $1 postfix, e.g. chatid
 								# $2 prefix, back- or startbot-
 								procname(){
-.80-pre, adjust doc, convert echo with parameters to fprint

											
										
										
											2019-05-20 08:50:51 +00:00
+									printf '%s\n' "$2${ME}_$1"
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+								}
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+								# $1 string to search for programme incl. parameters
 								# returns a list of PIDs of all current bot processes matching $1
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+								proclist() {
 									# shellcheck disable=SC2009
-												improved kill handling, fix job_control

											
										
										
											2019-05-21 08:53:52 +00:00
+									ps -fu "${UID}" | grep -F "$1" | grep -v ' grep'| grep -F "${ME}" | sed 's/\s\+/\t/g' | cut -f 2
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+								}
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+								# $1 string to search for programme to kill
-												improved kill handling, fix job_control

											
										
										
											2019-05-21 08:53:52 +00:00
+								killallproc() {
 									local procid; procid="$(proclist "$1")"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -n "${procid}" ] ; then
-												improved kill handling, fix job_control

											
										
										
											2019-05-21 08:53:52 +00:00
+										# shellcheck disable=SC2046
 										kill $(proclist "$1")
 										sleep 1
 										procid="$(proclist "$1")"
 										# shellcheck disable=SC2046
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+										[ -n "${procid}" ] && kill $(proclist -9 "$1")
-												improved kill handling, fix job_control

											
										
										
											2019-05-21 08:53:52 +00:00
+									fi
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									debug_checks "end killallproc" "$1"
-												improved kill handling, fix job_control

											
										
										
											2019-05-21 08:53:52 +00:00
+								}
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+								# $ chat $2 msg_id $3 nolog
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								declare -xr DELETE_URL=${URL}'/deleteMessage'
-												Add delete message support

since API v3 its possible to delete bot messages or any message if your bot is admin.
											
										
										
											2019-03-11 14:41:21 +00:00
+								delete_message() {
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									[ -z "$3" ] && log_update "Delete Message CHAT=$1 MSG_ID=$2"
 									sendJson "$1" '"message_id": '"$2"'' "${DELETE_URL}"
-												Add delete message support

since API v3 its possible to delete bot messages or any message if your bot is admin.
											
										
										
											2019-03-11 14:41:21 +00:00
+								}
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
+								get_file() {
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									[ -z "$1" ] && return
-												fix typos in changes

											
										
										
											2021-01-14 18:49:01 +00:00
+									sendJson ""  '"file_id": "'"$1"'"' "${URL}/getFile"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									printf "%s\n" "${URL}/${UPD["result,file_path"]}"
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
+								}
-												check if iconv exist

											
										
										
											2020-11-28 16:36:34 +00:00
+								# iconv used to filter out broken utf characters, if not installed fake it
 								if ! _exists iconv; then
-												optimize logging

											
										
										
											2020-12-15 19:53:42 +00:00
+									log_update "Warning: iconv not installed, pls imstall iconv!"
-												check if iconv exist

											
										
										
											2020-11-28 16:36:34 +00:00
+									function iconv() { cat; }
 								fi
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								TIMEOUT="${BASHBOT_TIMEOUT:-20}"
 								[[ "${TIMEOUT}" =~ ^[${o9o9o9}]+$ ]] || TIMEOUT="20"
-												autodetect sourcing, add CURL and WGET options, e.g. for using tor

											
										
										
											2019-05-23 17:40:15 +00:00
-												sendJson: factor out curl/wget, better log. fix git-add.sh

											
										
										
											2020-12-15 09:40:20 +00:00
+								# usage: sendJson "chat" "JSON" "URL"
 								sendJson(){
-												debug log sentMessage also

											
										
										
											2020-12-15 09:07:43 +00:00
+									local json chat=""
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									if [ -n "$1" ]; then
 										 chat='"chat_id":'"$1"','
-												dev: adjust make-standalone

											
										
										
											2021-01-20 18:50:19 +00:00
+										 [[ "$1" == *[!${o9o9o9}-]* ]] && chat='"chat_id":"'"$1"' NAN",'	# chat id not a number!
-												sendJson check chat is a number

											
										
										
											2020-12-15 09:12:18 +00:00
+									fi
-												add error respone for chat id not a nuber

											
										
										
											2020-12-18 13:23:20 +00:00
+									# compose final json
-												debug log sentMessage also

											
										
										
											2020-12-15 09:07:43 +00:00
+									json='{'"${chat} $(iconv -f utf-8 -t utf-8 -c <<<"$2")"'}'
 									if [ -n "${BASHBOTDEBUG}" ] ; then
-												fix DETECTED_CURL

											
										
										
											2020-12-19 07:03:55 +00:00
+										log_update "sendJson (${DETECTED_CURL}) CHAT=${chat#*:} JSON=${2:0:100} URL=${3##*/}"
-												optimize logging

											
										
										
											2020-12-15 19:53:42 +00:00
+										log_message "DEBUG sendJson ==========\n$("${JSONSHFILE}" -b -n <<<"${json}" 2>&1)"
-												debug log sentMessage also

											
										
										
											2020-12-15 09:07:43 +00:00
+									fi
-												fix sendJsonResult and chat is not a number

											
										
										
											2020-12-18 13:47:53 +00:00
+									# chat id not a number
 									if [[ "${chat}" == *"NAN\"," ]]; then
-												add error respone for chat id not a nuber

											
										
										
											2020-12-18 13:23:20 +00:00
+										sendJsonResult "$(printf '["ok"]\tfalse\n["error_code"]\t400\n["description"]\t"Bad Request: chat id not a number"\n')"\
 											"sendJson (NAN)" "$@"
-												fix sendJsonResult and chat is not a number

											
										
										
											2020-12-18 13:47:53 +00:00
+										return
-												add error respone for chat id not a nuber

											
										
										
											2020-12-18 13:23:20 +00:00
+									fi
-												sendJson: factor out curl/wget, better log. fix git-add.sh

											
										
										
											2020-12-15 09:40:20 +00:00
+									# OK here we go ...
 									# route to curl/wget specific function
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									res="$(sendJson_do "${json}" "$3")"
-												sendJson: factor out curl/wget, better log. fix git-add.sh

											
										
										
											2020-12-15 09:40:20 +00:00
+									# check telegram response
-												add error respone for chat id not a nuber

											
										
										
											2020-12-18 13:23:20 +00:00
+									sendJsonResult "${res}" "sendJson (${DETECTED_CURL})" "$@"
-												fix EVENT_SEND for upload

											
										
										
											2020-06-26 07:07:00 +00:00
+									[ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "send" "${@}" &
-												sendJson: factor out curl/wget, better log. fix git-add.sh

											
										
										
											2020-12-15 09:40:20 +00:00
+								}
 								#
 								# curl / wget specific functions
 								#
 								if detect_curl ; then
 								  # here we have curl ----
 								  [ -z "${BASHBOT_CURL}" ] && BASHBOT_CURL="curl"
-												remove URLs used once

											
										
										
											2021-01-14 16:47:06 +00:00
+								  # $1 URL, $2 hack: log getJson if not ""
-												sendJson: factor out curl/wget, better log. fix git-add.sh

											
										
										
											2020-12-15 09:40:20 +00:00
+								  getJson(){
 									# shellcheck disable=SC2086
 									"${BASHBOT_CURL}" -sL -k ${BASHBOT_CURL_ARGS} -m "${TIMEOUT}" "$1"
 								  }
 								  # curl variant for sendJson
 								  # usage: "JSON" "URL"
 								  sendJson_do(){
 									# shellcheck disable=SC2086
 									"${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} -m "${TIMEOUT}"\
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+										-d "$1" -X POST "$2" -H "Content-Type: application/json" | "${JSONSHFILE}" -b -n 2>/dev/null
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
+								  }
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+								  #$1 Chat, $2 what, $3 file, $4 URL, $5 caption
-												fix send_file, add test for send_file

											
										
										
											2019-05-20 15:26:21 +00:00
+								  sendUpload() {
 									[ "$#" -lt 4  ] && return
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -n "$5" ]; then
-												modules: send_file support for URL

											
										
										
											2021-01-05 21:01:32 +00:00
+										[ -n "${BASHBOTDEBUG}" ] &&\
 											log_update "sendUpload CHAT=$1 WHAT=$2  FILE=$3 CAPT=$5"
 										# shellcheck disable=SC2086
-												make curl location configurable

											
										
										
											2020-06-07 17:06:02 +00:00
+										res="$("${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} "$4" -F "chat_id=$1"\
-												remove JSON.sh -s option to fix message newline conversion on ubuntu

											
										
										
											2020-10-16 08:53:08 +00:00
+											-F "$2=@$3;${3##*/}" -F "caption=$5" | "${JSONSHFILE}" -b -n 2>/dev/null )"
-												fix send_file, add test for send_file

											
										
										
											2019-05-20 15:26:21 +00:00
+									else
-												modules: send_file support for URL

											
										
										
											2021-01-05 21:01:32 +00:00
+										# shellcheck disable=SC2086
-												make curl location configurable

											
										
										
											2020-06-07 17:06:02 +00:00
+										res="$("${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} "$4" -F "chat_id=$1"\
-												remove JSON.sh -s option to fix message newline conversion on ubuntu

											
										
										
											2020-10-16 08:53:08 +00:00
+											-F "$2=@$3;${3##*/}" | "${JSONSHFILE}" -b -n 2>/dev/null )"
-												fix send_file, add test for send_file

											
										
										
											2019-05-20 15:26:21 +00:00
+									fi
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+									sendJsonResult "${res}" "sendUpload (curl)" "$@"
-												fix EVENT_SEND for upload

											
										
										
											2020-06-26 07:07:00 +00:00
+									[ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "upload" "$@" &
-												fix send_file, add test for send_file

											
										
										
											2019-05-20 15:26:21 +00:00
+								  }
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
+								else
-												detect if no curl AND no wget

											
										
										
											2020-11-29 16:20:57 +00:00
+								  # NO curl, try wget
 								  if _exists wget; then
 								    getJson(){
-												autodetect sourcing, add CURL and WGET options, e.g. for using tor

											
										
										
											2019-05-23 17:40:15 +00:00
+									# shellcheck disable=SC2086
-												disable certificate checks

											
										
										
											2019-06-19 09:56:31 +00:00
+									wget --no-check-certificate -t 2 -T "${TIMEOUT}" ${BASHBOT_WGET_ARGS} -qO - "$1"
-												detect if no curl AND no wget

											
										
										
											2020-11-29 16:20:57 +00:00
+								    }
-												sendJson: factor out curl/wget, better log. fix git-add.sh

											
										
										
											2020-12-15 09:40:20 +00:00
+								    # curl variant for sendJson
 								    # usage: "JSON" "URL"
 								    sendJson_do(){
-												autodetect sourcing, add CURL and WGET options, e.g. for using tor

											
										
										
											2019-05-23 17:40:15 +00:00
+									# shellcheck disable=SC2086
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									wget --no-check-certificate -t 2 -T "${TIMEOUT}" ${BASHBOT_WGET_ARGS} -qO - --post-data="$1" \
 										--header='Content-Type:application/json' "$2" | "${JSONSHFILE}" -b -n 2>/dev/null
-												detect if no curl AND no wget

											
										
										
											2020-11-29 16:20:57 +00:00
+								    }
 								    sendUpload() {
-												start using log_error

											
										
										
											2020-06-27 08:43:08 +00:00
+									log_error "Sorry, wget does not support file upload"
-												fix send_file, add test for send_file

											
										
										
											2019-05-20 15:26:21 +00:00
+									BOTSENT[OK]="false"
-												fix EVENT_SEND for upload

											
										
										
											2020-06-26 07:07:00 +00:00
+									[ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "upload" "$@" &
-												detect if no curl AND no wget

											
										
										
											2020-11-29 16:20:57 +00:00
+								    }
 								  else
 									# ups, no curl AND no wget
 									if [ -n "${BASHBOT_WGET}" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										printf "${RED}Error: You set BASHBOT_WGET but no wget found!${NN}"
-												detect if no curl AND no wget

											
										
										
											2020-11-29 16:20:57 +00:00
+									else
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										printf "${RED}Error: curl and wget not found, install curl!${NN}"
-												detect if no curl AND no wget

											
										
										
											2020-11-29 16:20:57 +00:00
+									fi
 									exit 8
 								  fi
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
+								fi
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
 								# retry sendJson
-												 bashbotBlockRecover: notify bot about block

											
										
										
											2020-06-09 06:47:13 +00:00
+								# $1 function $2 sleep $3 ... $n arguments
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
+								sendJsonRetry(){
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									local retry="$1"; shift
 									[[ "$1" =~ ^\ *[${o9o9o9}.]+\ *$ ]] && sleep "$1"; shift
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+									printf "%(%c)T: RETRY %s %s %s\n" -1 "${retry}" "$1" "${2:0:60}"
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
+									case "${retry}" in
 										'sendJson'*)
 											sendJson "$@"
 											;;
 										'sendUpload'*)
 											sendUpload "$@"
 											;;
-												implement RETRY for send_album

											
										
										
											2020-06-26 07:11:10 +00:00
+										'send_album'*)
 											send_album "$@"
 											;;
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
+										*)
-												start using log_error

											
										
										
											2020-06-27 08:43:08 +00:00
+											log_error "Error: unknown function ${retry}, cannot retry"
-												retry now working

											
										
										
											2020-06-10 13:56:34 +00:00
+											return
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
+											;;
 									esac
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									[ "${BOTSENT[OK]}" = "true" ] && log_error "Retry OK:${retry} $1 ${2:0:60}"
-												retry now working

											
										
										
											2020-06-10 13:56:34 +00:00
+								} >>"${ERRORLOG}"
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
 								# process sendJson result
-												 bashbotBlockRecover: notify bot about block

											
										
										
											2020-06-09 06:47:13 +00:00
+								# stdout is written to ERROR.log
 								# $1 result $2 function $3 .. $n original arguments, $3 is Chat_id
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+								sendJsonResult(){
-												avoid unintended file overwrite

											
										
										
											2020-06-20 18:12:36 +00:00
+									local offset=0
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+									BOTSENT=( )
-												bashbot: use Json2Array UPD for response also

											
										
										
											2021-01-15 18:26:04 +00:00
+									Json2Array 'UPD' <<<"$1"
-												optimize logging

											
										
										
											2020-12-15 19:53:42 +00:00
+									[ -n "${BASHBOTDEBUG}" ] && log_message "New Result ==========\n$1"
-												bashbot: use Json2Array UPD for response also

											
										
										
											2021-01-15 18:26:04 +00:00
+									BOTSENT[OK]="${UPD["ok"]}"
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+									if [ "${BOTSENT[OK]}" = "true" ]; then
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+										BOTSENT[ID]="${UPD["result,message_id"]}"
 										BOTSENT[CHAT]="${UPD["result,chat,id"]}"
-												bashbot: use Json2Array UPD for response also

											
										
										
											2021-01-15 18:26:04 +00:00
+										[ -n "${UPD["result"]}" ] && BOTSENT[RESULT]="${UPD["result"]}"
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+										return
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+										# hot path everything OK!
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+									else
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+									    # oops something went wrong!
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+									    if [ -n "$1" ]; then
-												bashbot: use Json2Array UPD for response also

											
										
										
											2021-01-15 18:26:04 +00:00
+											BOTSENT[ERROR]="${UPD["error_code"]}"
 											BOTSENT[DESCRIPTION]="${UPD["description"]}"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+											[ -n "${UPD["parameters,retry_after"]}" ] && BOTSENT[RETRY]="${UPD["parameters,retry_after"]}"
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+									    else
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											BOTSENT[OK]="false"
 											BOTSENT[ERROR]="999"
 											BOTSENT[DESCRIPTION]="Send to telegram not possible, timeout/broken/no connection"
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+									    fi
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+									    # log error
-												avoid unintended file overwrite

											
										
										
											2020-06-20 18:12:36 +00:00
+									    [[ "${BOTSENT[ERROR]}" = "400" && "${BOTSENT[DESCRIPTION]}" == *"starting at byte offset"* ]] &&\
 											 offset="${BOTSENT[DESCRIPTION]%* }"
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+									    printf "%(%c)T: RESULT=%s FUNC=%s CHAT[ID]=%s ERROR=%s DESC=%s ACTION=%s\n" -1\
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+											"${BOTSENT[OK]}"  "$2" "$3" "${BOTSENT[ERROR]}" "${BOTSENT[DESCRIPTION]}" "${4:${offset}:100}"
-												do not retry with wget

											
										
										
											2020-06-09 10:27:28 +00:00
+									    # warm path, do not retry on error, also if we use wegt
-												enable retry by default

											
										
										
											2020-06-11 06:33:59 +00:00
+									    [ -n "${BASHBOT_RETRY}${BASHBOT_WGET}" ] && return
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
-												 bashbotBlockRecover: notify bot about block

											
										
										
											2020-06-09 06:47:13 +00:00
+									    # OK, we can retry sendJson, let's see what's failed
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									    # throttled, telegram say we send too many messages
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+									    if [ -n "${BOTSENT[RETRY]}" ]; then
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											BASHBOT_RETRY="$(( ++BOTSENT[RETRY] ))"
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+											printf "Retry %s in %s seconds ...\n" "$2" "${BASHBOT_RETRY}"
 											sendJsonRetry "$2" "${BASHBOT_RETRY}" "${@:3}"
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											unset BASHBOT_RETRY
 											return
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+									    fi
-												finalize retry

											
										
										
											2020-06-08 19:47:36 +00:00
+									    # timeout, failed connection or blocked
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+									    if [ "${BOTSENT[ERROR]}" == "999" ];then
 										# check if default curl and args are OK
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											if ! curl -sL -k -m 2 "${URL}" >/dev/null 2>&1 ; then
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+												printf "%(%c)T: BASHBOT IP Address seems blocked!\n" -1
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+												# user provided function to recover or notify block
 												if _exec_if_function bashbotBlockRecover; then
 													BASHBOT_RETRY="2"
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+													printf "bashbotBlockRecover returned true, retry %s ...\n" "$2"
 													sendJsonRetry "$2" "${BASHBOT_RETRY}" "${@:3}"
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+													unset BASHBOT_RETRY
 												fi
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+										    return
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											fi
-												explanation for BOTSEND_RETRY explanation and why printf

											
										
										
											2020-06-09 09:57:25 +00:00
+									        # are not blocked, default curl and args are working
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											if [ -n "${BASHBOT_CURL_ARGS}" ] || [ "${BASHBOT_CURL}" != "curl" ]; then
 												printf "Problem with \"%s %s\"? retry %s with default config ...\n"\
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+													"${BASHBOT_CURL}" "${BASHBOT_CURL_ARGS}" "$2"
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+												BASHBOT_RETRY="2"; BASHBOT_CURL="curl"; BASHBOT_CURL_ARGS=""
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+												sendJsonRetry "$2" "${BASHBOT_RETRY}" "${@:3}"
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+												unset BASHBOT_RETRY
 											fi
-												error handling: retry or not to retry?

											
										
										
											2020-06-08 18:51:15 +00:00
+									    fi
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
+									fi
-												 bashbotBlockRecover: notify bot about block

											
										
										
											2020-06-09 06:47:13 +00:00
+								} >>"${ERRORLOG}"
-												more sendJson error handling, rearrange source modules

											
										
										
											2020-06-08 10:58:36 +00:00
-												refactor JSON generation of common args

											
										
										
											2019-05-09 14:48:38 +00:00
+								# convert common telegram entities to JSON
 								# title caption description markup inlinekeyboard
 								title2Json(){
 									local title caption desc markup keyboard
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									[ -n "$1" ] && title=',"title":"'$(JsonEscape "$1")'"'
 									[ -n "$2" ] && caption=',"caption":"'$(JsonEscape "$2")'"'
 									[ -n "$3" ] && desc=',"description":"'$(JsonEscape "$3")'"'
-												remove JsonEscape for markup type, not needed

											
										
										
											2020-06-15 12:22:28 +00:00
+									[ -n "$4" ] && markup=',"parse_mode":"'"$4"'"'
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									[ -n "$5" ] && keyboard=',"reply_markup":"'$(JsonEscape "$5")'"'
-												prepare for release, start cleanup and optimizing

											
										
										
											2020-06-09 07:15:36 +00:00
+									printf '%s\n' "${title}${caption}${desc}${markup}${keyboard}"
-												refactor JSON generation of common args

											
										
										
											2019-05-09 14:48:38 +00:00
+								}
-												optimize getBotName

											
										
										
											2020-12-03 19:43:20 +00:00
+								# get bot name and id from telegram
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
+								getBotName() {
-												get/save botid, new function bot_is_admin

											
										
										
											2020-12-03 13:07:39 +00:00
+									declare -A BOTARRAY
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+									Json2Array 'BOTARRAY' <<<"$(getJson "${ME_URL}" | "${JSONSHFILE}" -b -n 2>/dev/null)"
-												optimize getBotName

											
										
										
											2020-12-03 19:43:20 +00:00
+									[ -z "${BOTARRAY["result","username"]}" ] && return 1
-												get/save botid, new function bot_is_admin

											
										
										
											2020-12-03 13:07:39 +00:00
+									# save botname and id
 									setConfigKey "botname" "${BOTARRAY["result","username"]}"
 									setConfigKey "botid" "${BOTARRAY["result","id"]}"
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${BOTARRAY["result","username"]}\n"
-												Adding missing telegram methods...

											
										
										
											2016-01-06 16:11:56 +00:00
+								}
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+								# pure bash implementation, done by KayM (@gnadelwartz)
-												SendJson bash only, no more python!

											
										
										
											2019-05-14 15:56:23 +00:00
+								# see https://stackoverflow.com/a/55666449/9381171
 								JsonDecode() {
-												bashbot.sh: jsonDecode: use printf

											
										
										
											2021-01-15 12:09:32 +00:00
+									local remain U out="$1"
-												SendJson bash only, no more python!

											
										
										
											2019-05-14 15:56:23 +00:00
+									local regexp='(.*)\\u[dD]([0-9a-fA-F]{3})\\u[dD]([0-9a-fA-F]{3})(.*)'
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+									while [[ "${out}" =~ ${regexp} ]] ; do
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									U=$(( ( (0xd${BASH_REMATCH[2]} & 0x3ff) <<10 ) | ( 0xd${BASH_REMATCH[3]} & 0x3ff ) + 0x10000 ))
 											remain="$(printf '\\U%8.8x' "${U}")${BASH_REMATCH[4]}${remain}"
 											out="${BASH_REMATCH[1]}"
 									done
-												bashbot.sh: jsonDecode: use printf

											
										
										
											2021-01-15 12:09:32 +00:00
+									printf "%b\n" "${out}${remain}"
-												SendJson bash only, no more python!

											
										
										
											2019-05-14 15:56:23 +00:00
+								}
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
 								################
 								# processing of updates starts here
-												Now the messages id can be accessed in MESSAGE[ID], all updates fetched with getUpdates are processed simultaneously and newlines and certain unicode codepoints are parsed correctly in messages (closes #21)

											
										
										
											2016-10-24 22:13:52 +00:00
+								process_updates() {
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+									local max num debug="$1"
-												fix some update messages are ignored

											
										
										
											2020-12-15 23:09:32 +00:00
+									max="$(grep -F ',"update_id"]'  <<< "${UPDATE}" | tail -1 | cut -d , -f 2 )"
-												Array2Json, module jsshDB.sh

											
										
										
											2019-05-27 12:30:21 +00:00
+									Json2Array 'UPD' <<<"${UPDATE}"
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+									for ((num=0; num<=max; num++)); do
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+										process_client "${num}" "${debug}"
-												Now the messages id can be accessed in MESSAGE[ID], all updates fetched with getUpdates are processed simultaneously and newlines and certain unicode codepoints are parsed correctly in messages (closes #21)

											
										
										
											2016-10-24 22:13:52 +00:00
+									done
 								}
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
-												fix first errors found by testsuite

											
										
										
											2019-04-21 11:45:51 +00:00
+								process_client() {
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+									local num="$1" debug="$2"
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
+									pre_process_message "${num}"
-												log updates received on debug

											
										
										
											2020-06-11 09:32:52 +00:00
+									# log message on debug
-												fix some update messages are ignored

											
										
										
											2020-12-15 23:09:32 +00:00
+									[[ -n "${debug}" ]] && log_message "New Message ==========\n$(grep -F '["result",'"${num}" <<<"${UPDATE}")"
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									# check for users / groups to ignore
-												cache blocked users with updateArray

											
										
										
											2020-06-15 08:42:36 +00:00
+									jssh_updateArray_async "BASHBOTBLOCKED" "${BLOCKEDFILE}"
 									[ -n "${USER[ID]}" ] && [[ -n "${BASHBOTBLOCKED[${USER[ID]}]}" || -n "${BASHBOTBLOCKED[${CHAT[ID]}]}" ]] && return
-												improved logging, error handling on update

											
										
										
											2020-06-11 23:17:15 +00:00
 									# process per message type
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+									if [ -n "${iQUERY[ID]}" ]; then
 										process_inline_query "${num}" "${debug}"
 									        printf "%(%c)T: Inline Query update received FROM=%s iQUERY=%s\n" -1\
 											"${iQUERY[USERNAME]:0:20} (${iQUERY[USER_ID]})" "${iQUERY[0]}" >>"${UPDATELOG}"
 									elif [ -n "${iBUTTON[ID]}" ]; then
 										process_inline_button "${num}" "${debug}"
-												iBUTTON: infrastructe seems to work

											
										
										
											2021-01-24 12:04:20 +00:00
+									        printf "%(%c)T: Inline Button update received FROM=%s CHAT=%s CALLBACK=%s DATA:%s \n" -1\
 											"${iBUTTON[USERNAME]:0:20} (${iBUTTON[USER_ID]})" "${iBUTTON[CHAT_ID]}" "${iBUTTON[ID]}" "${iBUTTON[DATA]}" >>"${UPDATELOG}"
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+									else
-												detect edited message

											
										
										
											2020-06-16 21:05:52 +00:00
+										if grep -qs -e '\["result",'"${num}"',"edited_message"' <<<"${UPDATE}"; then
 											# edited message
 											UPDATE="${UPDATE//,${num},\"edited_message\",/,${num},\"message\",}"
 											Json2Array 'UPD' <<<"${UPDATE}"
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
+											MESSAGE[0]="/_edited_message "
-												detect edited message

											
										
										
											2020-06-16 21:05:52 +00:00
+										fi
-												move procname and proclist, replace echo with cat for output to file

											
										
										
											2019-05-19 08:52:44 +00:00
+										process_message "${num}" "${debug}"
-												internal: some cleanup

											
										
										
											2021-01-06 14:33:07 +00:00
+									        printf "%(%c)T: update received FROM=%s CHAT=%s CMD=%s\n" -1 "${USER[USERNAME]:0:20} (${USER[ID]})"\
-												first working version with jssh botconfig database

											
										
										
											2020-06-12 21:41:47 +00:00
+											"${CHAT[USERNAME]:0:20}${CHAT[TITLE]:0:30} (${CHAT[ID]})"\
 											"${MESSAGE:0:30}${CAPTION:0:30}${URLS[*]:0:30}" >>"${UPDATELOG}"
-												first version with inline query

											
										
										
											2019-05-02 10:33:10 +00:00
+									fi
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									#####
 									# process inline and message events
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+									# first classic command dispatcher
-												fix source commands.sh, fix sendJson, sendMEssage module

											
										
										
											2019-05-12 15:51:52 +00:00
+									# shellcheck source=./commands.sh
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									source "${COMMANDS}" "${debug}" &
 									# then all registered addons
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -z "${iQUERY[ID]}" ]; then
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										event_message "${debug}"
-												fix EVENT typo and order

											
										
										
											2019-05-26 15:40:51 +00:00
+									else
-												_is_function process_inline is always true

											
										
										
											2019-05-28 19:28:58 +00:00
+										event_inline "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									fi
 									# last count users
-												_async for every jssh function, use async in bashbot.sh

											
										
										
											2020-06-05 07:01:20 +00:00
+									jssh_countKeyDB_async "${CHAT[ID]}" "${COUNTFILE}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+								}
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+								declare -Ax BASHBOT_EVENT_INLINE BASHBOT_EVENT_MESSAGE BASHBOT_EVENT_CMD BASHBOT_EVENT_REPLYTO BASHBOT_EVENT_FORWARD BASHBOT_EVENT_SEND
-												Updated prompt references to basbot / BASBOT to bashbot / BASHBOT

											
										
										
											2020-09-06 16:54:50 +00:00
+								declare -Ax BASHBOT_EVENT_CONTACT BASHBOT_EVENT_LOCATION BASHBOT_EVENT_FILE BASHBOT_EVENT_TEXT BASHBOT_EVENT_TIMER BASHBOT_BLOCKED
-												add EVENT_TIMER

											
										
										
											2019-05-29 11:49:05 +00:00
-												run timer event every 59.5 s

											
										
										
											2019-05-29 15:33:31 +00:00
+								start_timer(){
 									# send alarm every ~60 s
 									while :; do
 										sleep 59.5
 								    		kill -ALRM $$
 									done;
 								}
-												BASHBOT_EVENT_SEND plus documentation

											
										
										
											2019-06-04 16:04:52 +00:00
+								EVENT_SEND="0"
 								event_send() {
 									# max recursion level 5 to avoid fork bombs
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+									(( EVENT_SEND++ )); [ "${EVENT_SEND}" -gt "5" ] && return
-												BASHBOT_EVENT_SEND plus documentation

											
										
										
											2019-06-04 16:04:52 +00:00
+									# shellcheck disable=SC2153
 									for key in "${!BASHBOT_EVENT_SEND[@]}"
 									do
 										_exec_if_function "${BASHBOT_EVENT_SEND[${key}]}" "$@"
 									done
 								}
-												add EVENT_TIMER

											
										
										
											2019-05-29 11:49:05 +00:00
+								EVENT_TIMER="0"
 								event_timer() {
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+									local key timer debug="$1"
-												some minor adjustments in bashbot.sh

											
										
										
											2019-06-01 10:41:12 +00:00
+									(( EVENT_TIMER++ ))
-												add EVENT_TIMER

											
										
										
											2019-05-29 11:49:05 +00:00
+									# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+									for key in "${!BASHBOT_EVENT_TIMER[@]}"
-												add EVENT_TIMER

											
										
										
											2019-05-29 11:49:05 +00:00
+									do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										timer="${key##*,}"
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+										[[ ! "${timer}" =~ ^-*[1-9][0-9]*$ ]] && continue
-												add EVENT_TIMER

											
										
										
											2019-05-29 11:49:05 +00:00
+										if [ "$(( EVENT_TIMER % timer ))" = "0" ]; then
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											_exec_if_function "${BASHBOT_EVENT_TIMER[${key}]}" "timer" "${key}" "${debug}"
-												add EVENT_TIMER

											
										
										
											2019-05-29 11:49:05 +00:00
+											[ "$(( EVENT_TIMER % timer ))" -lt "0" ] && \
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+												unset BASHBOT_EVENT_TIMER["${key}"]
-												add EVENT_TIMER

											
										
										
											2019-05-29 11:49:05 +00:00
+										fi
 									done
 								}
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+								event_inline() {
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+									local key debug="$1"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+									for key in "${!BASHBOT_EVENT_INLINE[@]}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										_exec_if_function "${BASHBOT_EVENT_INLINE[${key}]}" "inline" "${key}" "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									done
 								}
 								event_message() {
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+									local key debug="$1"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									# ${MESSAEG[*]} event_message
 									# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+									for key in "${!BASHBOT_EVENT_MESSAGE[@]}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									do
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+										 _exec_if_function "${BASHBOT_EVENT_MESSAGE[${key}]}" "message" "${key}" "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									done
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+									# ${TEXT[*]} event_text
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -n "${MESSAGE[0]}" ]; then
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+										# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										for key in "${!BASHBOT_EVENT_TEXT[@]}"
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+										do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											_exec_if_function "${BASHBOT_EVENT_TEXT[${key}]}" "text" "${key}" "${debug}"
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+										done
 										# ${CMD[*]} event_cmd
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+										if [ -n "${CMD[0]}" ]; then
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+											# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											for key in "${!BASHBOT_EVENT_CMD[@]}"
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+											do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+												_exec_if_function "${BASHBOT_EVENT_CMD[${key}]}" "command" "${key}" "${debug}"
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+											done
 										fi
 									fi
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									# ${REPLYTO[*]} event_replyto
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -n "${REPLYTO[UID]}" ]; then
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										for key in "${!BASHBOT_EVENT_REPLYTO[@]}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											_exec_if_function "${BASHBOT_EVENT_REPLYTO[${key}]}" "replyto" "${key}" "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										done
 									fi
 									# ${FORWARD[*]} event_forward
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -n "${FORWARD[UID]}" ]; then
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										for key in "${!BASHBOT_EVENT_FORWARD[@]}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											 _exec_if_function && "${BASHBOT_EVENT_FORWARD[${key}]}" "forward" "${key}" "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										done
 									fi
 									# ${CONTACT[*]} event_contact
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -n "${CONTACT[FIRST_NAME]}" ]; then
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										for key in "${!BASHBOT_EVENT_CONTACT[@]}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											_exec_if_function "${BASHBOT_EVENT_CONTACT[${key}]}" "contact" "${key}" "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										done
 									fi
 									# ${VENUE[*]} event_location
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+									# ${LOCATION[*]} event_location
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+									if [ -n "${LOCATION[LONGITUDE]}" ] || [ -n "${VENUE[TITLE]}" ]; then
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										for key in "${!BASHBOT_EVENT_LOCATION[@]}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											_exec_if_function "${BASHBOT_EVENT_LOCATION[${key}]}" "location" "${key}" "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										done
 									fi
 									# ${URLS[*]} event_file
-												fix get_file, fix EVENT_FILE, reset MESSAGE variables on new message

											
										
										
											2019-05-30 17:52:14 +00:00
+									# NOTE: compare again #URLS -1 blanks!
 									if [[ "${URLS[*]}" != "     " ]]; then
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										# shellcheck disable=SC2153
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+										for key in "${!BASHBOT_EVENT_FILE[@]}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										do
-												provide event key to function

											
										
										
											2019-06-03 18:34:43 +00:00
+											_exec_if_function "${BASHBOT_EVENT_FILE[${key}]}" "file" "${key}" "${debug}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										done
 									fi
-												fix first errors found by testsuite

											
										
										
											2019-04-21 11:45:51 +00:00
+								}
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
+								pre_process_message(){
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									local num="$1"
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
+									# unset everything to not have old values
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+									CMD=( ); iQUERY=( ); iBUTTON=(); MESSAGE=(); CHAT=(); USER=(); CONTACT=(); LOCATION=(); unset CAPTION
-												detect supergroup migration

											
										
										
											2020-12-13 11:00:18 +00:00
+									REPLYTO=( ); FORWARD=( ); URLS=(); VENUE=( ); SERVICE=( ); NEWMEMBER=( ); LEFTMEMBER=( ); PINNED=( ); MIGRATE=( )
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									iQUERY[ID]="${UPD["result,${num},inline_query,id"]}"
-												iBUTTON: infrastructe seems to work

											
										
										
											2021-01-24 12:04:20 +00:00
+									iBUTTON[ID]="${UPD["result,${num},callback_query,id"]}"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									CHAT[ID]="${UPD["result,${num},message,chat,id"]}"
 									USER[ID]="${UPD["result,${num},message,from,id"]}"
 									[ -z "${CHAT[ID]}" ] && CHAT[ID]="${UPD["result,${num},edited_message,chat,id"]}"
 									[ -z "${USER[ID]}" ] && USER[ID]="${UPD["result,${num},edited_message,from,id"]}"
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
+									# always true
 									return 0
 								}
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+								process_inline_query() {
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									local num="$1"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									iQUERY[0]="$(JsonDecode "${UPD["result,${num},inline_query,query"]}")"
 									iQUERY[USER_ID]="${UPD["result,${num},inline_query,from,id"]}"
 									iQUERY[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},inline_query,from,first_name"]}")"
 									iQUERY[LAST_NAME]="$(JsonDecode "${UPD["result,${num},inline_query,from,last_name"]}")"
 									iQUERY[USERNAME]="$(JsonDecode "${UPD["result,${num},inline_query,from,username"]}")"
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
+									# always true
 									return 0
-												move process_inline to bashbot.sh, documentation make-standalone.sh

											
										
										
											2019-05-11 16:36:40 +00:00
+								}
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+								process_inline_button() {
-												modules: button url not starting with hhttp is sent as data

											
										
										
											2021-01-24 11:30:56 +00:00
+								# debugging for impelemetation
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+									local num="$1"
-												iBUTTON: infrastructe seems to work

											
										
										
											2021-01-24 12:04:20 +00:00
+									iBUTTON[DATA]="${UPD["result,${num},callback_query,data"]}"
 									#iBUTTON[CHAT_INSTANCE]="${UPD["result,${num},callback_query,chat_instance"]}"
 									#iBUTTON[INLINE_ID]="${UPD["result,${num},callback_query,inline_message_id"]}"
 									iBUTTON[CHAT_ID]="${UPD["result,${num},callback_query,message,chat,id"]}"
 									iBUTTON[MESSAGE_ID]="${UPD["result,${num},callback_query,message,message_id"]}"
 									iBUTTON[MEESSAGE]="$(JsonDecode "${UPD["result,${num},callback_query,message,text"]}")"
-												modules: button url not starting with hhttp is sent as data

											
										
										
											2021-01-24 11:30:56 +00:00
+								# XXX should we give back pressed button, all buttons or nothing?
-												iBUTTON: infrastructe seems to work

											
										
										
											2021-01-24 12:04:20 +00:00
+									iBUTTON[USER_ID]="${UPD["result,${num},callback_query,from,id"]}"
 									iBUTTON[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},callback_query,from,first_name"]}")"
 									iBUTTON[LAST_NAME]="$(JsonDecode "${UPD["result,${num},callback_query,from,last_name"]}")"
 									iBUTTON[USERNAME]="$(JsonDecode "${UPD["result,${num},callback_query,from,username"]}")"
-												iBUTTONS: initial code for processing CallbackQuery buttons

											
										
										
											2021-01-24 09:28:04 +00:00
+									# always true
 									return 0
 								}
-												fix first errors found by testsuite

											
										
										
											2019-04-21 11:45:51 +00:00
+								process_message() {
 									local num="$1"
-												Fixed bugs (now you can run multiple background session in multiple bots), added option to count users, added option to parse markdown and html using send_message, updated documentation and decided to put the sending loop for interactive chats in the background using tmux so that if I have to update the bot interactive sessions will continue to send out messages. Also changed the file name and the location (/tmp/ of the fifos for interactive chats) and added option to broadcast messages to all users.

											
										
										
											2016-04-16 18:50:05 +00:00
+									# Message
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									MESSAGE[0]+="$(JsonDecode "${UPD["result,${num},message,text"]}" | sed 's|\\/|/|g')"
 									MESSAGE[ID]="${UPD["result,${num},message,message_id"]}"
-												Now the messages id can be accessed in MESSAGE[ID], all updates fetched with getUpdates are processed simultaneously and newlines and certain unicode codepoints are parsed correctly in messages (closes #21)

											
										
										
											2016-10-24 22:13:52 +00:00
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									# Chat ID is now parsed when update is received
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									CHAT[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,chat,last_name"]}")"
 									CHAT[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,chat,first_name"]}")"
 									CHAT[USERNAME]="$(JsonDecode "${UPD["result,${num},message,chat,username"]}")"
-												fix newmwber first_name last_name

											
										
										
											2020-06-13 09:05:28 +00:00
+									# set real name as username if empty
-												startup message, optimize file_id

											
										
										
											2020-06-14 07:10:43 +00:00
+									[ -z "${CHAT[USERNAME]}" ] && CHAT[USERNAME]="${CHAT[FIRST_NAME]} ${CHAT[LAST_NAME]}"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									CHAT[TITLE]="$(JsonDecode "${UPD["result,${num},message,chat,title"]}")"
 									CHAT[TYPE]="$(JsonDecode "${UPD["result,${num},message,chat,type"]}")"
 									CHAT[ALL_ADMIN]="${UPD["result,${num},message,chat,all_members_are_administrators"]}"
-												Added a license for the unfortunate souls whose governments don't allow public domain.

Removed JSON.sh and added the project as a submodule. Modified code referencing it accordingly.

Added "attach" argument to attach to the tmux session and a default message if no argument is given.

Other minor changes.

											
										
										
											2016-04-19 09:49:35 +00:00
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									# user ID is now parsed when update is received
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									USER[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,from,first_name"]}")"
 									USER[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,from,last_name"]}")"
 									USER[USERNAME]="$(JsonDecode "${UPD["result,${num},message,from,username"]}")"
-												optimize update processing, fix LEFTMEMBER

											
										
										
											2020-06-15 17:44:46 +00:00
+									# set real name as username if empty
 									[ -z "${USER[USERNAME]}" ] && USER[USERNAME]="${USER[FIRST_NAME]} ${USER[LAST_NAME]}"
-												Nearly done

											
										
										
											2016-01-17 16:46:24 +00:00
-												provide information about replied and forwarded messages

											
										
										
											2019-03-22 19:30:22 +00:00
+									# in reply to message from
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									if [ -n "${UPD["result,${num},message,reply_to_message,from,id"]}" ]; then
 									   REPLYTO[UID]="${UPD["result,${num},message,reply_to_message,from,id"]}"
 									   REPLYTO[0]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,text"]}")"
 									   REPLYTO[ID]="${UPD["result,${num},message,reply_to_message,message_id"]}"
 									   REPLYTO[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,from,first_name"]}")"
 									   REPLYTO[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,from,last_name"]}")"
 									   REPLYTO[USERNAME]="$(JsonDecode "${UPD["result,${num},message,reply_to_message,from,username"]}")"
-												optimize replied and forwarded message parsing

											
										
										
											2019-03-22 19:41:34 +00:00
+									fi
-												provide information about replied and forwarded messages

											
										
										
											2019-03-22 19:30:22 +00:00
 									# forwarded message from
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									if [ -n "${UPD["result,${num},message,forward_from,id"]}" ]; then
 									   FORWARD[UID]="${UPD["result,${num},message,forward_from,id"]}"
-												dev: adjust make-standalone

											
										
										
											2021-01-20 18:50:19 +00:00
+									   FORWARD[ID]="${MESSAGE[ID]}"	# same as message ID
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									   FORWARD[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,forward_from,first_name"]}")"
 									   FORWARD[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,forward_from,last_name"]}")"
 									   FORWARD[USERNAME]="$(JsonDecode "${UPD["result,${num},message,forward_from,username"]}")"
-												optimize replied and forwarded message parsing

											
										
										
											2019-03-22 19:41:34 +00:00
+									fi
-												provide information about replied and forwarded messages

											
										
										
											2019-03-22 19:30:22 +00:00
-												less grep in process_message

											
										
										
											2020-12-13 08:57:57 +00:00
+									# get file URL from telegram, check for any of them!
-												minor optimisation  to URLS processing

											
										
										
											2020-06-29 10:25:55 +00:00
+									if grep -qs -e '\["result",'"${num}"',"message","[avpsd].*,"file_id"\]' <<<"${UPDATE}"; then
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									    URLS[AUDIO]="$(get_file "${UPD["result,${num},message,audio,file_id"]}")"
 									    URLS[DOCUMENT]="$(get_file "${UPD["result,${num},message,document,file_id"]}")"
 									    URLS[PHOTO]="$(get_file "${UPD["result,${num},message,photo,0,file_id"]}")"
 									    URLS[STICKER]="$(get_file "${UPD["result,${num},message,sticker,file_id"]}")"
 									    URLS[VIDEO]="$(get_file "${UPD["result,${num},message,video,file_id"]}")"
 									    URLS[VOICE]="$(get_file "${UPD["result,${num},message,voice,file_id"]}")"
-												startup message, optimize file_id

											
										
										
											2020-06-14 07:10:43 +00:00
+									fi
-												optimze venue and contact detection

											
										
										
											2020-12-13 09:10:15 +00:00
+									# Contact, must have phone_number
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									if [ -n "${UPD["result,${num},message,contact,phone_number"]}" ]; then
 										CONTACT[USER_ID]="$(JsonDecode  "${UPD["result,${num},message,contact,user_id"]}")"
 										CONTACT[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,contact,first_name"]}")"
 										CONTACT[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,contact,last_name"]}")"
 										CONTACT[NUMBER]="${UPD["result,${num},message,contact,phone_number"]}"
 										CONTACT[VCARD]="${UPD["result,${num},message,contact,vcard"]}"
-												some small optimization

											
										
										
											2019-05-22 08:01:39 +00:00
+									fi
-												parse VCARD and VENUE from message

											
										
										
											2019-04-23 17:00:17 +00:00
-												optimze venue and contact detection

											
										
										
											2020-12-13 09:10:15 +00:00
+									# venue, must have a position
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									if [ -n "${UPD["result,${num},message,venue,location,longitude"]}" ]; then
 										VENUE[TITLE]="$(JsonDecode "${UPD["result,${num},message,venue,title"]}")"
 										VENUE[ADDRESS]="$(JsonDecode "${UPD["result,${num},message,venue,address"]}")"
 										VENUE[LONGITUDE]="${UPD["result,${num},message,venue,location,longitude"]}"
 										VENUE[LATITUDE]="${UPD["result,${num},message,venue,location,latitude"]}"
 										VENUE[FOURSQUARE]="${UPD["result,${num},message,venue,foursquare_id"]}"
-												some small optimization

											
										
										
											2019-05-22 08:01:39 +00:00
+									fi
-												Nearly done

											
										
										
											2016-01-17 16:46:24 +00:00
 									# Caption
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									CAPTION="$(JsonDecode "${UPD["result,${num},message,caption"]}")"
-												Nearly done

											
										
										
											2016-01-17 16:46:24 +00:00
 									# Location
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									LOCATION[LONGITUDE]="${UPD["result,${num},message,location,longitude"]}"
 									LOCATION[LATITUDE]="${UPD["result,${num},message,location,latitude"]}"
-												fix tests, start addon implementation

											
										
										
											2019-05-25 15:02:25 +00:00
-												process service messages in groups only

											
										
										
											2020-12-13 07:53:29 +00:00
+									# service messages, group or channel only!
 									if [[ "${CHAT[ID]}" == "-"* ]] ; then
-												fix no need for JsonDecode

											
										
										
											2020-12-13 09:24:26 +00:00
+									    # new chat member
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									    if [ -n "${UPD["result,${num},message,new_chat_member,id"]}" ]; then
 										SERVICE[NEWMEMBER]="${UPD["result,${num},message,new_chat_member,id"]}"
-												some small fixes, start dev3

											
										
										
											2020-05-14 11:04:57 +00:00
+										NEWMEMBER[ID]="${SERVICE[NEWMEMBER]}"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+										NEWMEMBER[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,new_chat_member,first_name"]}")"
 										NEWMEMBER[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,new_chat_member,last_name"]}")"
 										NEWMEMBER[USERNAME]="$(JsonDecode "${UPD["result,${num},message,new_chat_member,username"]}")"
 										NEWMEMBER[ISBOT]="${UPD["result,${num},message,new_chat_member,is_bot"]}"
-												service message start with /_ to avoid clashes

											
										
										
											2020-06-29 06:14:39 +00:00
+										[ -z "${MESSAGE[0]}" ] &&\
 										MESSAGE[0]="/_new_chat_member ${NEWMEMBER[ID]} ${NEWMEMBER[USERNAME]:=${NEWMEMBER[FIRST_NAME]} ${NEWMEMBER[LAST_NAME]}}"
-												process service messages in groups only

											
										
										
											2020-12-13 07:53:29 +00:00
+									    fi
-												fix no need for JsonDecode

											
										
										
											2020-12-13 09:24:26 +00:00
+									    # left chat member
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									    if [ -n "${UPD["result,${num},message,left_chat_member,id"]}" ]; then
 										SERVICE[LEFTMEMBER]="${UPD["result,${num},message,left_chat_member,id"]}"
-												optimize update processing, fix LEFTMEMBER

											
										
										
											2020-06-15 17:44:46 +00:00
+										LEFTMEMBER[ID]="${SERVICE[LEFTMEBER]}"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+										LEFTMEMBER[FIRST_NAME]="$(JsonDecode "${UPD["result,${num},message,left_chat_member,first_name"]}")"
 										LEFTMEMBER[LAST_NAME]="$(JsonDecode "${UPD["result,${num},message,left_chat_member,last_name"]}")"
 										LEFTMEBER[USERNAME]="$(JsonDecode "${UPD["result,${num},message,left_chat_member,username"]}")"
 										LEFTMEMBER[ISBOT]="${UPD["result,${num},message,left_chat_member,is_bot"]}"
-												service message start with /_ to avoid clashes

											
										
										
											2020-06-29 06:14:39 +00:00
+										[ -z "${MESSAGE[0]}" ] &&\
-												fix leftchatmember example and message

											
										
										
											2020-08-04 06:31:38 +00:00
+										MESSAGE[0]="/_left_chat_member ${LEFTMEMBER[ID]} ${LEFTMEMBER[USERNAME]:=${LEFTMEMBER[FIRST_NAME]} ${LEFTMEMBER[LAST_NAME]}}"
-												process service messages in groups only

											
										
										
											2020-12-13 07:53:29 +00:00
+									    fi
-												fix no need for JsonDecode

											
										
										
											2020-12-13 09:24:26 +00:00
+									    # chat title / photo, check for any of them!
-												process service messages in groups only

											
										
										
											2020-12-13 07:53:29 +00:00
+									    if grep -qs -e '\["result",'"${num}"',"message","new_chat_[tp]' <<<"${UPDATE}"; then
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+										SERVICE[NEWTITLE]="$(JsonDecode "${UPD["result,${num},message,new_chat_title"]}")"
-												service message start with /_ to avoid clashes

											
										
										
											2020-06-29 06:14:39 +00:00
+										[ -z "${MESSAGE[0]}" ] && [ -n "${SERVICE[NEWTITLE]}" ] &&\
 											MESSAGE[0]="/_new_chat_title ${USER[ID]} ${SERVICE[NEWTITLE]}"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+										SERVICE[NEWPHOTO]="$(get_file "${UPD["result,${num},message,new_chat_photo,0,file_id"]}")"
-												service message start with /_ to avoid clashes

											
										
										
											2020-06-29 06:14:39 +00:00
+										[ -z "${MESSAGE[0]}" ] && [ -n "${SERVICE[NEWPHOTO]}" ] &&\
 											 MESSAGE[0]="/_new_chat_photo ${USER[ID]} ${SERVICE[NEWPHOTO]}"
-												process service messages in groups only

											
										
										
											2020-12-13 07:53:29 +00:00
+									    fi
-												fix no need for JsonDecode

											
										
										
											2020-12-13 09:24:26 +00:00
+									    # pinned message
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									    if [ -n "${UPD["result,${num},message,pinned_message,message_id"]}" ]; then
 										SERVICE[PINNED]="${UPD["result,${num},message,pinned_message,message_id"]}"
-												finalise service pinned message, fix new/left member ARRAY

											
										
										
											2020-06-29 11:29:47 +00:00
+										PINNED[ID]="${SERVICE[PINNED]}"
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+										PINNED[MESSAGE]="$(JsonDecode "${UPD["result,${num},message,pinned_message,text"]}")"
-												detect supergroup migration

											
										
										
											2020-12-13 11:00:18 +00:00
+										[ -z "${MESSAGE[0]}" ] &&\
-												finalise service pinned message, fix new/left member ARRAY

											
										
										
											2020-06-29 11:29:47 +00:00
+											MESSAGE[0]="/_new_pinned_message ${USER[ID]} ${PINNED[ID]} ${PINNED[MESSAGE]}"
-												process service messages in groups only

											
										
										
											2020-12-13 07:53:29 +00:00
+									    fi
-												detect supergroup migration

											
										
										
											2020-12-13 11:00:18 +00:00
+									    # migrate to super group
-												bashbot.sh: fix UPD array access to use "real" strings

											
										
										
											2021-01-19 16:47:15 +00:00
+									    if [ -n "${UPD["result,${num},message,migrate_to_chat_id"]}" ]; then
 										MIGRATE[TO]="${UPD["result,${num},message,migrate_to_chat_id"]}"
 										MIGRATE[FROM]="${UPD["result,${num},message,migrate_from_chat_id"]}"
-												fix set CHAT[ID] to new id on chat migration

											
										
										
											2021-01-23 12:58:45 +00:00
+										# CHAT is already migrated, so set new chat id
 										[ "${CHAT[ID]}" = "${MIGRATE[FROM]}" ] && CHAT[ID]="${MIGRATE[FROM]}"
-												detect supergroup migration

											
										
										
											2020-12-13 11:00:18 +00:00
+										SERVICE[MIGRATE]="${MIGRATE[FROM]} ${MIGRATE[TO]}"
 										[ -z "${MESSAGE[0]}" ] &&\
-												add /_migrate_group to mycommands.sh example

											
										
										
											2020-12-13 11:44:14 +00:00
+											MESSAGE[0]="/_migrate_group ${SERVICE[MIGRATE]}"
-												detect supergroup migration

											
										
										
											2020-12-13 11:00:18 +00:00
+									    fi
-												process service messages in groups only

											
										
										
											2020-12-13 07:53:29 +00:00
+									    # set SERVICE to yes if a service message was received
 									    [[ "${SERVICE[*]}" =~  ^[[:blank:]]*$ ]] || SERVICE[0]="yes"
-												some small fixes, start dev3

											
										
										
											2020-05-14 11:04:57 +00:00
+									fi
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+									# split message in command and args
-												fix of fix test errors

											
										
										
											2020-06-27 16:51:17 +00:00
+									[[ "${MESSAGE[0]}" == "/"* ]] && read -r CMD <<<"${MESSAGE[0]}" &&  CMD[0]="${CMD[0]%%@*}"
 									# everything went well
 									return 0
-												add EVENT_TEXT and EVENT_CMD

											
										
										
											2019-05-27 10:27:09 +00:00
+								}
-												replace all curl calls, add wget as curl replacement

											
										
										
											2019-05-14 13:25:15 +00:00
 								#########################
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+								# main get updates loop, should never terminate
-												cache blocked users with updateArray

											
										
										
											2020-06-15 08:42:36 +00:00
+								declare -A BASHBOTBLOCKED
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+								start_bot() {
-												remove unneeded variable ADIM

											
										
										
											2020-12-31 17:11:37 +00:00
+									local DEBUGMSG OFFSET=0
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+									# adaptive sleep defaults
-												unneeded : in start_bot fixes #134

											
										
										
											2020-06-23 18:57:38 +00:00
+									local nextsleep="100"
-												do not start timer by default

											
										
										
											2020-06-09 14:51:50 +00:00
+									local stepsleep="${BASHBOT_SLEEP_STEP:-100}"
 									local maxsleep="${BASHBOT_SLEEP:-5000}"
-												startup message, optimize file_id

											
										
										
											2020-06-14 07:10:43 +00:00
+									# startup message
-												optimize logging

											
										
										
											2020-12-15 19:53:42 +00:00
+									DEBUGMSG="Start BASHBOT updates in Mode \"${1:-normal}\" =========="
 									log_update "${DEBUGMSG}"
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+									# redirect to Debug.log
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+									[[ "$1" == *"debug" ]] && exec &>>"${DEBUGLOG}"
 									log_debug "${DEBUGMSG}"; DEBUGMSG="$1"
-												getJson: remove unneeded extra logging

											
										
										
											2021-01-17 08:55:13 +00:00
+									[[ "${DEBUGMSG}" == "xdebug"* ]] && set -x
-												Cosmetic updates to some comments

											
										
										
											2020-09-26 19:25:17 +00:00
+									# cleaup old pipes and empty logfiles
-												TMPDIR is used from BASH -> DATADIR

											
										
										
											2019-05-28 18:44:40 +00:00
+									find "${DATADIR}" -type p -delete
 									find "${DATADIR}" -size 0 -name "*.log" -delete
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									# load addons on startup
-												explain REGEX usage vs. file globbing

											
										
										
											2019-12-07 12:25:50 +00:00
+									for addons in "${ADDONDIR:-.}"/*.sh ; do
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										# shellcheck source=./modules/aliases.sh
-												rework BASHBOTDEBUG is always global

											
										
										
											2020-06-30 05:26:16 +00:00
+										[ -r "${addons}" ] && source "${addons}" "startbot" "${DEBUGMSG}"
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+									done
-												some small fixes, start dev3

											
										
										
											2020-05-14 11:04:57 +00:00
+									# shellcheck source=./commands.sh
 									source "${COMMANDS}" "startbot"
-												run timer event every 59.5 s

											
										
										
											2019-05-29 15:33:31 +00:00
+									# start timer events
-												do not start timer by default

											
										
										
											2020-06-09 14:51:50 +00:00
+									if [ -n "${BASHBOT_START_TIMER}" ] ; then
-												run timer event every 59.5 s

											
										
										
											2019-05-29 15:33:31 +00:00
+										# shellcheck disable=SC2064
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+										trap "event_timer ${DEBUGMSG}" ALRM
-												run timer event every 59.5 s

											
										
										
											2019-05-29 15:33:31 +00:00
+										start_timer &
 										# shellcheck disable=SC2064
 										trap "kill -9 $!; exit" EXIT INT HUP TERM QUIT
 									fi
-												fix keyDB_async, count cleanup only on bot start

											
										
										
											2020-06-10 07:32:53 +00:00
+									# cleanup countfile on startup
-												improve count cleanup on startup

											
										
										
											2020-06-10 07:48:37 +00:00
+									jssh_deleteKeyDB "CLEAN_COUNTER_DATABASE_ON_STARTUP" "${COUNTFILE}"
-												remove count.jssh.flock after cleanup

											
										
										
											2020-06-11 10:37:36 +00:00
+								        [ -f "${COUNTFILE}.jssh.flock" ] && rm -f "${COUNTFILE}.jssh.flock"
-												save startup time while cleanup botconfig

											
										
										
											2020-08-06 06:34:59 +00:00
+									# store start time and cleanup botconfig on startup
-												internal: printf date is 100 times faster

											
										
										
											2021-01-06 07:48:25 +00:00
+									jssh_updateKeyDB "startup" "$(_date)" "${BOTCONFIG}"
-												rename BOTDATABASE to BOTCONFIG

											
										
										
											2020-06-19 10:49:18 +00:00
+								        [ -f "${BOTCONFIG}.jssh.flock" ] && rm -f "${BOTCONFIG}.jssh.flock"
-												save startup time while cleanup botconfig

											
										
										
											2020-08-06 06:34:59 +00:00
+									# read blocked users
-												cache blocked users with updateArray

											
										
										
											2020-06-15 08:42:36 +00:00
+									jssh_readDB_async "BASHBOTBLOCKED" "${BLOCKEDFILE}"
-												inform admin about successful start

											
										
										
											2020-06-15 06:39:52 +00:00
+									# inform botadmin about start
-												remove unneeded variable ADIM

											
										
										
											2020-12-31 17:11:37 +00:00
+									send_normal_message "$(getConfigKey "botadmin")" "Bot $(getConfigKey "botname") started ..." &
-												fix keyDB_async, count cleanup only on bot start

											
										
										
											2020-06-10 07:32:53 +00:00
+									##########
 									# bot is ready, start processing updates ...
-												some fixes for updates from older versions

											
										
										
											2019-05-14 11:16:58 +00:00
+									while true; do
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+										# adaptive sleep in ms rounded to next 0.1 s
-												retry now working

											
										
										
											2020-06-10 13:56:34 +00:00
+										sleep "$(_round_float "${nextsleep}e-3" "1")"
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+										# get next update
-												getJson: remove unneeded extra logging

											
										
										
											2021-01-17 08:55:13 +00:00
+										UPDATE="$(getJson "${URL}/getUpdates?offset=${OFFSET}" 2>/dev/null | "${JSONSHFILE}" -b -n 2>/dev/null | iconv -f utf-8 -t utf-8 -c)"
-												Cosmetic updates to some comments

											
										
										
											2020-09-26 19:25:17 +00:00
+										# did we get an response?
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+										if [ -n "${UPDATE}" ]; then
 											# we got something, do processing
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+											[ "${OFFSET}" = "-999" ] && [ "${nextsleep}" -gt "$((maxsleep*2))" ] &&\
-												start using log_error

											
										
										
											2020-06-27 08:43:08 +00:00
+												log_error "Recovered from timeout/broken/no connection, continue with telegram updates"
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+											# escape bash $ expansion bug
-												finalize error logs, update events doc

											
										
										
											2020-06-12 08:00:52 +00:00
+											((nextsleep+= stepsleep , nextsleep= nextsleep>maxsleep ?maxsleep:nextsleep))
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+											UPDATE="${UPDATE//$/\\$}"
 											# Offset
 											OFFSET="$(grep <<< "${UPDATE}" '\["result",[0-9]*,"update_id"\]' | tail -1 | cut -f 2)"
 											((OFFSET++))
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+											if [ "${OFFSET}" != "1" ]; then
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+												nextsleep="100"
-												rework BASHBOTDEBUG is always global

											
										
										
											2020-06-30 05:26:16 +00:00
+												process_updates "${DEBUGMSG}"
-												error processing for get update loop

											
										
										
											2020-06-09 12:46:45 +00:00
+											fi
 										else
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											# oops, something bad happened, wait maxsleep*10
-												improved logging, error handling on update

											
										
										
											2020-06-11 23:17:15 +00:00
+											(( nextsleep=nextsleep*2 , nextsleep= nextsleep>maxsleep*10 ?maxsleep*10:nextsleep ))
-												try recover from block in update loop

											
										
										
											2020-12-14 13:00:23 +00:00
+											# second time, report problem
 											if [ "${OFFSET}" = "-999" ]; then
 											    log_error "Repeated timeout/broken/no connection on telegram update, sleep $(_round_float "${nextsleep}e-3")s"
 											    # try to recover
 											    if _is_function bashbotBlockRecover && [ -z "$(getJson "${ME_URL}")" ]; then
 												log_error "Try to recover, calling bashbotBlockRecover ..."
-												optimize logging

											
										
										
											2020-12-15 19:53:42 +00:00
+												bashbotBlockRecover >>"${ERRORLOG}"
-												try recover from block in update loop

											
										
										
											2020-12-14 13:00:23 +00:00
+											    fi
 											fi
-												improved logging, error handling on update

											
										
										
											2020-06-11 23:17:15 +00:00
+											OFFSET="-999"
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+										fi
 									done
 								}
 								# initialize bot environment, user and permissions
 								bot_init() {
-												fix init with BASHBOT_HOME

											
										
										
											2020-06-08 14:04:45 +00:00
+									[ -n "${BASHBOT_HOME}" ] && cd "${BASHBOT_HOME}" || exit 1
-												init: bashbot.rc: adjust botname

											
										
										
											2021-01-10 18:21:18 +00:00
+									local runuser chown touser botname DEBUG="$1"
-												some fixes for updates from older versions

											
										
										
											2019-05-14 11:16:58 +00:00
+									# upgrade from old version
-												currently no update actions on init

											
										
										
											2020-12-27 14:12:35 +00:00
+									# currently no action
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "Check for Update actions ...\n"
 									printf "Done.\n"
-												currently no update actions on init

											
										
										
											2020-12-27 14:12:35 +00:00
+									# load addons on startup
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "Initialize modules and addons ...\n"
-												explain REGEX usage vs. file globbing

											
										
										
											2019-12-07 12:25:50 +00:00
+									for addons in "${ADDONDIR:-.}"/*.sh ; do
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										# shellcheck source=./modules/aliases.sh
 										[ -r "${addons}" ] && source "${addons}" "init" "${DEBUG}"
 									done
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "Done.\n"
-												init: rework adjust user

											
										
										
											2021-01-10 17:23:37 +00:00
+									# ask for bashbot user
 									runuser="${RUNUSER}"; [ "${UID}" = "0" ] && runuser="nobody"
 									printf "Enter User to run bashbot [${runuser}]: "
-												init: bashbot.rc: adjust botname

											
										
										
											2021-01-10 18:21:18 +00:00
+									read -r chown
 									[ -z "${chown}" ] && chown="${runuser}"; touser="${chown%:*}"
-												init: rework adjust user

											
										
										
											2021-01-10 17:23:37 +00:00
+									# check user ...
 									if ! id "${touser}" &>/dev/null; then
 										printf "${RED}User \"${touser}\" does not exist!${NN}"
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+										exit 3
-												init: rework adjust user

											
										
										
											2021-01-10 17:23:37 +00:00
+									elif [[ "${UID}" != "0" && "${touser}" != "${runuser}" ]]; then
 										# different user but not root ...
-												init: finalize adjust user

											
										
										
											2021-01-10 17:39:43 +00:00
+										printf "${ORANGE}You are not root, adjusting permissions may fail. Try \"sudo ./bashbot.sh init\"${NN}Press <CTRL+C> to stop or <Enter> to continue..." 1>&2
 										[ -n "${INTERACTIVE}" ] && read -r runuser
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+									fi
-												init: rework adjust user

											
										
										
											2021-01-10 17:23:37 +00:00
+									# adjust permissions
 									printf "Adjusting files and permissions for user \"${touser}\" ...\n"
 									chmod 711 .
 									chmod -R o-w ./*
 									chmod -R u+w "${COUNTFILE}"* "${BLOCKEDFILE}"* "${DATADIR}" logs "${LOGDIR}/"*.log 2>/dev/null
 									chmod -R o-r,o-w "${COUNTFILE}"* "${BLOCKEDFILE}"* "${DATADIR}" "${BOTACL}" 2>/dev/null
 									# jsshDB must writeable by owner
 									find . -name '*.jssh*' -exec chmod u+w \{\} +
-												init: bashbot.rc: adjust botname

											
										
										
											2021-01-10 18:21:18 +00:00
+									chown -Rf "${chown}" . ./*
-												init: rework adjust user

											
										
										
											2021-01-10 17:23:37 +00:00
+									printf "Done.\n"
 									# adjust values in bashbot.rc
-												init: bashbot.rc: adjust botname

											
										
										
											2021-01-10 18:21:18 +00:00
+									if [ -w "bashbot.rc" ]; then
 										printf "Adjust user and botname in bashbot.rc ...\n"
-												init: change bahsbot path in  rc-file also

											
										
										
											2021-01-16 11:59:11 +00:00
+										sed -i '/^[# ]*runas=/ s|runas=.*$|runas="'"${touser}"'"|' "bashbot.rc"
 										sed -i '/^[# ]*bashbot=/ s|bashbot=.*$|bashbot="cd '"${PWD}"'; '"${PWD}"'/'"${0##*/}"'"|' "bashbot.rc"
-												init: bashbot.rc: adjust botname

											
										
										
											2021-01-10 18:21:18 +00:00
+										botname="$(getConfigKey "botname")"
-												init: change bahsbot path in  rc-file also

											
										
										
											2021-01-16 11:59:11 +00:00
+										[ -n "${botname}" ] && sed -i '/^[# ]*name=/ s|name=.*$|name="'"${botname}"'"|' "bashbot.rc"
-												init: bashbot.rc: adjust botname

											
										
										
											2021-01-10 18:21:18 +00:00
+										printf "Done.\n"
 									fi
-												offer to check bottoken online on first init

											
										
										
											2020-12-03 13:52:35 +00:00
+									# ask to check bottoken online
 									if [ -z "$(getConfigKey "botid")" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										printf "Seems to be your first init. Should I verify your bot token online? (y/N) N\b"
-												offer to check bottoken online on first init

											
										
										
											2020-12-03 13:52:35 +00:00
+										read -r ANSWER
 										if [[ "${ANSWER}" =~ ^[Yy] ]]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											printf "${GREEN}Contacting telegram to verify your bot token ...${NN}"
-												offer to check bottoken online on first init

											
										
										
											2020-12-03 13:52:35 +00:00
+											$0 botname
 										fi
 									fi
-												currently no update actions on init

											
										
										
											2020-12-27 14:12:35 +00:00
+									# check if botconf seems valid
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${GREEN}This is your bot config:${NN}"
-												improve init

											
										
										
											2020-06-25 15:15:49 +00:00
+									sed 's/^/\t/' "${BOTCONFIG}.jssh" | grep -vF '["bot_config_key"]'
-												replace R090909 -> o9o9o9 , better readable

											
										
										
											2021-01-04 15:10:43 +00:00
+									if check_token "$(getConfigKey "bottoken")" && [[ "$(getConfigKey "botadmin")" =~ ^[${o9o9o9}]+$ ]]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										printf "Bot config seems to be valid. Should I make a backup copy? (Y/n) Y\b"
-												improve init

											
										
										
											2020-06-25 15:15:49 +00:00
+										read -r ANSWER
 										if [[ -z "${ANSWER}" || "${ANSWER}" =~ ^[^Nn] ]]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											printf "Copy bot config to ${BOTCONFIG}.jssh.ok ...\n"
-												fix missing copy botconfig

											
										
										
											2020-06-27 10:43:46 +00:00
+											cp "${BOTCONFIG}.jssh" "${BOTCONFIG}.jssh.ok"
-												improve init

											
										
										
											2020-06-25 15:15:49 +00:00
+										fi
 									else
-												currently no update actions on init

											
										
										
											2020-12-27 14:12:35 +00:00
+										printf "${ORANGE}Bot config may incomplete, pls check.${NN}"
-												improve init

											
										
										
											2020-06-25 15:15:49 +00:00
+									fi
-												revert and redo fixed last commit

											
										
										
											2020-06-10 06:20:48 +00:00
+									# show result
-												fix possible problems found while adjust test

											
										
										
											2020-06-29 09:21:56 +00:00
+									ls -ld "${DATADIR}" "${LOGDIR}" ./*.jssh* ./*.sh 2>/dev/null
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+								}
-												finally fix send_message test

											
										
										
											2019-05-26 15:03:58 +00:00
+								if ! _is_function send_message ; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${RED}ERROR: send_message is not available, did you deactivate ${MODULEDIR}/sendMessage.sh?${NN}"
-												finally fix send_message test

											
										
										
											2019-05-26 15:03:58 +00:00
+									exit 1
 								fi
-												add support for JSON.awk, 5 times faster

											
										
										
											2020-12-15 15:36:27 +00:00
+								# check if JSON.awk exist and has x flag
 								JSONAWKFILE="${JSONSHFILE%.sh}.awk"
 								if [ -x "${JSONAWKFILE}" ] && _exists awk ; then
 									JSONSHFILE="JsonAwk"; JsonAwk() { "${JSONAWKFILE}" -v "BRIEF=8" -v "STRICT=0" -; }
 								fi
-												Fixed last bugs
											
										
										
											2016-03-20 21:34:55 +00:00
+								# source the script with source as param to use functions in other scripts
-												better handling of sourcing files

											
										
										
											2019-04-20 14:26:16 +00:00
+								# do not execute if read from other scripts
-												fix detecting sourceing

											
										
										
											2020-06-19 16:47:18 +00:00
+								if [ -z "${SOURCE}" ]; then
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+								  ##############
 								  # internal options only for use from bashbot and developers
-												statisfy newer shellcheck version

											
										
										
											2020-11-29 14:34:00 +00:00
+								  # shellcheck disable=SC2221,SC2222
-												coding-style: positonal parameters $1 - \9 has precedence over verything

											
										
										
											2021-01-05 15:17:34 +00:00
+								  case "$1" in
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									# update botname when starting only
-												better handling of restart jobs

											
										
										
											2020-06-22 12:10:36 +00:00
+									"botname"|"start"*)
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+										ME="$(getBotName)"
 										if [ -n "${ME}" ]; then
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+											# ok we have a connection and got botname, save it
-												CLEAR -> INTERACTIVE

											
										
										
											2020-12-27 10:26:38 +00:00
+											[ -n "${INTERACTIVE}" ] && printf "${GREY}Bottoken is valid ...${NN}"
-												rename BOTDATABASE to BOTCONFIG

											
										
										
											2020-06-19 10:49:18 +00:00
+											jssh_updateKeyDB "botname" "${ME}" "${BOTCONFIG}"
 											rm -f "${BOTCONFIG}.jssh.flock"
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+										else
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											printf "${GREY}Info: Can't get Botname from Telegram, try cached one ...${NN}"
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+											ME="$(getConfigKey "botname")"
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+											if [ -z "${ME}" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											    printf "${RED}ERROR: No cached botname, can't continue! ...${NN}"
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+											    exit 1
 											fi
 										fi
-												CLEAR -> INTERACTIVE

											
										
										
											2020-12-27 10:26:38 +00:00
+										[ -n "${INTERACTIVE}" ] && printf "Bot Name: %s\n" "${ME}"
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+										[ "$1" = "botname" ] && exit
-												first working version with jssh botconfig database

											
										
										
											2020-06-12 21:41:47 +00:00
+										;;&
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+									# used to send output of background and interactive to chats
-												dev: adjust make-standalone

											
										
										
											2021-01-20 18:50:19 +00:00
+									"outproc")	# $2 chat_id $3 identifier of job, internal use only!
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										[ -z "$3" ] && printf "No job identifier\n" && exit 3
 										[ -z "$2"  ] && printf "No chat to send to\n" && exit 3
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
+										ME="$(getConfigKey "botname")"
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+										# read until terminated
-												fix outproc exit and show script on ps

											
										
										
											2019-05-19 15:31:55 +00:00
+										while read -r line ;do
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+											[ -n "${line}" ] && send_message "$2" "${line}"
-												start dev3 - remove tmux

											
										
										
											2019-05-18 18:25:18 +00:00
+										done
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+										# cleanup datadir, keep logfile if not empty
-												TMPDIR is used from BASH -> DATADIR

											
										
										
											2019-05-28 18:44:40 +00:00
+										rm -f -r "${DATADIR:-.}/$3"
 										[ -s "${DATADIR:-.}/$3.log" ] || rm -f "${DATADIR:-.}/$3.log"
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+										debug_checks "end outproc" "$@"
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+										exit
 										;;
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									# finally starts the read update loop, internal use only1
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+									"startbot" )
-												slower adaptive sleep in pesudo ms

											
										
										
											2019-04-22 19:50:38 +00:00
+										start_bot "$2"
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+										debug_checks "end startbot" "$@"
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+										exit
-												Fixed bugs (now you can run multiple background session in multiple bots), added option to count users, added option to parse markdown and html using send_message, updated documentation and decided to put the sending loop for interactive chats in the background using tmux so that if I have to update the bot interactive sessions will continue to send out messages. Also changed the file name and the location (/tmp/ of the fifos for interactive chats) and added option to broadcast messages to all users.

											
										
										
											2016-04-16 18:50:05 +00:00
+										;;
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+									# run after every update to update files and adjust permissions
 									"init")
-												basic infrastructure for addons ready

											
										
										
											2019-05-25 17:31:20 +00:00
+										bot_init "$2"
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+										debug_checks "end init" "$@"
-												refactor options, startbot and init

											
										
										
											2019-04-22 19:05:52 +00:00
+										exit
 										;;
-												remove stats command

											
										
										
											2020-12-27 10:18:42 +00:00
+									# stats deprecated
 									"stats"|"count")
 										printf "${ORANGE}Stats is a separate command now, see bin/bashbot_stats.sh --help${NN}"
 										"${BASHBOT_HOME:-.}"/bin/bashbot_stats.sh --help
-												Bashbot Version 0.5 - fix count message

											
										
										
											2019-04-04 13:25:27 +00:00
+										exit
-												Fixed bugs (now you can run multiple background session in multiple bots), added option to count users, added option to parse markdown and html using send_message, updated documentation and decided to put the sending loop for interactive chats in the background using tmux so that if I have to update the bot interactive sessions will continue to send out messages. Also changed the file name and the location (/tmp/ of the fifos for interactive chats) and added option to broadcast messages to all users.

											
										
										
											2016-04-16 18:50:05 +00:00
+										;;
-												remove stats command

											
										
										
											2020-12-27 10:18:42 +00:00
+									# broadcast deprecated
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+									'broadcast')
-												remove stats command

											
										
										
											2020-12-27 10:18:42 +00:00
+										printf "${ORANGE}Broadcast is a separate command now, see bin/send_broadcast.sh --help${NN}"
-												remove nashbot option broadcast, use broadcast.sh

											
										
										
											2020-12-17 07:58:32 +00:00
+										"${BASHBOT_HOME:-.}"/bin/send_broadcast.sh --help
-												new feature block users, use jsshDB for count

											
										
										
											2020-05-29 18:11:51 +00:00
+										exit
-												Fixed bugs (now you can run multiple background session in multiple bots), added option to count users, added option to parse markdown and html using send_message, updated documentation and decided to put the sending loop for interactive chats in the background using tmux so that if I have to update the bot interactive sessions will continue to send out messages. Also changed the file name and the location (/tmp/ of the fifos for interactive chats) and added option to broadcast messages to all users.

											
										
										
											2016-04-16 18:50:05 +00:00
+										;;
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									# does what it says
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+									"status")
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
+										ME="$(getConfigKey "botname")"
 										SESSION="${ME:-_bot}-startbot"
 										BOTPID="$(proclist "${SESSION}")"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+										if [ -n "${BOTPID}" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											printf "${GREEN}Bot is running with UID ${RUNUSER}.${NN}"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+											exit
 										else
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											printf "${ORANGE}No Bot running with UID ${RUNUSER}.${NN}"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+											exit 5
 										fi
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+										debug_checks "end status" "$@"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+										;;
-												Cosmetic updates to spelling and indentation

											
										
										
											2020-09-26 17:52:06 +00:00
+									# start bot as background job and check if bot is running
-												Added easy way to start bot.

											
										
										
											2016-04-17 12:13:28 +00:00
+									"start")
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
+										# shellcheck disable=SC2086
 										SESSION="${ME:-_bot}-startbot"
 										BOTPID="$(proclist "${SESSION}")"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+										# shellcheck disable=SC2086
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+										[ -n "${BOTPID}" ] && kill ${BOTPID}
-												fix missing ${xxx} warnings

											
										
										
											2021-01-04 22:08:09 +00:00
+										nohup "${SCRIPT}" "startbot" "$2" "${SESSION}" &>/dev/null &
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+										printf "Session Name: %s\n" "${SESSION}"
 										sleep 1
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+										if [ -n "$(proclist "${SESSION}")" ]; then
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										 	printf "${GREEN}Bot started successfully.${NN}"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+										else
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											printf "${RED}An error occurred while starting the bot.${NN}"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+											exit 5
 										fi
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+										debug_checks "end start" "$@"
-												Added easy way to start bot.

											
										
										
											2016-04-17 12:13:28 +00:00
+										;;
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+									# does what it says
 									"stop")
-												rearrange get botname, allow recover from broken botconfig

											
										
										
											2020-06-19 10:54:05 +00:00
+										ME="$(getConfigKey "botname")"
 										SESSION="${ME:-_bot}-startbot"
 										BOTPID="$(proclist "${SESSION}")"
-												optimize startup and testing for empty string

											
										
										
											2020-05-14 18:33:30 +00:00
+										if [ -n "${BOTPID}" ]; then
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+											# shellcheck disable=SC2086
 											if kill ${BOTPID}; then
-												inform dot admin about stop, resume, restart

											
										
										
											2020-06-15 18:07:43 +00:00
+												# inform botadmin about stop
-												remove unneeded variable ADIM

											
										
										
											2020-12-31 17:11:37 +00:00
+												send_normal_message "$(getConfigKey "botadmin")" "Bot ${ME} stopped ..." &
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+												printf "${GREEN}OK. Bot stopped successfully.${NN}"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+											else
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+												printf "${RED}An error occurred while stopping bot.${NN}"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+												exit 5
 											fi
-												first working version with jssh botconfig database

											
										
										
											2020-06-12 21:41:47 +00:00
+										else
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+											printf "${ORANGE}No Bot running with UID ${RUNUSER}.${NN}"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+										fi
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+										debug_checks "end stop" "$@"
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+										exit
-												init command

											
										
										
											2019-03-25 10:15:07 +00:00
+										;;
-												codespell is much better

											
										
										
											2020-06-23 14:35:50 +00:00
+									# suspend, resume or kill background jobs
-												start 0.98 dev, create botconfig db

											
										
										
											2020-06-12 19:18:32 +00:00
+									"suspendb"*|"resumeb"*|"killb"*)
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+								  		_is_function job_control || { printf "${RED}Module background is not available!${NN}"; exit 3; }
-												better handling of restart jobs

											
										
										
											2020-06-22 12:10:36 +00:00
+										ME="$(getConfigKey "botname")"
-												move job control to module background and make it more failsave

											
										
										
											2019-05-20 19:40:14 +00:00
+										job_control "$1"
-												more debug checks to locate where broken config or strange files appears

											
										
										
											2020-06-27 08:29:36 +00:00
+										debug_checks "end background $1" "$@"
-												add command line option to kill all background jobs

											
										
										
											2019-03-18 21:19:44 +00:00
+										;;
-												Added a license for the unfortunate souls whose governments don't allow public domain.

Removed JSON.sh and added the project as a submodule. Modified code referencing it accordingly.

Added "attach" argument to attach to the tmux session and a default message if no argument is given.

Other minor changes.

											
										
										
											2016-04-19 09:49:35 +00:00
+									*)
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+										printf "${RED}${REALME##*/}: unknown command${NN}"
-												Bashbot Version 1.21 (cleanup release)

											
										
										
											2021-01-03 21:39:36 +00:00
+										printf "${ORANGE}Available commands: ${GREY}${BOTCOMMANDS}${NN}" && exit
-												autodetect sourcing, add CURL and WGET options, e.g. for using tor

											
										
										
											2019-05-23 17:40:15 +00:00
+										exit 4
-												Added easy way to start bot.

											
										
										
											2016-04-17 12:13:28 +00:00
+										;;
-												better handling of sourcing files

											
										
										
											2019-04-20 14:26:16 +00:00
+								  esac
-												functions in bash added and colors (#19)

* functions in bash added and colors

* Update bashbot.sh

* Update bashbot.sh

* Update bashbot.sh

* Update bashbot.sh

* Update bashbot.sh

											
										
										
											2016-06-05 10:41:49 +00:00
-												better handling of sourcing files

											
										
										
											2019-04-20 14:26:16 +00:00
+								  # warn if root
-												start, kill, resume, suspend now working

											
										
										
											2019-05-19 13:03:44 +00:00
+								  if [[ "${UID}" -eq "0" ]] ; then
-												Bashbot Version 1.21 (cleanup release)

											
										
										
											2021-01-03 21:39:36 +00:00
+									printf "\n${ORANGE}WARNING: ${SCRIPT} was started as ROOT (UID 0)!${NN}"
-												use printf

											
										
										
											2020-12-26 20:18:18 +00:00
+									printf "${ORANGE}You are at HIGH RISK when running a Telegram BOT with root privileges!${NN}"
-												better handling of sourcing files

											
										
										
											2019-04-20 14:26:16 +00:00
+								  fi
 								fi # end source