#!/bin/sh
#nsdataimport
PGNAME="nsdataimport"
PGDESC="Data import process"
TMPFILE="/tmp/"$PGNAME-$$".input"
TMPFOLDER="/tmp/"$PGNAME-$$
ACTIONSCRIPT="/tmp/"$PGNAME-$$".script"
LOGFILE="/usr/ns/log/nsdataimport.log"
DEF_TIMESPAN="1 hour"
PSQLTIMEOUT=5
usage () {
	echo "$PGNAME: $PGDESC"
	echo "Usage: $PGNAME [options...] [ImportFile] [-G #]"
	echo "where:"
	echo " ImportFile         Import filename"
	echo " -                  Read from standard input"
	echo "                    (Default: read from standard input)"
	echo " -G #               Data import group number"
	echo "and [options...] are:"
	echo " -a|-alarm|--alarm  Disable alarm checking."
	echo " -d #               Debug display level."
	echo " -f|-force|--force  Force replacing reports already in database."
	echo " -F fields,...      Specify input field order:"
	echo "                     [StationId,SensorId,RawData,ScaledData,"
	echo "                      DateTime,Date,Time,Year,Month,Day,Hour,Minute,Second,Source]"
	echo "                    (Default: SensorId,RawData,Date,Time)"
	echo " -F inline          Fields are prefixed by type:"
	echo "                     StationId=##,SensorId=##,RawData=#.##,DateTime=MM/DD/YYYY HH:MM:SS"
	echo " -help|--help       Display this help."
	echo " -i #               File data for this sensor ID only."
	echo " -q|-quiet|--quiet  Do not display activity messages."
	echo " -r|-raw|--raw      Force calibration of raw data."
	echo " -s #[smhd]         Add time offset to report time (Default: 0)"
	echo " -S #               Source number for report flag."
	echo " -T ImportType      Data import type:"
	echo "                     ImportType  Description              ImportProgram"
	echo "                     5096        5096 log data import     ns5096import"
	echo "                     5096A2      5096/A2 log data import  ns5096A2import"
	echo "                     50386       50386 log data import    ns50386import"
	echo "                     50386A2     50386/A2 log data import ns50386A2import"
	echo "                     Polllog     Station poll log import  nsautointerlogimport"
	echo "                     Recdatalog  Receive data log import  nsrecdatalogimport"
	echo "                     SHEF        SHEF data import         nsshefimport"
	echo "                     XML         XML data import          nsdataimportrpt -F inline"
	echo "                     Custom      Use field order          nsdataimportrpt -F fields"
	echo " -te D-T            Stopping time for data filing (Default: now)"
	echo " -ts D-T            Starting time for data filing (Default: 01/01/1980)"
	echo "     D-T is         MM/DD/YYYY-HH:MM:SS where / can be [/+-., ] - or : are any non digit"
	echo "                    YYYY/MM/DD-HH:MM:SS where / can be [/+-., ] - or : are any non digit"
	echo "                    +#[smhd...] Time offset added to current time"
	echo "                    -#[smhd...] Time offset subtracted from current time"
	echo " -version|--version    Display program version."
	echo " -xsl XslFilename   XSL translation filename."
}
if [ "$1" = "-help" -o "$1" = "--help" ]; then
	usage
	exit 0
fi

if [ "$1" = "-version" -o "$1" = "--version" ]; then
	echo $(nsversion)
	exit 0
fi

# Time stamp output and append to log file.
# Display on console if not quiet.
timestampLogFile() {
NotQuiet=${1:-false}
if [ $Quiet = "true" -a $NotQuiet = "false" ]; then
	sed -e "sz^z$(date '+%m/%d/%Y %H:%M:%S') z" >>$LOGFILE
else
	sed -e "sz^z$(date '+%m/%d/%Y %H:%M:%S') z" | tee -a $LOGFILE
fi
}

# Get command arguments.
COMMANDLINE="$0 $*"
COMMANDARGS="$*"
ImportFile=""
GroupNumber=""
Debug=0
AlarmDisable="false"
Force="false"
Quiet="false"
TimeOffset=""
StartTime=""
StopTime=""
ImportFields=""
ImportType=""
XslFilename=""
SensorId=""
RawData="false"
while test $# -gt 0; do
	arg="$1"
	if [ "$arg" = "-d" ]; then shift; Debug=$1
	elif [ "${arg#-d}" != "$arg" ]; then Debug="${arg#-d}";
	elif [ "$arg" = "-G" ]; then shift; GroupNumber="$1"
	elif [ "${arg#-G}" != "$arg" ]; then GroupNumber="${arg#-G}";
	elif [ "$arg" = "-F" ]; then shift; ImportFields=$1
	elif [ "${arg#-F}" != "$arg" ]; then ImportFields="${arg#-F}";
	elif [ "$arg" = "-S" ]; then shift; Source=$1
	elif [ "${arg#-S}" != "$arg" ]; then Source="${arg#-S}";
	elif [ "$arg" = "-T" ]; then shift; ImportType=$1
	elif [ "${arg#-T}" != "$arg" ]; then ImportType="${arg#-T}";
	elif [ "$arg" = "-s" ]; then shift; TimeOffset=$1
	elif [ "${arg#-s}" != "$arg" ]; then TimeOffset="${arg#-s}";
	elif [ "$arg" = "-te" ]; then shift; StopTime=$1
	elif [ "${arg#-te}" != "$arg" ]; then StopTime="${arg#-te}";
	elif [ "$arg" = "-ts" ]; then shift; StartTime=$1
	elif [ "${arg#-ts}" != "$arg" ]; then StartTime="${arg#-ts}";
	elif [ "$arg" = "-xsl" ]; then shift; XslFilename=$1
	elif [ "${arg#-xsl}" != "$arg" ]; then XslFilename="${arg#-xsl}";
	elif [ "$arg" = "-i" ]; then shift; SensorId=$1
	elif [ "${arg#-i}" != "$arg" ]; then SensorId="${arg#-i}";
	elif [ "$arg" = "-a" -o "$arg" = "-alarm" -o "$arg" = "--alarm" ]; then AlarmDisable="true";
	elif [ "$arg" = "-f" -o "$arg" = "-force" -o "$arg" = "--force" ]; then Force="true";
	elif [ "$arg" = "-q" -o "$arg" = "-quiet" -o "$arg" = "--quiet" ]; then Quiet="true";
	elif [ "$arg" = "-r" -o "$arg" = "-raw" -o "$arg" = "--raw" ]; then RawData="true";
	elif [ -z "$ImportFile" ]; then ImportFile=$1;
	else echo "Unknown argument: $arg"; fi
	shift
done
Debug=${Debug:-0}
Quiet=${Quiet:-false}

# Display start line for data import actions
echo "$COMMANDLINE started..." | timestampLogFile

# Get data import group option parameters
NumberOfActions=""
GID=0
if [ -n "$GroupNumber" ]; then
eval $(timeout $PSQLTIMEOUT psql novastar novastar -AtF= <<_EOF_
SELECT 'GID',id FROM data_import WHERE id=$GroupNumber;
SELECT 'Options',quote_literal(options) FROM data_import WHERE id=$GroupNumber;
_EOF_
)
	if [ $GID != $GroupNumber ]; then
		timestampLogFile <<_EOF_
Unable to read group record
$COMMANDLINE finished
_EOF_
		exit 1
	fi

	if [ $Debug -gt 0 ]; then
		(
		echo Options=$Options 
		) 2>&1 | timestampLogFile
	fi

	# Extract data import options
	if [ -n "$Options" ]; then
		if [ $Debug -gt 0 ]; then
			(
			echo "$Options" | sed -e "s/=/='/g" -e "s/$/'/g" -e "s/;/';/g" | tr ';' '\n'
			) 2>&1 | timestampLogFile
		fi
		eval $(echo "$Options" | sed -e "s/=/='/g" -e "s/$/'/g" -e "s/;/';/g" | tr ';' '\n')
		if [ -z "$ImportType" ]; then ImportType=$type; fi
		if [ -z "$ImportFields" ]; then ImportFields=$fields; fi
		if [ -z "$Source" ]; then Source=$source; fi
	fi

	# Get number of actions for data import
	eval $(timeout $PSQLTIMEOUT psql novastar novastar -AtF= <<_EOF_
SELECT 'NumberOfActions',action_order FROM data_import_action WHERE data_import_id=$GroupNumber ORDER BY action_order DESC LIMIT 1;
_EOF_
)
	if [ $Debug -gt 0 ]; then
		echo "NumberOfActions=$NumberOfActions" 2>&1 | timestampLogFile
	fi
fi

# Input data command arguments
ARGS=""
if [ $Debug -gt 0 ]; then ARGS=$ARGS" -d$Debug"; fi
if [ "$AlarmDisable" = "true" ]; then ARGS=$ARGS" -a"; fi
if [ "$Force" = "true" ]; then ARGS=$ARGS" -f"; fi
if [ "$Quiet" = "true" ]; then ARGS=$ARGS" -q"; fi
if [ "$RawData" = "true" ]; then ARGS=$ARGS" -r"; fi
if [ -n "$SensorId" ]; then ARGS=$ARGS" -i$SensorId"; fi
if [ -n "$Source" ]; then ARGS=$ARGS" -S$Source"; fi
if [ -n "$TimeOffset" ]; then ARGS=$ARGS" -s$TimeOffset"; fi
if [ -n "$StartTime" ]; then ARGS=$ARGS" -ts$StartTime"; fi
if [ -n "$StopTime" ]; then ARGS=$ARGS" -te$StopTime"; fi
if [ -n "$XslFilename" ]; then ARGS=$ARGS" -xsl$XslFilename"; fi

# Import data for import type
importData() {
	ImportFile="$1"

	# Get timeout, default is 5 minutes.
	timeout="$2"
	timeout=${timeout:-5m}

	# Quit with error if import file does not exist.
	if [ -n "$ImportFile" -a "$ImportFile" != "-" ]; then
		if [ ! -f "$ImportFile" ]; then
			echo "Error - $ImportFile does not exist!" 2>&1 | timestampLogFile
			return
		fi
	fi

	if [ "$ImportType" = "5096" ]; then ImportCommand="ns5096import"
	elif [ "$ImportType" = "5096A2" ]; then ImportCommand="ns5096A2import"
	elif [ "$ImportType" = "50386" ]; then ImportCommand="ns50386import"
	elif [ "$ImportType" = "50386A2" ]; then ImportCommand="ns50386A2import"
	elif [ "$ImportType" = "Recdatalog" ]; then ImportCommand="nsrecdatalogimport"
	elif [ "$ImportType" = "Polllog" ]; then ImportCommand="nsautointerlogimport"
	elif [ "$ImportType" = "SHEF" ]; then ImportCommand="nsshefimport"
	elif [ "$ImportType" = "XML" ]; then 
		ImportCommand="nsxmlimport"
		# XML imports use inline fields, force if not set.
		if [ -z "$ImportFields" ]; then ImportFields="inline"; fi		
		if [ -n "$ImportFields" ]; then ARGS=$ARGS" -F$ImportFields"; fi

		# XML import use XSL transformation, add to command if defined.
		if [ -z "$XslFilename" ]; then
			# Not defined on command line, check data import action argument.
			if [ -n "$xslFile" ]; then
				# XSL transformation file defined, check if local path.
				if [ ! -f "$xslFile" ]; then
					# Not local path, add default XSL file path.
					xslFile="/usr/ns/xsl/$xslFile"
				fi
				# Add XSL file name to command arguments if defined.
				if [ -f "$xslFile" ]; then
					ARGS="$ARGS -xsl$xslFile"
				fi
			fi
		fi
	else
		ImportCommand="nsdataimportrpt"
		# Add ImportFields if defined
		if [ -n "$ImportFields" ]; then ARGS=$ARGS" -F$ImportFields"; fi
	fi

	# Add ImportFile if defined. Import file name is first argument.
	CMDARGS=$ARGS
	if [ -n "$ImportFile" ]; then CMDARGS=$ImportFile" "$ARGS; fi

	if [ $Debug -gt 0 ]; then
		echo timeout $timeout $ImportCommand $CMDARGS 2>&1 | timestampLogFile
	fi

	# Execute import command with arguments.
	timeout $timeout $ImportCommand $CMDARGS
	iret=$?

	# Set action success by completion code
	if [ "$iret" -eq 0 ]; then 
		result="success"
	elif [ $iret -eq 124 ]; then
		result="timeout"
	else
		result="failed"
	fi
	echo "$ImportCommand $CMDARGS $result" 2>&1 | timestampLogFile
}

# Import from filename if defined.
if [ -n "$ImportFile" ]; then 
	# Set default timeout
	# Import data from file
	importData "$ImportFile" 2>&1

# No import file required for receive data log file import.
elif [ "$ImportType" = "Recdatalog" ]; then 
	importData 2>&1

# No import file required for station polling log file import.
elif [ "$ImportType" = "Polllog" ]; then 
	importData 2>&1

# Otherwise import data from import action sources
else

	ActionOrder=1
	while test $ActionOrder -le $NumberOfActions; do

		# Prepare import folder
		ImportFolder="$TMPFOLDER"
		rm -rf $ImportFolder
		mkdir $ImportFolder >/dev/null 2>&1

		# Get import action
		eval $(timeout $PSQLTIMEOUT psql novastar novastar -AtF= <<_EOF_
SELECT 'ActionOptions',quote_literal(action_options) FROM data_import_action WHERE data_import_id=$GroupNumber AND action_order=$ActionOrder;
_EOF_
)
		# Extract import action options
		type=""
		fileName=""
		folder=""
		hostName=""
		loginName=""
		password=""
		remoteDelete=""
		timeout=""
		timespan=""
		xslFile=""
		webPage=""
		if [ $Debug -gt 0 ]; then
			(
			echo "ActionOptions=$ActionOptions"
			echo "$ActionOptions" | tr ';' '\n' | sed -e "s/=/='/" -e "s/$/'/"
			) 2>&1 | timestampLogFile
		fi
		eval $(echo "$ActionOptions" | tr ';' '\n' | sed -e "s/=/='/" -e "s/$/'/")

		# Make action type upper case
		ActionType=$(echo $type | tr 'a-z' 'A-Z')

		# Patch for lower case
		fileName=${fileName:-$filename}	
		hostName=${hostName:-$hostname}	
		loginName=${loginName:-$loginname}	
		remoteDelete=${remoteDelete:-$remotedelete}
		xslFile=${xslFile:-$xslfile}	
		webPage=${webPage:-$webpage}	

		# Set default destination folder to current folder
		folder=${folder:-./}

		# Convert timeout interval to command syntax
		timeout=$(echo $timeout | sed -e "s/second.*/s/" -e "s/minute.*/m/" -e "s/hour.*/h/" -e "s/day.*/d/")
		timeout=${timeout:-60}

		# Set remote delete to false by default.
		remoteDelete=${remoteDelete:-false}

		# Use temporary file if import file not provided
		ImportFile=${ImportFile:-$TMPFILE}
		rm -rf $ImportFile

		# Execute action and log to file
		(
		# Display import action started
		iret=1
		echo "$ActionType import started..."

		# Delete action script
		rm -f $ACTIONSCRIPT

		# Copy import action
		if [ $ActionType = "COPY" ]; then
			if [ -z "$fileName" ]; then
				echo "$ActionType import missing file name"
			else
				if [ -d $folder ]; then
					# Execute action with timeout.
					RESTOREWD="$PWD"
					echo "cd $folder"
					cd $folder
					echo "timeout $timeout cp -v $fileName $ImportFolder"
					timeout $timeout cp -v $fileName $ImportFolder
					iret=$?
					cd "$RESTOREWD"
				else
					echo "Error - $folder does not exist!"
					iret=1
				fi		
			fi
		fi

		# FTP import action
		if [ $ActionType = "FTP" ]; then
			ACTIONCOMMAND="ftp -i -v"
			if [ -z "$hostName" ]; then
				echo "Error - $ActionType import missing host name"
			elif [ -z "$fileName" ]; then
				echo "Error - $ActionType import missing file name"
			else
				if [ -n "$loginName" ]; then
					ACTIONCOMMAND="$ACTIONCOMMAND -n"
					cat >>$ACTIONSCRIPT <<_EOF_
user $loginName $password
_EOF_
				fi
				cat >>$ACTIONSCRIPT <<_EOF_
lcd $ImportFolder
ascii
cd $folder
mget $fileName
bye
_EOF_

				# Execute action with timeout.
				echo "timeout $timeout $ACTIONCOMMAND $hostName"
				cat $ACTIONSCRIPT
				timeout $timeout $ACTIONCOMMAND $hostName <$ACTIONSCRIPT
				iret=$?
				rm -f $ACTIONSCRIPT
			fi
		fi

		# LFTP import action
		if [ $ActionType = "LFTP"  ]; then
			if [ -z "$hostName" ]; then
				echo "Error - $ActionType import missing host name"
			elif [ -z "$fileName" ]; then
				echo "Error - $ActionType import missing file name"
			else
				cat >>$ACTIONSCRIPT <<_EOF_
open $hostName
_EOF_
				if [ -n "$loginName" ]; then
					cat >>$ACTIONSCRIPT <<_EOF_
user $loginName $password
_EOF_
				fi
				# Insert ftps parameters if needed.
				NOTFTPShostName=${hostName#ftps://}
				if [ "$NOTFTPShostName" != "$hostName" ]; then
					cat >>$ACTIONSCRIPT <<_EOF_
set ftps:initial-prot ""
set ftp:ssl-force true
set ftp:ssl-protect-data true
_EOF_
				fi
				cat >>$ACTIONSCRIPT <<_EOF_
lcd $ImportFolder
cd $folder
mget $fileName
bye
_EOF_

				# Execute action with timeout.
				rm -f ~/.lftp/transfer_log
				echo "timeout $timeout lftp -f $ACTIONSCRIPT"
				cat $ACTIONSCRIPT
				timeout $timeout lftp -f $ACTIONSCRIPT
				iret=$?
				if [ -s "~/.lftp/transfer_log" ]; then
					cat ~/.lftp/transfer_log
				fi
				rm -f ~/.lftp/transfer_log
				rm -f $ACTIONSCRIPT
			fi
		fi

		# PFTP import action
		if [ $ActionType = "PFTP" ]; then
			if [ -z "$hostName" ]; then
				echo "Error - $ActionType import missing host name"
			elif [ -z "$fileName" ]; then
				echo "Error - $ActionType import missing file name"
			else
				ACTIONCOMMAND="pftp -i -v"
				if [ -n "$loginName" ]; then
					ACTIONCOMMAND="$ACTIONCOMMAND -n"
					cat >>$ACTIONSCRIPT <<_EOF_
user $loginName $password
_EOF_
				fi
				cat >>$ACTIONSCRIPT <<_EOF_
lcd $ImportFolder
ascii
cd $folder
mget $fileName
bye
_EOF_

				# Execute action with timeout.
				echo "timeout $timeout $ACTIONCOMMAND $hostName"
				cat $ACTIONSCRIPT
				timeout $timeout $ACTIONCOMMAND $hostName <$ACTIONSCRIPT
				iret=$?
				rm -f $ACTIONSCRIPT
			fi
		fi

		# SFTP import action
		if [ $ActionType  = "SFTP" ]; then
			if [ -z "$hostName" ]; then
				echo "Error - $ActionType import missing host name"
			elif [ -z "$fileName" ]; then
				echo "Error - $ActionType import missing file name"
			else
				cat >>$ACTIONSCRIPT <<_EOF_
lcd $ImportFolder
cd $folder
get $fileName
bye
_EOF_
				# Prepare login host name.
				loginNameHostName=""
				if [ -n "$loginName" ]; then
					loginNameHostName="$loginName@"
				fi
				loginNameHostName="$loginNameHostName$hostName"
				echo "timeout $timeout sftp -b $ACTIONSCRIPT $loginNameHostName"

				# Execute action with timeout.
				cat $ACTIONSCRIPT
				timeout $timeout sftp -b $ACTIONSCRIPT $loginNameHostName
				iret=$?
				rm -f $ACTIONSCRIPT
			fi
		fi

		# SMB import action
		if [ $ActionType = "SMB" ]; then
			if [ -z "$hostName" ]; then
				echo "Error - $ActionType import missing host name"
			else
				cat >>$ACTIONSCRIPT <<_EOF_
lcd $ImportFolder
cd $folder
prompt
mget $fileName
quit
_EOF_
				# Create password and login name smbclient command arguments
				loginNamePassword=""
				if [ -n "$password" ]; then
					loginNamePassword=" $password"
				fi
				if [ -n "$loginName" ]; then
					loginNamePassword="$loginNamePassword -U $loginName"
				fi

				# Execute action with timeout.
				echo "timeout $timeout smbclient $hostName$loginNamePassword"
				cat $ACTIONSCRIPT
				timeout $timeout smbclient "$hostName"$loginNamePassword <$ACTIONSCRIPT
				iret=$?
				rm -f $ACTIONSCRIPT
			fi
		fi

		# Webpage import action
		if [ $ActionType = "WEBPAGE" ]; then
			if [ -z "$webPage" ]; then
				echo "Error - $ActionType import missing URL"
			else
				# Prepare import file name
				ImportFile="$ImportFolder/$PGNAME-$$.input"

				# Translate special strings in URL
				url="$webPage"

				# If ending time not defined, use current time.
				TimeEnd=${StopTime:-$(nstime)}

				# Set ending time in URL.
				if [ -n "$(echo $url | grep _TIMEEND_)" ]; then

					# Translate ending time for URL (no spaces) 
					TimeEnd=$(dispdate "$TimeEnd" "+%Y-%m-%d+%H:%M:%S")
					echo $url | sed -e "s/_TIMEEND_/$TimeEnd/"
					url=$(echo $url | sed -e "s/_TIMEEND_/$TimeEnd/")
				fi

				# Set starting time in URL.
				if [ -n "$(echo $url | grep _TIMESTART_)" ]; then

					# If not provided then subtract timespan from ending time.
					if [ -z "$StartTime" ]; then
						# Set default time span if not defined.
						timespan=${timespan:-$DEF_TIMESPAN}
						# Put ending time back in SQL format. 
						TimeEnd=$(dispdate "$TimeEnd" "+%Y-%m-%d %H:%M:%S")
						# Compute starting time as ending time less time span.
						StartTime=$(echo "SELECT '$TimeEnd'::timestamp - INTERVAL '$timespan';" | timeout $PSQLTIMEOUT psql novastar novastar -AtF,)
					fi

					# Translate starting time for URL (no spaces)
					TimeStart=$(dispdate "$StartTime" "+%Y-%m-%d+%H:%M:%S")
					url=$(echo $url | sed -e "s/_TIMESTART_/$TimeStart/")
				fi			

				# Get import file from webpage URL.
				# Store in import file.
				echo "timeout $timeout curl $url $ImportFile"
				timeout $timeout curl "$url" >"$ImportFile"
				iret=$?
			fi
		fi	

		# Set action success by completion code
		if [ "$iret" -eq 0 ]; then 
			result="success"
		elif [ $iret -eq 124 ]; then
			result="timeout"
		else
			result="failed"
		fi

		if [ $(ls $ImportFolder | wc -l) -eq 0 ]; then
			echo "$ActionType import no files found"
		fi

		# Display import action result
		echo "$ActionType import $result"

		) 2>&1 | timestampLogFile

		# If import action successful, import data by reading files in import folder
		if [ $(ls $ImportFolder | wc -l) -gt 0 ]; then
			ls "$ImportFolder" | while read ImportFile; do
				echo importData "$ImportFolder"/"$ImportFile" "$timeout" | timestampLogFile
				importData "$ImportFolder"/"$ImportFile" "$timeout"
			done
		fi

		# Delete remote files if import action successful and remote delete enabled and files in import folder
		if [ "$remoteDelete" = "true" -a $(ls $ImportFolder | wc -l) -gt 0 ]; then

		# Display delete action started
		(
		echo "$ActionType delete started..."
		rm -f $ACTIONSCRIPT
		iret=1

		# Copy delete action
		if [ $ActionType = "COPY" ]; then
			if [ -d $folder ]; then
				RESTOREWD="$PWD"
				echo "cd $folder"
				cd $folder
				echo "timeout $timeout rm -fv $fileName"
				timeout $timeout rm -fv $fileName
				iret=$?
				cd "$RESTOREWD"
			else
				echo "Error - $folder does not exist!"
				iret=1
			fi			
		fi	

		# FTP delete action
		if [ $ActionType = "FTP" ]; then
			DELETECOMMAND="ftp -i -v"
			if [ -n "$loginName" ]; then
				DELETECOMMAND="$DELETECOMMAND -n"
				cat >>$ACTIONSCRIPT <<_EOF_
user $loginName $password
_EOF_
			fi
			cat >>$ACTIONSCRIPT <<_EOF_
cd $folder
_EOF_
			ls $ImportFolder | sed -e "s/^/del /" >>$ACTIONSCRIPT
			cat >>$ACTIONSCRIPT <<_EOF_
bye
_EOF_
			echo "timeout $timeout $DELETECOMMAND $hostName"
			cat $ACTIONSCRIPT 
			timeout $timeout $DELETECOMMAND $hostName <$ACTIONSCRIPT
  		iret=$?
			rm -f $ACTIONSCRIPT
		fi

		# LFTP delete action
		if [ $ActionType = "LFTP"  ]; then
			cat >$ACTIONSCRIPT <<_EOF_
open $hostName
_EOF_
			if [ -n "$loginName" ]; then
				cat >>$ACTIONSCRIPT <<_EOF_
user $loginName $password
_EOF_
			fi
			# Insert ftps parameters if needed.
			NOTFTPShostName=${hostName#ftps://}
			if [ "$NOTFTPShostName" != "$hostName" ]; then
				cat >>$ACTIONSCRIPT <<_EOF_
set ftps:initial-prot ""
set ftp:ssl-force true
set ftp:ssl-protect-data true
_EOF_
			fi
			cat >>$ACTIONSCRIPT <<_EOF_
lcd $ImportFolder
cd $folder
_EOF_
			ls $ImportFolder | sed -e "s/^/rm /" >>$ACTIONSCRIPT
cat >>$ACTIONSCRIPT <<_EOF_
bye
_EOF_
			rm -f ~/.lftp/transfer_log
			echo "timeout $timeout lftp -f $ACTIONSCRIPT"
			cat $ACTIONSCRIPT
			timeout $timeout lftp -f $ACTIONSCRIPT
  		iret=$?
			if [ -s "~/.lftp/transfer_log" ]; then
				cat ~/.lftp/transfer_log
			fi
			rm -f $ACTIONSCRIPT
			rm -f ~/.lftp/transfer_log
		fi

		# PFTP delete action
		if [ $ActionType = "PFTP" ]; then
			DELETECOMMAND="pftp -i -v"
			if [ -n "$loginName" ]; then
				DELETECOMMAND="$DELETECOMMAND -n"
				cat >>$ACTIONSCRIPT <<_EOF_
user $loginName $password
_EOF_
			fi
			cat >>$ACTIONSCRIPT <<_EOF_
cd $folder
_EOF_
			ls $ImportFolder | sed -e "s/^/del /" >>$ACTIONSCRIPT
			cat >>$ACTIONSCRIPT <<_EOF_
bye
_EOF_
			echo "timeout $timeout $DELETECOMMAND $hostName"
			cat $ACTIONSCRIPT
			timeout $timeout $DELETECOMMAND $hostName <$ACTIONSCRIPT
  		iret=$?
			rm -f $ACTIONSCRIPT
		fi

		# SFTP delete action
		if [ $ActionType  = "SFTP" ]; then
			cat >>$ACTIONSCRIPT <<_EOF_
cd $folder
_EOF_
			ls $ImportFolder | sed -e "s/^/rm /" >>$ACTIONSCRIPT
			cat >>$ACTIONSCRIPT <<_EOF_
bye
_EOF_
			loginNameHostName=""
			if [ -n "$loginName" ]; then
				loginNameHostName="$loginName@"
			fi
			loginNameHostName="$loginNameHostName$hostName"
			echo "timeout $timeout sftp -b $ACTIONSCRIPT $loginNameHostName"
			cat $ACTIONSCRIPT
			timeout $timeout sftp -b $ACTIONSCRIPT $loginNameHostName
  		iret=$?
			rm -f $ACTIONSCRIPT
		fi

		# SMB delete action
		if [ $ActionType = "SMB" ]; then
			cat >>$ACTIONSCRIPT <<_EOF_
cd $folder
_EOF_
			ls $ImportFolder | sed -e "s/^/rm /" >>$ACTIONSCRIPT
			cat >>$ACTIONSCRIPT <<_EOF_
quit
_EOF_
			# Create password and login name smbclient command arguments
			loginNamePassword=""
			if [ -n "$password" ]; then
				loginNamePassword=" $password"
			fi
			if [ -n "$loginName" ]; then
				loginNamePassword="$loginNamePassword -U $loginName"
			fi
			echo "timeout $timeout smbclient $hostName$loginNamePassword"
			cat $ACTIONSCRIPT
			timeout $timeout smbclient $hostName$loginNamePassword <$ACTIONSCRIPT
  		iret=$?
			rm -f $ACTIONSCRIPT
		fi

		# Set action success by completion code
		if [ "$iret" -eq 0 ]; then 
			result="success"
		elif [ $iret -eq 124 ]; then
			result="timeout"
		else
			result="failed"
		fi

		# Webpage delete action
		if [ $ActionType = "WEBPAGE" ]; then
				# Ignore webpage delete action.
    		result="ignore"
		fi

		# Display delete action result
		echo "$ActionType delete $result"

		) 2>&1 | timestampLogFile

		fi # End of delete remote file

		rm -rf "$ImportFolder"
		ActionOrder=$((ActionOrder+1))
	done #End of action loop
fi

# Cleanup
rm -rf "$TMPFILE" "$ImportFolder"

# Display finish line for data import actions
echo "$COMMANDLINE finished" 2>&1 | timestampLogFile