#!/bin/bash

####################################################################################################
#### author: SlickStack ############################################################################
#### link: https://slickstack.io ###################################################################
#### mirror: https://mirrors.slickstack.io/bash/ss-check.txt #######################################
#### path: /var/www/ss-check #######################################################################
#### destination: n/a (not a boilerplate) ##########################################################
#### purpose: Retrieves all cron jobs and bash scripts (except for ss-check) #######################
#### module version: Ubuntu 22.04 LTS ##############################################################
#### sourced by: ss-install, ss-update-modules #####################################################
#### bash aliases: ss check ########################################################################
####################################################################################################

## source ss-config ##
source /var/www/ss-config

## source ss-functions ##
source /var/www/ss-functions

## BELOW THIS RELIES ON SS-CONFIG AND SS-FUNCTIONS

####################################################################################################
#### TABLE OF CONTENTS (SS-Check) ##################################################################
####################################################################################################

## this is a brief summary of the different code snippets you will find in this script ##
## each section should be commented so you understand what is being accomplished ##

## A. Touch Timestamp File
## B. Message (Begin Script)
## C. Retrieve Cron Jobs
## D. Retrieve Custom Cron Job Boilerplates
## E. Retrieve Bash Scripts (Except SS-Check)
## F. Install Cron Jobs 
## G. Install Custom Cron Job Boilerplates (If Not Exist)
## H. Install Bash Scripts (Except SS-Check)

####################################################################################################
#### A. SS-Check: Touch Timestamp File #############################################################
####################################################################################################

## this is a dummy timestamp file that will remember the last time this script was run ##
## it can be useful for developer reference and is sometimes used by SlickStack ##

ss_touch "${TIMESTAMP_SS_CHECK}"

####################################################################################################
#### B. SS-Check: Message (Begin Script) ###########################################################
####################################################################################################

## this is a simple message that announces to the shell the purpose of this bash script ##
## it will only be seen by sudo users who manually run this script in the shell ##

ss_echo "${COLOR_INFO}Running ss-check... ${COLOR_RESET}"

####################################################################################################
#### C. SS-Check: Retrieve Cron Jobs ###############################################################
####################################################################################################

## here we retrieve all the latest cron jobs and bash scripts to ensure they are current ##
## this process does not affect ss-config, LEMP modules, or the ss-check script ##

## 00-crontab ##
ss_wget "${TMP_00_CRONTAB}" "${GITHUB_00_CRONTAB}"
VALIDATE_TMP_00_CRONTAB=$(grep 'SS_EOF' "${TMP_00_CRONTAB}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_00_CRONTAB}" ]]; then
    ss_wget "${TMP_00_CRONTAB}" "${GITLAB_00_CRONTAB}"
fi

## 01-cron-minutely ##
ss_wget "${TMP_01_CRON_MINUTELY}" "${GITHUB_01_CRON_MINUTELY}"
VALIDATE_TMP_01_CRON_MINUTELY=$(grep 'SS_EOF' "${TMP_01_CRON_MINUTELY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_01_CRON_MINUTELY}" ]]; then
    ss_wget "${TMP_01_CRON_MINUTELY}" "${GITLAB_01_CRON_MINUTELY}"
fi

## 02-cron-often ##
ss_wget "${TMP_02_CRON_OFTEN}" "${GITHUB_02_CRON_OFTEN}"
VALIDATE_TMP_02_CRON_OFTEN=$(grep 'SS_EOF' "${TMP_02_CRON_OFTEN}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_02_CRON_OFTEN}" ]]; then
    ss_wget "${TMP_02_CRON_OFTEN}" "${GITLAB_02_CRON_OFTEN}"
fi

## 03-cron-regular ##
ss_wget "${TMP_03_CRON_REGULAR}" "${GITHUB_03_CRON_REGULAR}"
VALIDATE_TMP_03_CRON_REGULAR=$(grep 'SS_EOF' "${TMP_03_CRON_REGULAR}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_03_CRON_REGULAR}" ]]; then
    ss_wget "${TMP_03_CRON_REGULAR}" "${GITLAB_03_CRON_REGULAR}"
fi

## 04-cron-quarter-hourly ##
ss_wget "${TMP_04_CRON_QUARTER_HOURLY}" "${GITHUB_04_CRON_QUARTER_HOURLY}"
VALIDATE_TMP_04_CRON_QUARTER_HOURLY=$(grep 'SS_EOF' "${TMP_04_CRON_QUARTER_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_04_CRON_QUARTER_HOURLY}" ]]; then
    ss_wget "${TMP_04_CRON_QUARTER_HOURLY}" "${GITLAB_04_CRON_QUARTER_HOURLY}"
fi

## 05-cron-half-hourly ##
ss_wget "${TMP_05_CRON_HALF_HOURLY}" "${GITHUB_05_CRON_HALF_HOURLY}"
VALIDATE_TMP_05_CRON_HALF_HOURLY=$(grep 'SS_EOF' "${TMP_05_CRON_HALF_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_05_CRON_HALF_HOURLY}" ]]; then
    ss_wget "${TMP_05_CRON_HALF_HOURLY}" "${GITLAB_05_CRON_HALF_HOURLY}"
fi

## 06-cron-hourly ##
ss_wget "${TMP_06_CRON_HOURLY}" "${GITHUB_06_CRON_HOURLY}"
VALIDATE_TMP_06_CRON_HOURLY=$(grep 'SS_EOF' "${TMP_06_CRON_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_06_CRON_HOURLY}" ]]; then
    ss_wget "${TMP_06_CRON_HOURLY}" "${GITLAB_06_CRON_HOURLY}"
fi

## 07-cron-quarter-daily ##
ss_wget "${TMP_07_CRON_QUARTER_DAILY}" "${GITHUB_07_CRON_QUARTER_DAILY}"
VALIDATE_TMP_07_CRON_QUARTER_DAILY=$(grep 'SS_EOF' "${TMP_07_CRON_QUARTER_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_07_CRON_QUARTER_DAILY}" ]]; then
    ss_wget "${TMP_07_CRON_QUARTER_DAILY}" "${GITLAB_07_CRON_QUARTER_DAILY}"
fi

## 08-cron-half-daily ##
ss_wget "${TMP_08_CRON_HALF_DAILY}" "${GITHUB_08_CRON_HALF_DAILY}"
VALIDATE_TMP_08_CRON_HALF_DAILY=$(grep 'SS_EOF' "${TMP_08_CRON_HALF_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_08_CRON_HALF_DAILY}" ]]; then
    ss_wget "${TMP_08_CRON_HALF_DAILY}" "${GITLAB_08_CRON_HALF_DAILY}"
fi

## 09-cron-daily ##
ss_wget "${TMP_09_CRON_DAILY}" "${GITHUB_09_CRON_DAILY}"
VALIDATE_TMP_09_CRON_DAILY=$(grep 'SS_EOF' "${TMP_09_CRON_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_09_CRON_DAILY}" ]]; then
    ss_wget "${TMP_09_CRON_DAILY}" "${GITLAB_09_CRON_DAILY}"
fi

## 10-cron-half-weekly ##
ss_wget "${TMP_10_CRON_HALF_WEEKLY}" "${GITHUB_10_CRON_HALF_WEEKLY}"
VALIDATE_TMP_10_CRON_HALF_WEEKLY=$(grep 'SS_EOF' "${TMP_10_CRON_HALF_WEEKLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_10_CRON_HALF_WEEKLY}" ]]; then
    ss_wget "${TMP_10_CRON_HALF_WEEKLY}" "${GITLAB_10_CRON_HALF_WEEKLY}"
fi

## 11-cron-weekly ##
ss_wget "${TMP_11_CRON_WEEKLY}" "${GITHUB_11_CRON_WEEKLY}"
VALIDATE_TMP_11_CRON_WEEKLY=$(grep 'SS_EOF' "${TMP_11_CRON_WEEKLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_11_CRON_WEEKLY}" ]]; then
    ss_wget "${TMP_11_CRON_WEEKLY}" "${GITLAB_11_CRON_WEEKLY}"
fi

## 12-cron-half-monthly ##
ss_wget "${TMP_12_CRON_HALF_MONTHLY}" "${GITHUB_12_CRON_HALF_MONTHLY}"
VALIDATE_TMP_12_CRON_HALF_MONTHLY=$(grep 'SS_EOF' "${TMP_12_CRON_HALF_MONTHLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_12_CRON_HALF_MONTHLY}" ]]; then
    ss_wget "${TMP_12_CRON_HALF_MONTHLY}" "${GITLAB_12_CRON_HALF_MONTHLY}"
fi

## 13-cron-monthly ##
ss_wget "${TMP_13_CRON_MONTHLY}" "${GITHUB_13_CRON_MONTHLY}"
VALIDATE_TMP_13_CRON_MONTHLY=$(grep 'SS_EOF' "${TMP_13_CRON_MONTHLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_13_CRON_MONTHLY}" ]]; then
    ss_wget "${TMP_13_CRON_MONTHLY}" "${GITLAB_13_CRON_MONTHLY}"
fi

## 14-cron-sometimes ##
ss_wget "${TMP_14_CRON_SOMETIMES}" "${GITHUB_14_CRON_SOMETIMES}"
VALIDATE_TMP_14_CRON_SOMETIMES=$(grep 'SS_EOF' "${TMP_14_CRON_SOMETIMES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_14_CRON_SOMETIMES}" ]]; then
    ss_wget "${TMP_14_CRON_SOMETIMES}" "${GITLAB_14_CRON_SOMETIMES}"
fi

####################################################################################################
#### D. SS-Check: Retrieve Custom Cron Job Boilerplates ############################################
####################################################################################################

## here we retrieve all the latest cron jobs and bash scripts to ensure they are current ##
## this process does not affect ss-config, LEMP modules, or the ss-check script ##

## 01-cron-minutely-custom ##
ss_wget "${TMP_01_CRON_MINUTELY_CUSTOM}" "${GITHUB_01_CRON_MINUTELY_CUSTOM}"
VALIDATE_TMP_01_CRON_MINUTELY_CUSTOM=$(grep 'SS_EOF' "${TMP_01_CRON_MINUTELY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_01_CRON_MINUTELY_CUSTOM}" ]]; then
    ss_wget "${TMP_01_CRON_MINUTELY_CUSTOM}" "${GITLAB_01_CRON_MINUTELY_CUSTOM}"
fi

## 02-cron-often-custom ##
ss_wget "${TMP_02_CRON_OFTEN_CUSTOM}" "${GITHUB_02_CRON_OFTEN_CUSTOM}"
VALIDATE_TMP_02_CRON_OFTEN_CUSTOM=$(grep 'SS_EOF' "${TMP_02_CRON_OFTEN_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_02_CRON_OFTEN_CUSTOM}" ]]; then
    ss_wget "${TMP_02_CRON_OFTEN_CUSTOM}" "${GITLAB_02_CRON_OFTEN_CUSTOM}"
fi

## 03-cron-regular-custom ##
ss_wget "${TMP_03_CRON_REGULAR_CUSTOM}" "${GITHUB_03_CRON_REGULAR_CUSTOM}"
VALIDATE_TMP_03_CRON_REGULAR_CUSTOM=$(grep 'SS_EOF' "${TMP_03_CRON_REGULAR_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_03_CRON_REGULAR_CUSTOM}" ]]; then
    ss_wget "${TMP_03_CRON_REGULAR_CUSTOM}" "${GITLAB_03_CRON_REGULAR_CUSTOM}"
fi

## 04-cron-quarter-hourly-custom ##
ss_wget "${TMP_04_CRON_QUARTER_HOURLY_CUSTOM}" "${GITHUB_04_CRON_QUARTER_HOURLY_CUSTOM}"
VALIDATE_TMP_04_CRON_QUARTER_HOURLY_CUSTOM=$(grep 'SS_EOF' "${TMP_04_CRON_QUARTER_HOURLY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_04_CRON_QUARTER_HOURLY_CUSTOM}" ]]; then
    ss_wget "${TMP_04_CRON_QUARTER_HOURLY_CUSTOM}" "${GITLAB_04_CRON_QUARTER_HOURLY_CUSTOM}"
fi

## 05-cron-half-hourly-custom ##
ss_wget "${TMP_05_CRON_HALF_HOURLY_CUSTOM}" "${GITHUB_05_CRON_HALF_HOURLY_CUSTOM}"
VALIDATE_TMP_05_CRON_HALF_HOURLY_CUSTOM=$(grep 'SS_EOF' "${TMP_05_CRON_HALF_HOURLY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_05_CRON_HALF_HOURLY_CUSTOM}" ]]; then
    ss_wget "${TMP_05_CRON_HALF_HOURLY_CUSTOM}" "${GITLAB_05_CRON_HALF_HOURLY_CUSTOM}"
fi

## 06-cron-hourly-custom ##
ss_wget "${TMP_06_CRON_HOURLY_CUSTOM}" "${GITHUB_06_CRON_HOURLY_CUSTOM}"
VALIDATE_TMP_06_CRON_HOURLY_CUSTOM=$(grep 'SS_EOF' "${TMP_06_CRON_HOURLY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_06_CRON_HOURLY_CUSTOM}" ]]; then
    ss_wget "${TMP_06_CRON_HOURLY_CUSTOM}" "${GITLAB_06_CRON_HOURLY_CUSTOM}"
fi

## 07-cron-quarter-daily-custom ##
ss_wget "${TMP_07_CRON_QUARTER_DAILY_CUSTOM}" "${GITHUB_07_CRON_QUARTER_DAILY_CUSTOM}"
VALIDATE_TMP_07_CRON_QUARTER_DAILY_CUSTOM=$(grep 'SS_EOF' "${TMP_07_CRON_QUARTER_DAILY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_07_CRON_QUARTER_DAILY_CUSTOM}" ]]; then
    ss_wget "${TMP_07_CRON_QUARTER_DAILY_CUSTOM}" "${GITLAB_07_CRON_QUARTER_DAILY_CUSTOM}"
fi

## 08-cron-half-daily-custom ##
ss_wget "${TMP_08_CRON_HALF_DAILY_CUSTOM}" "${GITHUB_08_CRON_HALF_DAILY_CUSTOM}"
VALIDATE_TMP_08_CRON_HALF_DAILY_CUSTOM=$(grep 'SS_EOF' "${TMP_08_CRON_HALF_DAILY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_08_CRON_HALF_DAILY_CUSTOM}" ]]; then
    ss_wget "${TMP_08_CRON_HALF_DAILY_CUSTOM}" "${GITLAB_08_CRON_HALF_DAILY_CUSTOM}"
fi

## 09-cron-daily-custom ##
ss_wget "${TMP_09_CRON_DAILY_CUSTOM}" "${GITHUB_09_CRON_DAILY_CUSTOM}"
VALIDATE_TMP_09_CRON_DAILY_CUSTOM=$(grep 'SS_EOF' "${TMP_09_CRON_DAILY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_09_CRON_DAILY_CUSTOM}" ]]; then
    ss_wget "${TMP_09_CRON_DAILY_CUSTOM}" "${GITLAB_09_CRON_DAILY_CUSTOM}"
fi

## 10-cron-half-weekly-custom ##
ss_wget "${TMP_10_CRON_HALF_WEEKLY_CUSTOM}" "${GITHUB_10_CRON_HALF_WEEKLY_CUSTOM}"
VALIDATE_TMP_10_CRON_HALF_WEEKLY_CUSTOM=$(grep 'SS_EOF' "${TMP_10_CRON_HALF_WEEKLY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_10_CRON_HALF_WEEKLY_CUSTOM}" ]]; then
    ss_wget "${TMP_10_CRON_HALF_WEEKLY_CUSTOM}" "${GITLAB_10_CRON_HALF_WEEKLY_CUSTOM}"
fi

## 11-cron-weekly-custom ##
ss_wget "${TMP_11_CRON_WEEKLY_CUSTOM}" "${GITHUB_11_CRON_WEEKLY_CUSTOM}"
VALIDATE_TMP_11_CRON_WEEKLY_CUSTOM=$(grep 'SS_EOF' "${TMP_11_CRON_WEEKLY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_11_CRON_WEEKLY_CUSTOM}" ]]; then
    ss_wget "${TMP_11_CRON_WEEKLY_CUSTOM}" "${GITLAB_11_CRON_WEEKLY_CUSTOM}"
fi

## 12-cron-half-monthly-custom ##
ss_wget "${TMP_12_CRON_HALF_MONTHLY_CUSTOM}" "${GITHUB_12_CRON_HALF_MONTHLY_CUSTOM}"
VALIDATE_TMP_12_CRON_HALF_MONTHLY_CUSTOM=$(grep 'SS_EOF' "${TMP_12_CRON_HALF_MONTHLY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_12_CRON_HALF_MONTHLY_CUSTOM}" ]]; then
    ss_wget "${TMP_12_CRON_HALF_MONTHLY_CUSTOM}" "${GITLAB_12_CRON_HALF_MONTHLY_CUSTOM}"
fi

## 13-cron-monthly-custom ##
ss_wget "${TMP_13_CRON_MONTHLY_CUSTOM}" "${GITHUB_13_CRON_MONTHLY_CUSTOM}"
VALIDATE_TMP_13_CRON_MONTHLY_CUSTOM=$(grep 'SS_EOF' "${TMP_13_CRON_MONTHLY_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_13_CRON_MONTHLY_CUSTOM}" ]]; then
    ss_wget "${TMP_13_CRON_MONTHLY_CUSTOM}" "${GITLAB_13_CRON_MONTHLY_CUSTOM}"
fi

## 14-cron-sometimes-custom ##
ss_wget "${TMP_14_CRON_SOMETIMES_CUSTOM}" "${GITHUB_14_CRON_SOMETIMES_CUSTOM}"
VALIDATE_TMP_14_CRON_SOMETIMES_CUSTOM=$(grep 'SS_EOF' "${TMP_14_CRON_SOMETIMES_CUSTOM}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_14_CRON_SOMETIMES_CUSTOM}" ]]; then
    ss_wget "${TMP_14_CRON_SOMETIMES_CUSTOM}" "${GITLAB_14_CRON_SOMETIMES_CUSTOM}"
fi

####################################################################################################
#### E. SS-Check: Retrieve Bash Scripts (Except SS-Check) ##########################################
####################################################################################################

## here we retrieve all the latest cron jobs and bash scripts to ensure they are current ##
## this process does not affect ss-config, LEMP modules, or the ss-check script ##

#!/bin/bash

## ss-clean-database ##
ss_wget "${TMP_SS_CLEAN_DATABASE}" "${GITHUB_SS_CLEAN_DATABASE}"
VALIDATE_TMP_SS_CLEAN_DATABASE=$(grep 'SS_EOF' "${TMP_SS_CLEAN_DATABASE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_CLEAN_DATABASE}" ]]; then
    ss_wget "${TMP_SS_CLEAN_DATABASE}" "${GITLAB_SS_CLEAN_DATABASE}"
fi

## ss-clean-files ##
ss_wget "${TMP_SS_CLEAN_FILES}" "${GITHUB_SS_CLEAN_FILES}"
VALIDATE_TMP_SS_CLEAN_FILES=$(grep 'SS_EOF' "${TMP_SS_CLEAN_FILES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_CLEAN_FILES}" ]]; then
    ss_wget "${TMP_SS_CLEAN_FILES}" "${GITLAB_SS_CLEAN_FILES}"
fi

## ss-config-sample ##
ss_wget "${TMP_SS_CONFIG_SAMPLE}" "${GITHUB_SS_CONFIG_SAMPLE}"
VALIDATE_TMP_SS_CONFIG_SAMPLE=$(grep 'SS_EOF' "${TMP_SS_CONFIG_SAMPLE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_CONFIG_SAMPLE}" ]]; then
    ss_wget "${TMP_SS_CONFIG_SAMPLE}" "${GITLAB_SS_CONFIG_SAMPLE}"
fi

## ss-delete-database ##
ss_wget "${TMP_SS_DELETE_DATABASE}" "${GITHUB_SS_DELETE_DATABASE}"
VALIDATE_TMP_SS_DELETE_DATABASE=$(grep 'SS_EOF' "${TMP_SS_DELETE_DATABASE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_DELETE_DATABASE}" ]]; then
    ss_wget "${TMP_SS_DELETE_DATABASE}" "${GITLAB_SS_DELETE_DATABASE}"
fi

## ss-delete-files ##
ss_wget "${TMP_SS_DELETE_FILES}" "${GITHUB_SS_DELETE_FILES}"
VALIDATE_TMP_SS_DELETE_FILES=$(grep 'SS_EOF' "${TMP_SS_DELETE_FILES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_DELETE_FILES}" ]]; then
    ss_wget "${TMP_SS_DELETE_FILES}" "${GITLAB_SS_DELETE_FILES}"
fi

## ss-dump-database ##
ss_wget "${TMP_SS_DUMP_DATABASE}" "${GITHUB_SS_DUMP_DATABASE}"
VALIDATE_TMP_SS_DUMP_DATABASE=$(grep 'SS_EOF' "${TMP_SS_DUMP_DATABASE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_DUMP_DATABASE}" ]]; then
    ss_wget "${TMP_SS_DUMP_DATABASE}" "${GITLAB_SS_DUMP_DATABASE}"
fi

## ss-dump-files ##
ss_wget "${TMP_SS_DUMP_FILES}" "${GITHUB_SS_DUMP_FILES}"
VALIDATE_TMP_SS_DUMP_FILES=$(grep 'SS_EOF' "${TMP_SS_DUMP_FILES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_DUMP_FILES}" ]]; then
    ss_wget "${TMP_SS_DUMP_FILES}" "${GITLAB_SS_DUMP_FILES}"
fi

## ss-empty-logs ##
ss_wget "${TMP_SS_EMPTY_LOGS}" "${GITHUB_SS_EMPTY_LOGS}"
VALIDATE_TMP_SS_EMPTY_LOGS=$(grep 'SS_EOF' "${TMP_SS_EMPTY_LOGS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_EMPTY_LOGS}" ]]; then
    ss_wget "${TMP_SS_EMPTY_LOGS}" "${GITLAB_SS_EMPTY_LOGS}"
fi

## ss-encrypt-acme ##
ss_wget "${TMP_SS_ENCRYPT_ACME}" "${GITHUB_SS_ENCRYPT_ACME}"
VALIDATE_TMP_SS_ENCRYPT_ACME=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_ACME}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_ENCRYPT_ACME}" ]]; then
    ss_wget "${TMP_SS_ENCRYPT_ACME}" "${GITLAB_SS_ENCRYPT_ACME}"
fi

## ss-encrypt-certbot ##
ss_wget "${TMP_SS_ENCRYPT_CERTBOT}" "${GITHUB_SS_ENCRYPT_CERTBOT}"
VALIDATE_TMP_SS_ENCRYPT_CERTBOT=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_CERTBOT}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_ENCRYPT_CERTBOT}" ]]; then
    ss_wget "${TMP_SS_ENCRYPT_CERTBOT}" "${GITLAB_SS_ENCRYPT_CERTBOT}"
fi

## ss-encrypt-openssl ##
ss_wget "${TMP_SS_ENCRYPT_OPENSSL}" "${GITHUB_SS_ENCRYPT_OPENSSL}"
VALIDATE_TMP_SS_ENCRYPT_OPENSSL=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_OPENSSL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_ENCRYPT_OPENSSL}" ]]; then
    ss_wget "${TMP_SS_ENCRYPT_OPENSSL}" "${GITLAB_SS_ENCRYPT_OPENSSL}"
fi

## ss-functions ##
ss_wget "${TMP_SS_FUNCTIONS}" "${GITHUB_SS_FUNCTIONS}"
VALIDATE_TMP_SS_FUNCTIONS=$(grep 'SS_EOF' "${TMP_SS_FUNCTIONS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_FUNCTIONS}" ]]; then
    ss_wget "${TMP_SS_FUNCTIONS}" "${GITLAB_SS_FUNCTIONS}"
fi

## ss-import-database ##
ss_wget "${TMP_SS_IMPORT_DATABASE}" "${GITHUB_SS_IMPORT_DATABASE}"
VALIDATE_TMP_SS_IMPORT_DATABASE=$(grep 'SS_EOF' "${TMP_SS_IMPORT_DATABASE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_IMPORT_DATABASE}" ]]; then
    ss_wget "${TMP_SS_IMPORT_DATABASE}" "${GITLAB_SS_IMPORT_DATABASE}"
fi

## ss-import-files ##
ss_wget "${TMP_SS_IMPORT_FILES}" "${GITHUB_SS_IMPORT_FILES}"
VALIDATE_TMP_SS_IMPORT_FILES=$(grep 'SS_EOF' "${TMP_SS_IMPORT_FILES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_IMPORT_FILES}" ]]; then
    ss_wget "${TMP_SS_IMPORT_FILES}" "${GITLAB_SS_IMPORT_FILES}"
fi

## ss-install ##
ss_wget "${TMP_SS_INSTALL}" "${GITHUB_SS_INSTALL}"
VALIDATE_TMP_SS_INSTALL=$(grep 'SS_EOF' "${TMP_SS_INSTALL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL}" ]]; then
    ss_wget "${TMP_SS_INSTALL}" "${GITLAB_SS_INSTALL}"
fi

## ss-install-adminer ##
ss_wget "${TMP_SS_INSTALL_ADMINER}" "${GITHUB_SS_INSTALL_ADMINER}"
VALIDATE_TMP_SS_INSTALL_ADMINER=$(grep 'SS_EOF' "${TMP_SS_INSTALL_ADMINER}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_ADMINER}" ]]; then
    ss_wget "${TMP_SS_INSTALL_ADMINER}" "${GITLAB_SS_INSTALL_ADMINER}"
fi

## ss-install-craft-config ##
ss_wget "${TMP_SS_INSTALL_CRAFT_CONFIG}" "${GITHUB_SS_INSTALL_CRAFT_CONFIG}"
VALIDATE_TMP_SS_INSTALL_CRAFT_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_CRAFT_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_CRAFT_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_CRAFT_CONFIG}" "${GITLAB_SS_INSTALL_CRAFT_CONFIG}"
fi

## ss-install-craft-packages ##
ss_wget "${TMP_SS_INSTALL_CRAFT_PACKAGES}" "${GITHUB_SS_INSTALL_CRAFT_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_CRAFT_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_CRAFT_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_CRAFT_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_CRAFT_PACKAGES}" "${GITLAB_SS_INSTALL_CRAFT_PACKAGES}"
fi

## ss-install-mediawiki-config ##
ss_wget "${TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" "${GITHUB_SS_INSTALL_MEDIAWIKI_CONFIG}"
VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" "${GITLAB_SS_INSTALL_MEDIAWIKI_CONFIG}"
fi

## ss-install-mediawiki-packages ##
ss_wget "${TMP_SS_INSTALL_MEDIAWIKI_PACKAGES}" "${GITHUB_SS_INSTALL_MEDIAWIKI_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEDIAWIKI_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MEDIAWIKI_PACKAGES}" "${GITLAB_SS_INSTALL_MEDIAWIKI_PACKAGES}"
fi

## ss-install-memcached-config ##
ss_wget "${TMP_SS_INSTALL_MEMCACHED_CONFIG}" "${GITHUB_SS_INSTALL_MEMCACHED_CONFIG}"
VALIDATE_TMP_SS_INSTALL_MEMCACHED_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEMCACHED_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MEMCACHED_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MEMCACHED_CONFIG}" "${GITLAB_SS_INSTALL_MEMCACHED_CONFIG}"
fi

## ss-install-memcached-packages ##
ss_wget "${TMP_SS_INSTALL_MEMCACHED_PACKAGES}" "${GITHUB_SS_INSTALL_MEMCACHED_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_MEMCACHED_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEMCACHED_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MEMCACHED_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MEMCACHED_PACKAGES}" "${GITLAB_SS_INSTALL_MEMCACHED_PACKAGES}"
fi

## ss-install-moodle-config ##
ss_wget "${TMP_SS_INSTALL_MOODLE_CONFIG}" "${GITHUB_SS_INSTALL_MOODLE_CONFIG}"
VALIDATE_TMP_SS_INSTALL_MOODLE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MOODLE_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MOODLE_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MOODLE_CONFIG}" "${GITLAB_SS_INSTALL_MOODLE_CONFIG}"
fi

## ss-install-moodle-packages ##
ss_wget "${TMP_SS_INSTALL_MOODLE_PACKAGES}" "${GITHUB_SS_INSTALL_MOODLE_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_MOODLE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MOODLE_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MOODLE_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MOODLE_PACKAGES}" "${GITLAB_SS_INSTALL_MOODLE_PACKAGES}"
fi

## ss-install-mysql-config ##
ss_wget "${TMP_SS_INSTALL_MYSQL_CONFIG}" "${GITHUB_SS_INSTALL_MYSQL_CONFIG}"
VALIDATE_TMP_SS_INSTALL_MYSQL_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MYSQL_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MYSQL_CONFIG}" "${GITLAB_SS_INSTALL_MYSQL_CONFIG}"
fi

## ss-install-mysql-database ##
ss_wget "${TMP_SS_INSTALL_MYSQL_DATABASE}" "${GITHUB_SS_INSTALL_MYSQL_DATABASE}"
VALIDATE_TMP_SS_INSTALL_MYSQL_DATABASE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_DATABASE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MYSQL_DATABASE}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MYSQL_DATABASE}" "${GITLAB_SS_INSTALL_MYSQL_DATABASE}"
fi

## ss-install-mysql-packages ##
ss_wget "${TMP_SS_INSTALL_MYSQL_PACKAGES}" "${GITHUB_SS_INSTALL_MYSQL_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_MYSQL_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_MYSQL_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_MYSQL_PACKAGES}" "${GITLAB_SS_INSTALL_MYSQL_PACKAGES}"
fi

## ss-install-nginx-config ##
ss_wget "${TMP_SS_INSTALL_NGINX_CONFIG}" "${GITHUB_SS_INSTALL_NGINX_CONFIG}"
VALIDATE_TMP_SS_INSTALL_NGINX_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_NGINX_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_NGINX_CONFIG}" "${GITLAB_SS_INSTALL_NGINX_CONFIG}"
fi

## ss-install-nginx-letsencrypt ##
ss_wget "${TMP_SS_INSTALL_NGINX_LETSENCRYPT}" "${GITHUB_SS_INSTALL_NGINX_LETSENCRYPT}"
VALIDATE_TMP_SS_INSTALL_NGINX_LETSENCRYPT=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_LETSENCRYPT}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_NGINX_LETSENCRYPT}" ]]; then
    ss_wget "${TMP_SS_INSTALL_NGINX_LETSENCRYPT}" "${GITLAB_SS_INSTALL_NGINX_LETSENCRYPT}"
fi

## ss-install-nginx-openssl ##
ss_wget "${TMP_SS_INSTALL_NGINX_OPENSSL}" "${GITHUB_SS_INSTALL_NGINX_OPENSSL}"
VALIDATE_TMP_SS_INSTALL_NGINX_OPENSSL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_OPENSSL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_NGINX_OPENSSL}" ]]; then
    ss_wget "${TMP_SS_INSTALL_NGINX_OPENSSL}" "${GITLAB_SS_INSTALL_NGINX_OPENSSL}"
fi

## ss-install-nginx-packages ##
ss_wget "${TMP_SS_INSTALL_NGINX_PACKAGES}" "${GITHUB_SS_INSTALL_NGINX_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_NGINX_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_NGINX_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_NGINX_PACKAGES}" "${GITLAB_SS_INSTALL_NGINX_PACKAGES}"
fi

## ss-install-nginx-ssl ##
ss_wget "${TMP_SS_INSTALL_NGINX_SSL}" "${GITHUB_SS_INSTALL_NGINX_SSL}"
VALIDATE_TMP_SS_INSTALL_NGINX_SSL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_SSL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_NGINX_SSL}" ]]; then
    ss_wget "${TMP_SS_INSTALL_NGINX_SSL}" "${GITLAB_SS_INSTALL_NGINX_SSL}"
fi

## ss-install-opencart-config ##
ss_wget "${TMP_SS_INSTALL_OPENCART_CONFIG}" "${GITHUB_SS_INSTALL_OPENCART_CONFIG}"
VALIDATE_TMP_SS_INSTALL_OPENCART_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_OPENCART_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_OPENCART_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_OPENCART_CONFIG}" "${GITLAB_SS_INSTALL_OPENCART_CONFIG}"
fi

## ss-install-opencart-packages ##
ss_wget "${TMP_SS_INSTALL_OPENCART_PACKAGES}" "${GITHUB_SS_INSTALL_OPENCART_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_OPENCART_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_OPENCART_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_OPENCART_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_OPENCART_PACKAGES}" "${GITLAB_SS_INSTALL_OPENCART_PACKAGES}"
fi

## ss-install-php-config ##
ss_wget "${TMP_SS_INSTALL_PHP_CONFIG}" "${GITHUB_SS_INSTALL_PHP_CONFIG}"
VALIDATE_TMP_SS_INSTALL_PHP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PHP_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_PHP_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_PHP_CONFIG}" "${GITLAB_SS_INSTALL_PHP_CONFIG}"
fi

## ss-install-php-packages ##
ss_wget "${TMP_SS_INSTALL_PHP_PACKAGES}" "${GITHUB_SS_INSTALL_PHP_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_PHP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PHP_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_PHP_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_PHP_PACKAGES}" "${GITLAB_SS_INSTALL_PHP_PACKAGES}"
fi

## ss-install-prestashop-config ##
ss_wget "${TMP_SS_INSTALL_PRESTASHOP_CONFIG}" "${GITHUB_SS_INSTALL_PRESTASHOP_CONFIG}"
VALIDATE_TMP_SS_INSTALL_PRESTASHOP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PRESTASHOP_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_PRESTASHOP_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_PRESTASHOP_CONFIG}" "${GITLAB_SS_INSTALL_PRESTASHOP_CONFIG}"
fi

## ss-install-prestashop-packages ##
ss_wget "${TMP_SS_INSTALL_PRESTASHOP_PACKAGES}" "${GITHUB_SS_INSTALL_PRESTASHOP_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_PRESTASHOP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PRESTASHOP_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_PRESTASHOP_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_PRESTASHOP_PACKAGES}" "${GITLAB_SS_INSTALL_PRESTASHOP_PACKAGES}"
fi

## ss-install-rclone-config ##
ss_wget "${TMP_SS_INSTALL_RCLONE_CONFIG}" "${GITHUB_SS_INSTALL_RCLONE_CONFIG}"
VALIDATE_TMP_SS_INSTALL_RCLONE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_RCLONE_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_RCLONE_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_RCLONE_CONFIG}" "${GITLAB_SS_INSTALL_RCLONE_CONFIG}"
fi

## ss-install-rclone-packages ##
ss_wget "${TMP_SS_INSTALL_RCLONE_PACKAGES}" "${GITHUB_SS_INSTALL_RCLONE_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_RCLONE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_RCLONE_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_RCLONE_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_RCLONE_PACKAGES}" "${GITLAB_SS_INSTALL_RCLONE_PACKAGES}"
fi

## ss-install-ubuntu-bash ##
ss_wget "${TMP_SS_INSTALL_UBUNTU_BASH}" "${GITHUB_SS_INSTALL_UBUNTU_BASH}"
VALIDATE_TMP_SS_INSTALL_UBUNTU_BASH=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_BASH}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UBUNTU_BASH}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UBUNTU_BASH}" "${GITLAB_SS_INSTALL_UBUNTU_BASH}"
fi

## ss-install-ubuntu-crontab ##
ss_wget "${TMP_SS_INSTALL_UBUNTU_CRONTAB}" "${GITHUB_SS_INSTALL_UBUNTU_CRONTAB}"
VALIDATE_TMP_SS_INSTALL_UBUNTU_CRONTAB=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_CRONTAB}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UBUNTU_CRONTAB}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UBUNTU_CRONTAB}" "${GITLAB_SS_INSTALL_UBUNTU_CRONTAB}"
fi

## ss-install-ubuntu-kernel ##
ss_wget "${TMP_SS_INSTALL_UBUNTU_KERNEL}" "${GITHUB_SS_INSTALL_UBUNTU_KERNEL}"
VALIDATE_TMP_SS_INSTALL_UBUNTU_KERNEL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_KERNEL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UBUNTU_KERNEL}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UBUNTU_KERNEL}" "${GITLAB_SS_INSTALL_UBUNTU_KERNEL}"
fi

## ss-install-ubuntu-ssh ##
ss_wget "${TMP_SS_INSTALL_UBUNTU_SSH}" "${GITHUB_SS_INSTALL_UBUNTU_SSH}"
VALIDATE_TMP_SS_INSTALL_UBUNTU_SSH=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_SSH}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UBUNTU_SSH}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UBUNTU_SSH}" "${GITLAB_SS_INSTALL_UBUNTU_SSH}"
fi

## ss-install-ubuntu-swapfile ##
ss_wget "${TMP_SS_INSTALL_UBUNTU_SWAPFILE}" "${GITHUB_SS_INSTALL_UBUNTU_SWAPFILE}"
VALIDATE_TMP_SS_INSTALL_UBUNTU_SWAPFILE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_SWAPFILE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UBUNTU_SWAPFILE}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UBUNTU_SWAPFILE}" "${GITLAB_SS_INSTALL_UBUNTU_SWAPFILE}"
fi

## ss-install-ubuntu-users ##
ss_wget "${TMP_SS_INSTALL_UBUNTU_USERS}" "${GITHUB_SS_INSTALL_UBUNTU_USERS}"
VALIDATE_TMP_SS_INSTALL_UBUNTU_USERS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_USERS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UBUNTU_USERS}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UBUNTU_USERS}" "${GITLAB_SS_INSTALL_UBUNTU_USERS}"
fi

## ss-install-ubuntu-utils ##
ss_wget "${TMP_SS_INSTALL_UBUNTU_UTILS}" "${GITHUB_SS_INSTALL_UBUNTU_UTILS}"
VALIDATE_TMP_SS_INSTALL_UBUNTU_UTILS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_UTILS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UBUNTU_UTILS}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UBUNTU_UTILS}" "${GITLAB_SS_INSTALL_UBUNTU_UTILS}"
fi

## ss-install-ufw-config ##
ss_wget "${TMP_SS_INSTALL_UFW_CONFIG}" "${GITHUB_SS_INSTALL_UFW_CONFIG}"
VALIDATE_TMP_SS_INSTALL_UFW_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UFW_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UFW_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UFW_CONFIG}" "${GITLAB_SS_INSTALL_UFW_CONFIG}"
fi

## ss-install-ufw-packages ##
ss_wget "${TMP_SS_INSTALL_UFW_PACKAGES}" "${GITHUB_SS_INSTALL_UFW_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_UFW_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UFW_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_UFW_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_UFW_PACKAGES}" "${GITLAB_SS_INSTALL_UFW_PACKAGES}"
fi

## ss-install-wordpress-cli ##
ss_wget "${TMP_SS_INSTALL_WORDPRESS_CLI}" "${GITHUB_SS_INSTALL_WORDPRESS_CLI}"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_CLI=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_CLI}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_WORDPRESS_CLI}" ]]; then
    ss_wget "${TMP_SS_INSTALL_WORDPRESS_CLI}" "${GITLAB_SS_INSTALL_WORDPRESS_CLI}"
fi

## ss-install-wordpress-config ##
ss_wget "${TMP_SS_INSTALL_WORDPRESS_CONFIG}" "${GITHUB_SS_INSTALL_WORDPRESS_CONFIG}"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_WORDPRESS_CONFIG}" ]]; then
    ss_wget "${TMP_SS_INSTALL_WORDPRESS_CONFIG}" "${GITLAB_SS_INSTALL_WORDPRESS_CONFIG}"
fi

## ss-install-wordpress-mu-plugins ##
ss_wget "${TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" "${GITHUB_SS_INSTALL_WORDPRESS_MU_PLUGINS}"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" ]]; then
    ss_wget "${TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" "${GITLAB_SS_INSTALL_WORDPRESS_MU_PLUGINS}"
fi

## ss-install-wordpress-packages ##
ss_wget "${TMP_SS_INSTALL_WORDPRESS_PACKAGES}" "${GITHUB_SS_INSTALL_WORDPRESS_PACKAGES}"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_INSTALL_WORDPRESS_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_INSTALL_WORDPRESS_PACKAGES}" "${GITLAB_SS_INSTALL_WORDPRESS_PACKAGES}"
fi

## ss-maintenance-disable ##
ss_wget "${TMP_SS_MAINTENANCE_DISABLE}" "${GITHUB_SS_MAINTENANCE_DISABLE}"
VALIDATE_TMP_SS_MAINTENANCE_DISABLE=$(grep 'SS_EOF' "${TMP_SS_MAINTENANCE_DISABLE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_MAINTENANCE_DISABLE}" ]]; then
    ss_wget "${TMP_SS_MAINTENANCE_DISABLE}" "${GITLAB_SS_MAINTENANCE_DISABLE}"
fi

## ss-maintenance-enable ##
ss_wget "${TMP_SS_MAINTENANCE_ENABLE}" "${GITHUB_SS_MAINTENANCE_ENABLE}"
VALIDATE_TMP_SS_MAINTENANCE_ENABLE=$(grep 'SS_EOF' "${TMP_SS_MAINTENANCE_ENABLE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_MAINTENANCE_ENABLE}" ]]; then
    ss_wget "${TMP_SS_MAINTENANCE_ENABLE}" "${GITLAB_SS_MAINTENANCE_ENABLE}"
fi

## ss-monitor-resources ##
ss_wget "${TMP_SS_MONITOR_RESOURCES}" "${GITHUB_SS_MONITOR_RESOURCES}"
VALIDATE_TMP_SS_MONITOR_RESOURCES=$(grep 'SS_EOF' "${TMP_SS_MONITOR_RESOURCES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_MONITOR_RESOURCES}" ]]; then
    ss_wget "${TMP_SS_MONITOR_RESOURCES}" "${GITLAB_SS_MONITOR_RESOURCES}"
fi

## ss-optimize-database ##
ss_wget "${TMP_SS_OPTIMIZE_DATABASE}" "${GITHUB_SS_OPTIMIZE_DATABASE}"
VALIDATE_TMP_SS_OPTIMIZE_DATABASE=$(grep 'SS_EOF' "${TMP_SS_OPTIMIZE_DATABASE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_OPTIMIZE_DATABASE}" ]]; then
    ss_wget "${TMP_SS_OPTIMIZE_DATABASE}" "${GITLAB_SS_OPTIMIZE_DATABASE}"
fi

## ss-optimize-files ##
ss_wget "${TMP_SS_OPTIMIZE_FILES}" "${GITHUB_SS_OPTIMIZE_FILES}"
VALIDATE_TMP_SS_OPTIMIZE_FILES=$(grep 'SS_EOF' "${TMP_SS_OPTIMIZE_FILES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_OPTIMIZE_FILES}" ]]; then
    ss_wget "${TMP_SS_OPTIMIZE_FILES}" "${GITLAB_SS_OPTIMIZE_FILES}"
fi

## ss-perms ##
ss_wget "${TMP_SS_PERMS}" "${GITHUB_SS_PERMS}"
VALIDATE_TMP_SS_PERMS=$(grep 'SS_EOF' "${TMP_SS_PERMS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS}" ]]; then
    ss_wget "${TMP_SS_PERMS}" "${GITLAB_SS_PERMS}"
fi

## ss-perms-adminer ##
ss_wget "${TMP_SS_PERMS_ADMINER}" "${GITHUB_SS_PERMS_ADMINER}"
VALIDATE_TMP_SS_PERMS_ADMINER=$(grep 'SS_EOF' "${TMP_SS_PERMS_ADMINER}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_ADMINER}" ]]; then
    ss_wget "${TMP_SS_PERMS_ADMINER}" "${GITLAB_SS_PERMS_ADMINER}"
fi

## ss-perms-craft-config ##
ss_wget "${TMP_SS_PERMS_CRAFT_CONFIG}" "${GITHUB_SS_PERMS_CRAFT_CONFIG}"
VALIDATE_TMP_SS_PERMS_CRAFT_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_CRAFT_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_CRAFT_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_CRAFT_CONFIG}" "${GITLAB_SS_PERMS_CRAFT_CONFIG}"
fi

## ss-perms-craft-packages ##
ss_wget "${TMP_SS_PERMS_CRAFT_PACKAGES}" "${GITHUB_SS_PERMS_CRAFT_PACKAGES}"
VALIDATE_TMP_SS_PERMS_CRAFT_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_CRAFT_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_CRAFT_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_CRAFT_PACKAGES}" "${GITLAB_SS_PERMS_CRAFT_PACKAGES}"
fi

## ss-perms-mediawiki-config ##
ss_wget "${TMP_SS_PERMS_MEDIAWIKI_CONFIG}" "${GITHUB_SS_PERMS_MEDIAWIKI_CONFIG}"
VALIDATE_TMP_SS_PERMS_MEDIAWIKI_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEDIAWIKI_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MEDIAWIKI_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_MEDIAWIKI_CONFIG}" "${GITLAB_SS_PERMS_MEDIAWIKI_CONFIG}"
fi

## ss-perms-mediawiki-packages ##
ss_wget "${TMP_SS_PERMS_MEDIAWIKI_PACKAGES}" "${GITHUB_SS_PERMS_MEDIAWIKI_PACKAGES}"
VALIDATE_TMP_SS_PERMS_MEDIAWIKI_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEDIAWIKI_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MEDIAWIKI_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_MEDIAWIKI_PACKAGES}" "${GITLAB_SS_PERMS_MEDIAWIKI_PACKAGES}"
fi

## ss-perms-memcached-config ##
ss_wget "${TMP_SS_PERMS_MEMCACHED_CONFIG}" "${GITHUB_SS_PERMS_MEMCACHED_CONFIG}"
VALIDATE_TMP_SS_PERMS_MEMCACHED_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEMCACHED_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MEMCACHED_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_MEMCACHED_CONFIG}" "${GITLAB_SS_PERMS_MEMCACHED_CONFIG}"
fi

## ss-perms-memcached-packages ##
ss_wget "${TMP_SS_PERMS_MEMCACHED_PACKAGES}" "${GITHUB_SS_PERMS_MEMCACHED_PACKAGES}"
VALIDATE_TMP_SS_PERMS_MEMCACHED_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEMCACHED_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MEMCACHED_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_MEMCACHED_PACKAGES}" "${GITLAB_SS_PERMS_MEMCACHED_PACKAGES}"
fi

## ss-perms-moodle-config ##
ss_wget "${TMP_SS_PERMS_MOODLE_CONFIG}" "${GITHUB_SS_PERMS_MOODLE_CONFIG}"
VALIDATE_TMP_SS_PERMS_MOODLE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MOODLE_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MOODLE_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_MOODLE_CONFIG}" "${GITLAB_SS_PERMS_MOODLE_CONFIG}"
fi

## ss-perms-moodle-packages ##
ss_wget "${TMP_SS_PERMS_MOODLE_PACKAGES}" "${GITHUB_SS_PERMS_MOODLE_PACKAGES}"
VALIDATE_TMP_SS_PERMS_MOODLE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MOODLE_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MOODLE_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_MOODLE_PACKAGES}" "${GITLAB_SS_PERMS_MOODLE_PACKAGES}"
fi

## ss-perms-mysql-config ##
ss_wget "${TMP_SS_PERMS_MYSQL_CONFIG}" "${GITHUB_SS_PERMS_MYSQL_CONFIG}"
VALIDATE_TMP_SS_PERMS_MYSQL_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MYSQL_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_MYSQL_CONFIG}" "${GITLAB_SS_PERMS_MYSQL_CONFIG}"
fi

## ss-perms-mysql-database ##
ss_wget "${TMP_SS_PERMS_MYSQL_DATABASE}" "${GITHUB_SS_PERMS_MYSQL_DATABASE}"
VALIDATE_TMP_SS_PERMS_MYSQL_DATABASE=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_DATABASE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MYSQL_DATABASE}" ]]; then
    ss_wget "${TMP_SS_PERMS_MYSQL_DATABASE}" "${GITLAB_SS_PERMS_MYSQL_DATABASE}"
fi

## ss-perms-mysql-packages ##
ss_wget "${TMP_SS_PERMS_MYSQL_PACKAGES}" "${GITHUB_SS_PERMS_MYSQL_PACKAGES}"
VALIDATE_TMP_SS_PERMS_MYSQL_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_MYSQL_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_MYSQL_PACKAGES}" "${GITLAB_SS_PERMS_MYSQL_PACKAGES}"
fi

## ss-perms-nginx-config ##
ss_wget "${TMP_SS_PERMS_NGINX_CONFIG}" "${GITHUB_SS_PERMS_NGINX_CONFIG}"
VALIDATE_TMP_SS_PERMS_NGINX_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_NGINX_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_NGINX_CONFIG}" "${GITLAB_SS_PERMS_NGINX_CONFIG}"
fi

## ss-perms-nginx-packages ##
ss_wget "${TMP_SS_PERMS_NGINX_PACKAGES}" "${GITHUB_SS_PERMS_NGINX_PACKAGES}"
VALIDATE_TMP_SS_PERMS_NGINX_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_NGINX_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_NGINX_PACKAGES}" "${GITLAB_SS_PERMS_NGINX_PACKAGES}"
fi

## ss-perms-nginx-ssl ##
ss_wget "${TMP_SS_PERMS_NGINX_SSL}" "${GITHUB_SS_PERMS_NGINX_SSL}"
VALIDATE_TMP_SS_PERMS_NGINX_SSL=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_SSL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_NGINX_SSL}" ]]; then
    ss_wget "${TMP_SS_PERMS_NGINX_SSL}" "${GITLAB_SS_PERMS_NGINX_SSL}"
fi

## ss-perms-opencart-config ##
ss_wget "${TMP_SS_PERMS_OPENCART_CONFIG}" "${GITHUB_SS_PERMS_OPENCART_CONFIG}"
VALIDATE_TMP_SS_PERMS_OPENCART_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_OPENCART_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_OPENCART_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_OPENCART_CONFIG}" "${GITLAB_SS_PERMS_OPENCART_CONFIG}"
fi

## ss-perms-opencart-packages ##
ss_wget "${TMP_SS_PERMS_OPENCART_PACKAGES}" "${GITHUB_SS_PERMS_OPENCART_PACKAGES}"
VALIDATE_TMP_SS_PERMS_OPENCART_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_OPENCART_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_OPENCART_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_OPENCART_PACKAGES}" "${GITLAB_SS_PERMS_OPENCART_PACKAGES}"
fi

## ss-perms-php-config ##
ss_wget "${TMP_SS_PERMS_PHP_CONFIG}" "${GITHUB_SS_PERMS_PHP_CONFIG}"
VALIDATE_TMP_SS_PERMS_PHP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_PHP_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_PHP_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_PHP_CONFIG}" "${GITLAB_SS_PERMS_PHP_CONFIG}"
fi

## ss-perms-php-packages ##
ss_wget "${TMP_SS_PERMS_PHP_PACKAGES}" "${GITHUB_SS_PERMS_PHP_PACKAGES}"
VALIDATE_TMP_SS_PERMS_PHP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_PHP_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_PHP_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_PHP_PACKAGES}" "${GITLAB_SS_PERMS_PHP_PACKAGES}"
fi

## ss-perms-prestashop-config ##
ss_wget "${TMP_SS_PERMS_PRESTASHOP_CONFIG}" "${GITHUB_SS_PERMS_PRESTASHOP_CONFIG}"
VALIDATE_TMP_SS_PERMS_PRESTASHOP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_PRESTASHOP_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_PRESTASHOP_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_PRESTASHOP_CONFIG}" "${GITLAB_SS_PERMS_PRESTASHOP_CONFIG}"
fi

## ss-perms-prestashop-packages ##
ss_wget "${TMP_SS_PERMS_PRESTASHOP_PACKAGES}" "${GITHUB_SS_PERMS_PRESTASHOP_PACKAGES}"
VALIDATE_TMP_SS_PERMS_PRESTASHOP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_PRESTASHOP_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_PRESTASHOP_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_PRESTASHOP_PACKAGES}" "${GITLAB_SS_PERMS_PRESTASHOP_PACKAGES}"
fi

## ss-perms-rclone-config ##
ss_wget "${TMP_SS_PERMS_RCLONE_CONFIG}" "${GITHUB_SS_PERMS_RCLONE_CONFIG}"
VALIDATE_TMP_SS_PERMS_RCLONE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_RCLONE_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_RCLONE_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_RCLONE_CONFIG}" "${GITLAB_SS_PERMS_RCLONE_CONFIG}"
fi

## ss-perms-rclone-packages ##
ss_wget "${TMP_SS_PERMS_RCLONE_PACKAGES}" "${GITHUB_SS_PERMS_RCLONE_PACKAGES}"
VALIDATE_TMP_SS_PERMS_RCLONE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_RCLONE_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_RCLONE_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_RCLONE_PACKAGES}" "${GITLAB_SS_PERMS_RCLONE_PACKAGES}"
fi

## ss-perms-ubuntu-bash ##
ss_wget "${TMP_SS_PERMS_UBUNTU_BASH}" "${GITHUB_SS_PERMS_UBUNTU_BASH}"
VALIDATE_TMP_SS_PERMS_UBUNTU_BASH=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_BASH}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UBUNTU_BASH}" ]]; then
    ss_wget "${TMP_SS_PERMS_UBUNTU_BASH}" "${GITLAB_SS_PERMS_UBUNTU_BASH}"
fi

## ss-perms-ubuntu-crontab ##
ss_wget "${TMP_SS_PERMS_UBUNTU_CRONTAB}" "${GITHUB_SS_PERMS_UBUNTU_CRONTAB}"
VALIDATE_TMP_SS_PERMS_UBUNTU_CRONTAB=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_CRONTAB}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UBUNTU_CRONTAB}" ]]; then
    ss_wget "${TMP_SS_PERMS_UBUNTU_CRONTAB}" "${GITLAB_SS_PERMS_UBUNTU_CRONTAB}"
fi

## ss-perms-ubuntu-kernel ##
ss_wget "${TMP_SS_PERMS_UBUNTU_KERNEL}" "${GITHUB_SS_PERMS_UBUNTU_KERNEL}"
VALIDATE_TMP_SS_PERMS_UBUNTU_KERNEL=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_KERNEL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UBUNTU_KERNEL}" ]]; then
    ss_wget "${TMP_SS_PERMS_UBUNTU_KERNEL}" "${GITLAB_SS_PERMS_UBUNTU_KERNEL}"
fi

## ss-perms-ubuntu-ssh ##
ss_wget "${TMP_SS_PERMS_UBUNTU_SSH}" "${GITHUB_SS_PERMS_UBUNTU_SSH}"
VALIDATE_TMP_SS_PERMS_UBUNTU_SSH=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_SSH}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UBUNTU_SSH}" ]]; then
    ss_wget "${TMP_SS_PERMS_UBUNTU_SSH}" "${GITLAB_SS_PERMS_UBUNTU_SSH}"
fi

## ss-perms-ubuntu-swapfile ##
ss_wget "${TMP_SS_PERMS_UBUNTU_SWAPFILE}" "${GITHUB_SS_PERMS_UBUNTU_SWAPFILE}"
VALIDATE_TMP_SS_PERMS_UBUNTU_SWAPFILE=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_SWAPFILE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UBUNTU_SWAPFILE}" ]]; then
    ss_wget "${TMP_SS_PERMS_UBUNTU_SWAPFILE}" "${GITLAB_SS_PERMS_UBUNTU_SWAPFILE}"
fi

## ss-perms-ubuntu-users ##
ss_wget "${TMP_SS_PERMS_UBUNTU_USERS}" "${GITHUB_SS_PERMS_UBUNTU_USERS}"
VALIDATE_TMP_SS_PERMS_UBUNTU_USERS=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_USERS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UBUNTU_USERS}" ]]; then
    ss_wget "${TMP_SS_PERMS_UBUNTU_USERS}" "${GITLAB_SS_PERMS_UBUNTU_USERS}"
fi

## ss-perms-ubuntu-utils ##
ss_wget "${TMP_SS_PERMS_UBUNTU_UTILS}" "${GITHUB_SS_PERMS_UBUNTU_UTILS}"
VALIDATE_TMP_SS_PERMS_UBUNTU_UTILS=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_UTILS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UBUNTU_UTILS}" ]]; then
    ss_wget "${TMP_SS_PERMS_UBUNTU_UTILS}" "${GITLAB_SS_PERMS_UBUNTU_UTILS}"
fi

## ss-perms-ufw-config ##
ss_wget "${TMP_SS_PERMS_UFW_CONFIG}" "${GITHUB_SS_PERMS_UFW_CONFIG}"
VALIDATE_TMP_SS_PERMS_UFW_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_UFW_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UFW_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_UFW_CONFIG}" "${GITLAB_SS_PERMS_UFW_CONFIG}"
fi

## ss-perms-ufw-packages ##
ss_wget "${TMP_SS_PERMS_UFW_PACKAGES}" "${GITHUB_SS_PERMS_UFW_PACKAGES}"
VALIDATE_TMP_SS_PERMS_UFW_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_UFW_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_UFW_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_UFW_PACKAGES}" "${GITLAB_SS_PERMS_UFW_PACKAGES}"
fi

## ss-perms-wordpress-cli ##
ss_wget "${TMP_SS_PERMS_WORDPRESS_CLI}" "${GITHUB_SS_PERMS_WORDPRESS_CLI}"
VALIDATE_TMP_SS_PERMS_WORDPRESS_CLI=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_CLI}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_WORDPRESS_CLI}" ]]; then
    ss_wget "${TMP_SS_PERMS_WORDPRESS_CLI}" "${GITLAB_SS_PERMS_WORDPRESS_CLI}"
fi

## ss-perms-wordpress-config ##
ss_wget "${TMP_SS_PERMS_WORDPRESS_CONFIG}" "${GITHUB_SS_PERMS_WORDPRESS_CONFIG}"
VALIDATE_TMP_SS_PERMS_WORDPRESS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_WORDPRESS_CONFIG}" ]]; then
    ss_wget "${TMP_SS_PERMS_WORDPRESS_CONFIG}" "${GITLAB_SS_PERMS_WORDPRESS_CONFIG}"
fi

## ss-perms-wordpress-mu-plugins ##
ss_wget "${TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" "${GITHUB_SS_PERMS_WORDPRESS_MU_PLUGINS}"
VALIDATE_TMP_SS_PERMS_WORDPRESS_MU_PLUGINS=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" ]]; then
    ss_wget "${TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" "${GITLAB_SS_PERMS_WORDPRESS_MU_PLUGINS}"
fi

## ss-perms-wordpress-packages ##
ss_wget "${TMP_SS_PERMS_WORDPRESS_PACKAGES}" "${GITHUB_SS_PERMS_WORDPRESS_PACKAGES}"
VALIDATE_TMP_SS_PERMS_WORDPRESS_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_PACKAGES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PERMS_WORDPRESS_PACKAGES}" ]]; then
    ss_wget "${TMP_SS_PERMS_WORDPRESS_PACKAGES}" "${GITLAB_SS_PERMS_WORDPRESS_PACKAGES}"
fi

## ss-purge-nginx ##
ss_wget "${TMP_SS_PURGE_NGINX}" "${GITHUB_SS_PURGE_NGINX}"
VALIDATE_TMP_SS_PURGE_NGINX=$(grep 'SS_EOF' "${TMP_SS_PURGE_NGINX}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PURGE_NGINX}" ]]; then
    ss_wget "${TMP_SS_PURGE_NGINX}" "${GITLAB_SS_PURGE_NGINX}"
fi

## ss-purge-opcache ##
ss_wget "${TMP_SS_PURGE_OPCACHE}" "${GITHUB_SS_PURGE_OPCACHE}"
VALIDATE_TMP_SS_PURGE_OPCACHE=$(grep 'SS_EOF' "${TMP_SS_PURGE_OPCACHE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PURGE_OPCACHE}" ]]; then
    ss_wget "${TMP_SS_PURGE_OPCACHE}" "${GITLAB_SS_PURGE_OPCACHE}"
fi

## ss-purge-memcached ##
ss_wget "${TMP_SS_PURGE_MEMCACHED}" "${GITHUB_SS_PURGE_MEMCACHED}"
VALIDATE_TMP_SS_PURGE_MEMCACHED=$(grep 'SS_EOF' "${TMP_SS_PURGE_MEMCACHED}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PURGE_MEMCACHED}" ]]; then
    ss_wget "${TMP_SS_PURGE_MEMCACHED}" "${GITLAB_SS_PURGE_MEMCACHED}"
fi

## ss-purge-transients ##
ss_wget "${TMP_SS_PURGE_TRANSIENTS}" "${GITHUB_SS_PURGE_TRANSIENTS}"
VALIDATE_TMP_SS_PURGE_TRANSIENTS=$(grep 'SS_EOF' "${TMP_SS_PURGE_TRANSIENTS}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PURGE_TRANSIENTS}" ]]; then
    ss_wget "${TMP_SS_PURGE_TRANSIENTS}" "${GITLAB_SS_PURGE_TRANSIENTS}"
fi

## ss-push-development ##
ss_wget "${TMP_SS_PUSH_DEVELOPMENT}" "${GITHUB_SS_PUSH_DEVELOPMENT}"
VALIDATE_TMP_SS_PUSH_DEVELOPMENT=$(grep 'SS_EOF' "${TMP_SS_PUSH_DEVELOPMENT}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PUSH_DEVELOPMENT}" ]]; then
    ss_wget "${TMP_SS_PUSH_DEVELOPMENT}" "${GITLAB_SS_PUSH_DEVELOPMENT}"
fi

## ss-push-staging ##
ss_wget "${TMP_SS_PUSH_STAGING}" "${GITHUB_SS_PUSH_STAGING}"
VALIDATE_TMP_SS_PUSH_STAGING=$(grep 'SS_EOF' "${TMP_SS_PUSH_STAGING}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_PUSH_STAGING}" ]]; then
    ss_wget "${TMP_SS_PUSH_STAGING}" "${GITLAB_SS_PUSH_STAGING}"
fi

## ss-reboot-machine ##
ss_wget "${TMP_SS_REBOOT_MACHINE}" "${GITHUB_SS_REBOOT_MACHINE}"
VALIDATE_TMP_SS_REBOOT_MACHINE=$(grep 'SS_EOF' "${TMP_SS_REBOOT_MACHINE}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_REBOOT_MACHINE}" ]]; then
    ss_wget "${TMP_SS_REBOOT_MACHINE}" "${GITLAB_SS_REBOOT_MACHINE}"
fi

## ss-remote-backup ##
ss_wget "${TMP_SS_REMOTE_BACKUP}" "${GITHUB_SS_REMOTE_BACKUP}"
VALIDATE_TMP_SS_REMOTE_BACKUP=$(grep 'SS_EOF' "${TMP_SS_REMOTE_BACKUP}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_REMOTE_BACKUP}" ]]; then
    ss_wget "${TMP_SS_REMOTE_BACKUP}" "${GITLAB_SS_REMOTE_BACKUP}"
fi

## ss-reset-password-sftp ##
ss_wget "${TMP_SS_RESET_PASSWORD_SFTP}" "${GITHUB_SS_RESET_PASSWORD_SFTP}"
VALIDATE_TMP_SS_RESET_PASSWORD_SFTP=$(grep 'SS_EOF' "${TMP_SS_RESET_PASSWORD_SFTP}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_RESET_PASSWORD_SFTP}" ]]; then
    ss_wget "${TMP_SS_RESET_PASSWORD_SFTP}" "${GITLAB_SS_RESET_PASSWORD_SFTP}"
fi

## ss-restart-memcached ##
ss_wget "${TMP_SS_RESTART_MEMCACHED}" "${GITHUB_SS_RESTART_MEMCACHED}"
VALIDATE_TMP_SS_RESTART_MEMCACHED=$(grep 'SS_EOF' "${TMP_SS_RESTART_MEMCACHED}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_RESTART_MEMCACHED}" ]]; then
    ss_wget "${TMP_SS_RESTART_MEMCACHED}" "${GITLAB_SS_RESTART_MEMCACHED}"
fi

## ss-restart-mysql ##
ss_wget "${TMP_SS_RESTART_MYSQL}" "${GITHUB_SS_RESTART_MYSQL}"
VALIDATE_TMP_SS_RESTART_MYSQL=$(grep 'SS_EOF' "${TMP_SS_RESTART_MYSQL}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_RESTART_MYSQL}" ]]; then
    ss_wget "${TMP_SS_RESTART_MYSQL}" "${GITLAB_SS_RESTART_MYSQL}"
fi

## ss-restart-nginx ##
ss_wget "${TMP_SS_RESTART_NGINX}" "${GITHUB_SS_RESTART_NGINX}"
VALIDATE_TMP_SS_RESTART_NGINX=$(grep 'SS_EOF' "${TMP_SS_RESTART_NGINX}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_RESTART_NGINX}" ]]; then
    ss_wget "${TMP_SS_RESTART_NGINX}" "${GITLAB_SS_RESTART_NGINX}"
fi

## ss-restart-php ##
ss_wget "${TMP_SS_RESTART_PHP}" "${GITHUB_SS_RESTART_PHP}"
VALIDATE_TMP_SS_RESTART_PHP=$(grep 'SS_EOF' "${TMP_SS_RESTART_PHP}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_RESTART_PHP}" ]]; then
    ss_wget "${TMP_SS_RESTART_PHP}" "${GITLAB_SS_RESTART_PHP}"
fi

## ss-restart-ufw ##
ss_wget "${TMP_SS_RESTART_UFW}" "${GITHUB_SS_RESTART_UFW}"
VALIDATE_TMP_SS_RESTART_UFW=$(grep 'SS_EOF' "${TMP_SS_RESTART_UFW}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_RESTART_UFW}" ]]; then
    ss_wget "${TMP_SS_RESTART_UFW}" "${GITLAB_SS_RESTART_UFW}"
fi

## ss-stack-overview ##
ss_wget "${TMP_SS_STACK_OVERVIEW}" "${GITHUB_SS_STACK_OVERVIEW}"
VALIDATE_TMP_SS_STACK_OVERVIEW=$(grep 'SS_EOF' "${TMP_SS_STACK_OVERVIEW}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_STACK_OVERVIEW}" ]]; then
    ss_wget "${TMP_SS_STACK_OVERVIEW}" "${GITLAB_SS_STACK_OVERVIEW}"
fi

## ss-sync-development ##
ss_wget "${TMP_SS_SYNC_DEVELOPMENT}" "${GITHUB_SS_SYNC_DEVELOPMENT}"
VALIDATE_TMP_SS_SYNC_DEVELOPMENT=$(grep 'SS_EOF' "${TMP_SS_SYNC_DEVELOPMENT}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_SYNC_DEVELOPMENT}" ]]; then
    ss_wget "${TMP_SS_SYNC_DEVELOPMENT}" "${GITLAB_SS_SYNC_DEVELOPMENT}"
fi

## ss-sync-staging ##
ss_wget "${TMP_SS_SYNC_STAGING}" "${GITHUB_SS_SYNC_STAGING}"
VALIDATE_TMP_SS_SYNC_STAGING=$(grep 'SS_EOF' "${TMP_SS_SYNC_STAGING}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_SYNC_STAGING}" ]]; then
    ss_wget "${TMP_SS_SYNC_STAGING}" "${GITLAB_SS_SYNC_STAGING}"
fi

## ss-update-config ##
ss_wget "${TMP_SS_UPDATE_CONFIG}" "${GITHUB_SS_UPDATE_CONFIG}"
VALIDATE_TMP_SS_UPDATE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_UPDATE_CONFIG}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_UPDATE_CONFIG}" ]]; then
    ss_wget "${TMP_SS_UPDATE_CONFIG}" "${GITLAB_SS_UPDATE_CONFIG}"
fi

## ss-update-modules ##
ss_wget "${TMP_SS_UPDATE_MODULES}" "${GITHUB_SS_UPDATE_MODULES}"
VALIDATE_TMP_SS_UPDATE_MODULES=$(grep 'SS_EOF' "${TMP_SS_UPDATE_MODULES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_UPDATE_MODULES}" ]]; then
    ss_wget "${TMP_SS_UPDATE_MODULES}" "${GITLAB_SS_UPDATE_MODULES}"
fi

## ss-worker ##
ss_wget "${TMP_SS_WORKER}" "${GITHUB_SS_WORKER}"
VALIDATE_TMP_SS_WORKER=$(grep 'SS_EOF' "${TMP_SS_WORKER}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_SS_WORKER}" ]]; then
    ss_wget "${TMP_SS_WORKER}" "${GITLAB_SS_WORKER}"
fi

####################################################################################################
#### F. SS-Check: Install Cron Jobs ################################################################
####################################################################################################

## here we install all the downloaded cron job files to their permanent location paths ##
## the root crontab will run the cron jobs which in turn run the bash scripts ##

## 00-crontab ##
VALIDATE2_TMP_00_CRONTAB=$(grep 'SS_EOF' "${TMP_00_CRONTAB}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_00_CRONTAB}" ]]; then
    ss_mv "${TMP_00_CRONTAB}" "${PATH_00_CRONTAB}"
fi

## 01-cron-minutely ##
VALIDATE2_TMP_01_CRON_MINUTELY=$(grep 'SS_EOF' "${TMP_01_CRON_MINUTELY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_01_CRON_MINUTELY}" ]]; then
    ss_mv "${TMP_01_CRON_MINUTELY}" "${PATH_01_CRON_MINUTELY}"
fi

## 02-cron-often ##
VALIDATE2_TMP_02_CRON_OFTEN=$(grep 'SS_EOF' "${TMP_02_CRON_OFTEN}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_02_CRON_OFTEN}" ]]; then
    ss_mv "${TMP_02_CRON_OFTEN}" "${PATH_02_CRON_OFTEN}"
fi

## 03-cron-regular ##
VALIDATE2_TMP_03_CRON_REGULAR=$(grep 'SS_EOF' "${TMP_03_CRON_REGULAR}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_03_CRON_REGULAR}" ]]; then
    ss_mv "${TMP_03_CRON_REGULAR}" "${PATH_03_CRON_REGULAR}"
fi

## 04-cron-quarter-hourly ##
VALIDATE2_TMP_04_CRON_QUARTER_HOURLY=$(grep 'SS_EOF' "${TMP_04_CRON_QUARTER_HOURLY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_04_CRON_QUARTER_HOURLY}" ]]; then
    ss_mv "${TMP_04_CRON_QUARTER_HOURLY}" "${PATH_04_CRON_QUARTER_HOURLY}"
fi

## 05-cron-half-hourly ##
VALIDATE2_TMP_05_CRON_HALF_HOURLY=$(grep 'SS_EOF' "${TMP_05_CRON_HALF_HOURLY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_05_CRON_HALF_HOURLY}" ]]; then
    ss_mv "${TMP_05_CRON_HALF_HOURLY}" "${PATH_05_CRON_HALF_HOURLY}"
fi

## 06-cron-hourly ##
VALIDATE2_TMP_06_CRON_HOURLY=$(grep 'SS_EOF' "${TMP_06_CRON_HOURLY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_06_CRON_HOURLY}" ]]; then
    ss_mv "${TMP_06_CRON_HOURLY}" "${PATH_06_CRON_HOURLY}"
fi

## 07-cron-quarter-daily ##
VALIDATE2_TMP_07_CRON_QUARTER_DAILY=$(grep 'SS_EOF' "${TMP_07_CRON_QUARTER_DAILY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_07_CRON_QUARTER_DAILY}" ]]; then
    ss_mv "${TMP_07_CRON_QUARTER_DAILY}" "${PATH_07_CRON_QUARTER_DAILY}"
fi

## 08-cron-half-daily ##
VALIDATE2_TMP_08_CRON_HALF_DAILY=$(grep 'SS_EOF' "${TMP_08_CRON_HALF_DAILY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_08_CRON_HALF_DAILY}" ]]; then
    ss_mv "${TMP_08_CRON_HALF_DAILY}" "${PATH_08_CRON_HALF_DAILY}"
fi

## 09-cron-daily ##
VALIDATE2_TMP_09_CRON_DAILY=$(grep 'SS_EOF' "${TMP_09_CRON_DAILY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_09_CRON_DAILY}" ]]; then
    ss_mv "${TMP_09_CRON_DAILY}" "${PATH_09_CRON_DAILY}"
fi

## 10-cron-half-weekly ##
VALIDATE2_TMP_10_CRON_HALF_WEEKLY=$(grep 'SS_EOF' "${TMP_10_CRON_HALF_WEEKLY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_10_CRON_HALF_WEEKLY}" ]]; then
    ss_mv "${TMP_10_CRON_HALF_WEEKLY}" "${PATH_10_CRON_HALF_WEEKLY}"
fi

## 11-cron-weekly ##
VALIDATE2_TMP_11_CRON_WEEKLY=$(grep 'SS_EOF' "${TMP_11_CRON_WEEKLY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_11_CRON_WEEKLY}" ]]; then
    ss_mv "${TMP_11_CRON_WEEKLY}" "${PATH_11_CRON_WEEKLY}"
fi

## 12-cron-half-monthly ##
VALIDATE2_TMP_12_CRON_HALF_MONTHLY=$(grep 'SS_EOF' "${TMP_12_CRON_HALF_MONTHLY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_12_CRON_HALF_MONTHLY}" ]]; then
    ss_mv "${TMP_12_CRON_HALF_MONTHLY}" "${PATH_12_CRON_HALF_MONTHLY}"
fi

## 13-cron-monthly ##
VALIDATE2_TMP_13_CRON_MONTHLY=$(grep 'SS_EOF' "${TMP_13_CRON_MONTHLY}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_13_CRON_MONTHLY}" ]]; then
    ss_mv "${TMP_13_CRON_MONTHLY}" "${PATH_13_CRON_MONTHLY}"
fi

## 14-cron-sometimes ##
VALIDATE2_TMP_14_CRON_SOMETIMES=$(grep 'SS_EOF' "${TMP_14_CRON_SOMETIMES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_14_CRON_SOMETIMES}" ]]; then
    ss_mv "${TMP_14_CRON_SOMETIMES}" "${PATH_14_CRON_SOMETIMES}"
fi

####################################################################################################
#### G. SS-Check: Install Custom Cron Job Boilerplates (If Not Exist) ##############################
####################################################################################################

## here we install boilerplates for custom cron jobs if none are found on your server ##
## you can then edit these files as needed and they will never be overwritten ##

## 01-cron-minutely-custom ##
VALIDATE2_TMP_01_CRON_MINUTELY_CUSTOM=$(grep 'SS_EOF' "${TMP_01_CRON_MINUTELY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_01_CRON_MINUTELY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_01_CRON_MINUTELY_CUSTOM}" "${PATH_01_CRON_MINUTELY_CUSTOM}"
fi

## 02-cron-often-custom ##
VALIDATE2_TMP_02_CRON_OFTEN_CUSTOM=$(grep 'SS_EOF' "${TMP_02_CRON_OFTEN_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_02_CRON_OFTEN_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_02_CRON_OFTEN_CUSTOM}" "${PATH_02_CRON_OFTEN_CUSTOM}"
fi

## 03-cron-regular-custom ##
VALIDATE2_TMP_03_CRON_REGULAR_CUSTOM=$(grep 'SS_EOF' "${TMP_03_CRON_REGULAR_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_03_CRON_REGULAR_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_03_CRON_REGULAR_CUSTOM}" "${PATH_03_CRON_REGULAR_CUSTOM}"
fi

## 04-cron-quarter-hourly-custom ##
VALIDATE2_TMP_04_CRON_QUARTER_HOURLY_CUSTOM=$(grep 'SS_EOF' "${TMP_04_CRON_QUARTER_HOURLY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_04_CRON_QUARTER_HOURLY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_04_CRON_QUARTER_HOURLY_CUSTOM}" "${PATH_04_CRON_QUARTER_HOURLY_CUSTOM}"
fi

## 05-cron-half-hourly-custom ##
VALIDATE2_TMP_05_CRON_HALF_HOURLY_CUSTOM=$(grep 'SS_EOF' "${TMP_05_CRON_HALF_HOURLY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_05_CRON_HALF_HOURLY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_05_CRON_HALF_HOURLY_CUSTOM}" "${PATH_05_CRON_HALF_HOURLY_CUSTOM}"
fi

## 06-cron-hourly-custom ##
VALIDATE2_TMP_06_CRON_HOURLY_CUSTOM=$(grep 'SS_EOF' "${TMP_06_CRON_HOURLY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_06_CRON_HOURLY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_06_CRON_HOURLY_CUSTOM}" "${PATH_06_CRON_HOURLY_CUSTOM}"
fi

## 07-cron-quarter-daily-custom ##
VALIDATE2_TMP_07_CRON_QUARTER_DAILY_CUSTOM=$(grep 'SS_EOF' "${TMP_07_CRON_QUARTER_DAILY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_07_CRON_QUARTER_DAILY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_07_CRON_QUARTER_DAILY_CUSTOM}" "${PATH_07_CRON_QUARTER_DAILY_CUSTOM}"
fi

## 08-cron-half-daily-custom ##
VALIDATE2_TMP_08_CRON_HALF_DAILY_CUSTOM=$(grep 'SS_EOF' "${TMP_08_CRON_HALF_DAILY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_08_CRON_HALF_DAILY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_08_CRON_HALF_DAILY_CUSTOM}" "${PATH_08_CRON_HALF_DAILY_CUSTOM}"
fi

## 09-cron-daily-custom ##
VALIDATE2_TMP_09_CRON_DAILY_CUSTOM=$(grep 'SS_EOF' "${TMP_09_CRON_DAILY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_09_CRON_DAILY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_09_CRON_DAILY_CUSTOM}" "${PATH_09_CRON_DAILY_CUSTOM}"
fi

## 10-cron-half-weekly-custom ##
VALIDATE2_TMP_10_CRON_HALF_WEEKLY_CUSTOM=$(grep 'SS_EOF' "${TMP_10_CRON_HALF_WEEKLY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_10_CRON_HALF_WEEKLY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_10_CRON_HALF_WEEKLY_CUSTOM}" "${PATH_10_CRON_HALF_WEEKLY_CUSTOM}"
fi

## 11-cron-weekly-custom ##
VALIDATE2_TMP_11_CRON_WEEKLY_CUSTOM=$(grep 'SS_EOF' "${TMP_11_CRON_WEEKLY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_11_CRON_WEEKLY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_11_CRON_WEEKLY_CUSTOM}" "${PATH_11_CRON_WEEKLY_CUSTOM}"
fi

## 12-cron-half-monthly-custom ##
VALIDATE2_TMP_12_CRON_HALF_MONTHLY_CUSTOM=$(grep 'SS_EOF' "${TMP_12_CRON_HALF_MONTHLY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_12_CRON_HALF_MONTHLY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_12_CRON_HALF_MONTHLY_CUSTOM}" "${PATH_12_CRON_HALF_MONTHLY_CUSTOM}"
fi

## 13-cron-monthly-custom ##
VALIDATE2_TMP_13_CRON_MONTHLY_CUSTOM=$(grep 'SS_EOF' "${TMP_13_CRON_MONTHLY_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_13_CRON_MONTHLY_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_13_CRON_MONTHLY_CUSTOM}" "${PATH_13_CRON_MONTHLY_CUSTOM}"
fi

## 14-cron-sometimes-custom ##
VALIDATE2_TMP_14_CRON_SOMETIMES_CUSTOM=$(grep 'SS_EOF' "${TMP_14_CRON_SOMETIMES_CUSTOM}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_14_CRON_SOMETIMES_CUSTOM}" ]]; then
    ss_cp_if_not_exists "${TMP_14_CRON_SOMETIMES_CUSTOM}" "${PATH_14_CRON_SOMETIMES_CUSTOM}"
fi

####################################################################################################
#### H. SS-Check: Install Bash Scripts (Except SS-Check) ###########################################
####################################################################################################

## here we install all the downloaded bash scripts to their permanent location paths ##
## the root crontab will run the cron jobs which in turn run the bash scripts ##

## ss-clean-database ##
VALIDATE2_TMP_SS_CLEAN_DATABASE=$(grep 'SS_EOF' "${TMP_SS_CLEAN_DATABASE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_CLEAN_DATABASE}" ]]; then
    ss_mv "${TMP_SS_CLEAN_DATABASE}" "${PATH_SS_CLEAN_DATABASE}"
fi

## ss-clean-files ##
VALIDATE2_TMP_SS_CLEAN_FILES=$(grep 'SS_EOF' "${TMP_SS_CLEAN_FILES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_CLEAN_FILES}" ]]; then
    ss_mv "${TMP_SS_CLEAN_FILES}" "${PATH_SS_CLEAN_FILES}"
fi

## ss-config-sample ##
VALIDATE2_TMP_SS_CONFIG_SAMPLE=$(grep 'SS_EOF' "${TMP_SS_CONFIG_SAMPLE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_CONFIG_SAMPLE}" ]]; then
    ss_mv "${TMP_SS_CONFIG_SAMPLE}" "${PATH_SS_CONFIG_SAMPLE}"
fi

## ss-delete-database ##
VALIDATE2_TMP_SS_DELETE_DATABASE=$(grep 'SS_EOF' "${TMP_SS_DELETE_DATABASE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_DELETE_DATABASE}" ]]; then
    ss_mv "${TMP_SS_DELETE_DATABASE}" "${PATH_SS_DELETE_DATABASE}"
fi

## ss-delete-files ##
VALIDATE2_TMP_SS_DELETE_FILES=$(grep 'SS_EOF' "${TMP_SS_DELETE_FILES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_DELETE_FILES}" ]]; then
    ss_mv "${TMP_SS_DELETE_FILES}" "${PATH_SS_DELETE_FILES}"
fi

## ss-dump-database ##
VALIDATE2_TMP_SS_DUMP_DATABASE=$(grep 'SS_EOF' "${TMP_SS_DUMP_DATABASE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_DUMP_DATABASE}" ]]; then
    ss_mv "${TMP_SS_DUMP_DATABASE}" "${PATH_SS_DUMP_DATABASE}"
fi

## ss-dump-files ##
VALIDATE2_TMP_SS_DUMP_FILES=$(grep 'SS_EOF' "${TMP_SS_DUMP_FILES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_DUMP_FILES}" ]]; then
    ss_mv "${TMP_SS_DUMP_FILES}" "${PATH_SS_DUMP_FILES}"
fi

## ss-empty-logs ##
VALIDATE2_TMP_SS_EMPTY_LOGS=$(grep 'SS_EOF' "${TMP_SS_EMPTY_LOGS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_EMPTY_LOGS}" ]]; then
    ss_mv "${TMP_SS_EMPTY_LOGS}" "${PATH_SS_EMPTY_LOGS}"
fi

## ss-encrypt-acme ##
VALIDATE2_TMP_SS_ENCRYPT_ACME=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_ACME}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_ENCRYPT_ACME}" ]]; then
    ss_mv "${TMP_SS_ENCRYPT_ACME}" "${PATH_SS_ENCRYPT_ACME}"
fi

## ss-encrypt-certbot ##
VALIDATE2_TMP_SS_ENCRYPT_CERTBOT=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_CERTBOT}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_ENCRYPT_CERTBOT}" ]]; then
    ss_mv "${TMP_SS_ENCRYPT_CERTBOT}" "${PATH_SS_ENCRYPT_CERTBOT}"
fi

## ss-encrypt-openssl ##
VALIDATE2_TMP_SS_ENCRYPT_OPENSSL=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_OPENSSL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_ENCRYPT_OPENSSL}" ]]; then
    ss_mv "${TMP_SS_ENCRYPT_OPENSSL}" "${PATH_SS_ENCRYPT_OPENSSL}"
fi

## ss-functions ##
VALIDATE2_TMP_SS_FUNCTIONS=$(grep 'SS_EOF' "${TMP_SS_FUNCTIONS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_FUNCTIONS}" ]]; then
    ss_mv "${TMP_SS_FUNCTIONS}" "${PATH_SS_FUNCTIONS}"
fi

## ss-import-database ##
VALIDATE2_TMP_SS_IMPORT_DATABASE=$(grep 'SS_EOF' "${TMP_SS_IMPORT_DATABASE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_IMPORT_DATABASE}" ]]; then
    ss_mv "${TMP_SS_IMPORT_DATABASE}" "${PATH_SS_IMPORT_DATABASE}"
fi

## ss-import-files ##
VALIDATE2_TMP_SS_IMPORT_FILES=$(grep 'SS_EOF' "${TMP_SS_IMPORT_FILES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_IMPORT_FILES}" ]]; then
    ss_mv "${TMP_SS_IMPORT_FILES}" "${PATH_SS_IMPORT_FILES}"
fi

## ss-install ##
VALIDATE2_TMP_SS_INSTALL=$(grep 'SS_EOF' "${TMP_SS_INSTALL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL}" ]]; then
    ss_mv "${TMP_SS_INSTALL}" "${PATH_SS_INSTALL}"
fi

## ss-install-adminer ##
VALIDATE2_TMP_SS_INSTALL_ADMINER=$(grep 'SS_EOF' "${TMP_SS_INSTALL_ADMINER}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_ADMINER}" ]]; then
    ss_mv "${TMP_SS_INSTALL_ADMINER}" "${PATH_SS_INSTALL_ADMINER}"
fi

## ss-install-craft-config ##
VALIDATE2_TMP_SS_INSTALL_CRAFT_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_CRAFT_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_CRAFT_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_CRAFT_CONFIG}" "${PATH_SS_INSTALL_CRAFT_CONFIG}"
fi

## ss-install-craft-packages ##
VALIDATE2_TMP_SS_INSTALL_CRAFT_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_CRAFT_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_CRAFT_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_CRAFT_PACKAGES}" "${PATH_SS_INSTALL_CRAFT_PACKAGES}"
fi

## ss-install-mediawiki-config ##
VALIDATE2_TMP_SS_INSTALL_MEDIAWIKI_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" "${PATH_SS_INSTALL_MEDIAWIKI_CONFIG}"
fi

## ss-install-mediawiki-packages ##
VALIDATE2_TMP_SS_INSTALL_MEDIAWIKI_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEDIAWIKI_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MEDIAWIKI_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MEDIAWIKI_PACKAGES}" "${PATH_SS_INSTALL_MEDIAWIKI_PACKAGES}"
fi

## ss-install-memcached-config ##
VALIDATE2_TMP_SS_INSTALL_MEMCACHED_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEMCACHED_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MEMCACHED_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MEMCACHED_CONFIG}" "${PATH_SS_INSTALL_MEMCACHED_CONFIG}"
fi

## ss-install-memcached-packages ##
VALIDATE2_TMP_SS_INSTALL_MEMCACHED_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEMCACHED_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MEMCACHED_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MEMCACHED_PACKAGES}" "${PATH_SS_INSTALL_MEMCACHED_PACKAGES}"
fi

## ss-install-moodle-config ##
VALIDATE2_TMP_SS_INSTALL_MOODLE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MOODLE_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MOODLE_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MOODLE_CONFIG}" "${PATH_SS_INSTALL_MOODLE_CONFIG}"
fi

## ss-install-moodle-packages ##
VALIDATE2_TMP_SS_INSTALL_MOODLE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MOODLE_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MOODLE_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MOODLE_PACKAGES}" "${PATH_SS_INSTALL_MOODLE_PACKAGES}"
fi

## ss-install-mysql-config ##
VALIDATE2_TMP_SS_INSTALL_MYSQL_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MYSQL_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MYSQL_CONFIG}" "${PATH_SS_INSTALL_MYSQL_CONFIG}"
fi

## ss-install-mysql-database ##
VALIDATE2_TMP_SS_INSTALL_MYSQL_DATABASE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_DATABASE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MYSQL_DATABASE}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MYSQL_DATABASE}" "${PATH_SS_INSTALL_MYSQL_DATABASE}"
fi

## ss-install-mysql-packages ##
VALIDATE2_TMP_SS_INSTALL_MYSQL_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_MYSQL_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_MYSQL_PACKAGES}" "${PATH_SS_INSTALL_MYSQL_PACKAGES}"
fi

## ss-install-nginx-config ##
VALIDATE2_TMP_SS_INSTALL_NGINX_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_NGINX_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_NGINX_CONFIG}" "${PATH_SS_INSTALL_NGINX_CONFIG}"
fi

## ss-install-nginx-letsencrypt ##
VALIDATE2_TMP_SS_INSTALL_NGINX_LETSENCRYPT=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_LETSENCRYPT}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_NGINX_LETSENCRYPT}" ]]; then
    ss_mv "${TMP_SS_INSTALL_NGINX_LETSENCRYPT}" "${PATH_SS_INSTALL_NGINX_LETSENCRYPT}"
fi

## ss-install-nginx-openssl ##
VALIDATE2_TMP_SS_INSTALL_NGINX_OPENSSL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_OPENSSL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_NGINX_OPENSSL}" ]]; then
    ss_mv "${TMP_SS_INSTALL_NGINX_OPENSSL}" "${PATH_SS_INSTALL_NGINX_OPENSSL}"
fi

## ss-install-nginx-packages ##
VALIDATE2_TMP_SS_INSTALL_NGINX_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_NGINX_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_NGINX_PACKAGES}" "${PATH_SS_INSTALL_NGINX_PACKAGES}"
fi

## ss-install-nginx-ssl ##
VALIDATE2_TMP_SS_INSTALL_NGINX_SSL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_SSL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_NGINX_SSL}" ]]; then
    ss_mv "${TMP_SS_INSTALL_NGINX_SSL}" "${PATH_SS_INSTALL_NGINX_SSL}"
fi

## ss-install-opencart-config ##
VALIDATE2_TMP_SS_INSTALL_OPENCART_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_OPENCART_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_OPENCART_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_OPENCART_CONFIG}" "${PATH_SS_INSTALL_OPENCART_CONFIG}"
fi

## ss-install-opencart-packages ##
VALIDATE2_TMP_SS_INSTALL_OPENCART_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_OPENCART_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_OPENCART_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_OPENCART_PACKAGES}" "${PATH_SS_INSTALL_OPENCART_PACKAGES}"
fi

## ss-install-php-config ##
VALIDATE2_TMP_SS_INSTALL_PHP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PHP_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_PHP_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_PHP_CONFIG}" "${PATH_SS_INSTALL_PHP_CONFIG}"
fi

## ss-install-php-packages ##
VALIDATE2_TMP_SS_INSTALL_PHP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PHP_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_PHP_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_PHP_PACKAGES}" "${PATH_SS_INSTALL_PHP_PACKAGES}"
fi

## ss-install-prestashop-config ##
VALIDATE2_TMP_SS_INSTALL_PRESTASHOP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PRESTASHOP_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_PRESTASHOP_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_PRESTASHOP_CONFIG}" "${PATH_SS_INSTALL_PRESTASHOP_CONFIG}"
fi

## ss-install-prestashop-packages ##
VALIDATE2_TMP_SS_INSTALL_PRESTASHOP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PRESTASHOP_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_PRESTASHOP_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_PRESTASHOP_PACKAGES}" "${PATH_SS_INSTALL_PRESTASHOP_PACKAGES}"
fi

## ss-install-rclone-config ##
VALIDATE2_TMP_SS_INSTALL_RCLONE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_RCLONE_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_RCLONE_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_RCLONE_CONFIG}" "${PATH_SS_INSTALL_RCLONE_CONFIG}"
fi

## ss-install-rclone-packages ##
VALIDATE2_TMP_SS_INSTALL_RCLONE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_RCLONE_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_RCLONE_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_RCLONE_PACKAGES}" "${PATH_SS_INSTALL_RCLONE_PACKAGES}"
fi

## ss-install-ubuntu-bash ##
VALIDATE2_TMP_SS_INSTALL_UBUNTU_BASH=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_BASH}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UBUNTU_BASH}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UBUNTU_BASH}" "${PATH_SS_INSTALL_UBUNTU_BASH}"
fi

## ss-install-ubuntu-crontab ##
VALIDATE2_TMP_SS_INSTALL_UBUNTU_CRONTAB=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_CRONTAB}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UBUNTU_CRONTAB}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UBUNTU_CRONTAB}" "${PATH_SS_INSTALL_UBUNTU_CRONTAB}"
fi

## ss-install-ubuntu-kernel ##
VALIDATE2_TMP_SS_INSTALL_UBUNTU_KERNEL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_KERNEL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UBUNTU_KERNEL}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UBUNTU_KERNEL}" "${PATH_SS_INSTALL_UBUNTU_KERNEL}"
fi

## ss-install-ubuntu-ssh ##
VALIDATE2_TMP_SS_INSTALL_UBUNTU_SSH=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_SSH}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UBUNTU_SSH}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UBUNTU_SSH}" "${PATH_SS_INSTALL_UBUNTU_SSH}"
fi

## ss-install-ubuntu-swapfile ##
VALIDATE2_TMP_SS_INSTALL_UBUNTU_SWAPFILE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_SWAPFILE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UBUNTU_SWAPFILE}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UBUNTU_SWAPFILE}" "${PATH_SS_INSTALL_UBUNTU_SWAPFILE}"
fi

## ss-install-ubuntu-users ##
VALIDATE2_TMP_SS_INSTALL_UBUNTU_USERS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_USERS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UBUNTU_USERS}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UBUNTU_USERS}" "${PATH_SS_INSTALL_UBUNTU_USERS}"
fi

## ss-install-ubuntu-utils ##
VALIDATE2_TMP_SS_INSTALL_UBUNTU_UTILS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_UTILS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UBUNTU_UTILS}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UBUNTU_UTILS}" "${PATH_SS_INSTALL_UBUNTU_UTILS}"
fi

## ss-install-ufw-config ##
VALIDATE2_TMP_SS_INSTALL_UFW_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UFW_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UFW_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UFW_CONFIG}" "${PATH_SS_INSTALL_UFW_CONFIG}"
fi

## ss-install-ufw-packages ##
VALIDATE2_TMP_SS_INSTALL_UFW_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UFW_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_UFW_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_UFW_PACKAGES}" "${PATH_SS_INSTALL_UFW_PACKAGES}"
fi

## ss-install-wordpress-cli ##
VALIDATE2_TMP_SS_INSTALL_WORDPRESS_CLI=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_CLI}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_WORDPRESS_CLI}" ]]; then
    ss_mv "${TMP_SS_INSTALL_WORDPRESS_CLI}" "${PATH_SS_INSTALL_WORDPRESS_CLI}"
fi

## ss-install-wordpress-config ##
VALIDATE2_TMP_SS_INSTALL_WORDPRESS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_WORDPRESS_CONFIG}" ]]; then
    ss_mv "${TMP_SS_INSTALL_WORDPRESS_CONFIG}" "${PATH_SS_INSTALL_WORDPRESS_CONFIG}"
fi

## ss-install-wordpress-mu-plugins ##
VALIDATE2_TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" ]]; then
    ss_mv "${TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" "${PATH_SS_INSTALL_WORDPRESS_MU_PLUGINS}"
fi

## ss-install-wordpress-packages ##
VALIDATE2_TMP_SS_INSTALL_WORDPRESS_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_INSTALL_WORDPRESS_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_INSTALL_WORDPRESS_PACKAGES}" "${PATH_SS_INSTALL_WORDPRESS_PACKAGES}"
fi

## ss-maintenance-disable ##
VALIDATE2_TMP_SS_MAINTENANCE_DISABLE=$(grep 'SS_EOF' "${TMP_SS_MAINTENANCE_DISABLE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_MAINTENANCE_DISABLE}" ]]; then
    ss_mv "${TMP_SS_MAINTENANCE_DISABLE}" "${PATH_SS_MAINTENANCE_DISABLE}"
fi

## ss-maintenance-enable ##
VALIDATE2_TMP_SS_MAINTENANCE_ENABLE=$(grep 'SS_EOF' "${TMP_SS_MAINTENANCE_ENABLE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_MAINTENANCE_ENABLE}" ]]; then
    ss_mv "${TMP_SS_MAINTENANCE_ENABLE}" "${PATH_SS_MAINTENANCE_ENABLE}"
fi

## ss-monitor-resources ##
VALIDATE2_TMP_SS_MONITOR_RESOURCES=$(grep 'SS_EOF' "${TMP_SS_MONITOR_RESOURCES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_MONITOR_RESOURCES}" ]]; then
    ss_mv "${TMP_SS_MONITOR_RESOURCES}" "${PATH_SS_MONITOR_RESOURCES}"
fi

## ss-optimize-database ##
VALIDATE2_TMP_SS_OPTIMIZE_DATABASE=$(grep 'SS_EOF' "${TMP_SS_OPTIMIZE_DATABASE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_OPTIMIZE_DATABASE}" ]]; then
    ss_mv "${TMP_SS_OPTIMIZE_DATABASE}" "${PATH_SS_OPTIMIZE_DATABASE}"
fi

## ss-optimize-files ##
VALIDATE2_TMP_SS_OPTIMIZE_FILES=$(grep 'SS_EOF' "${TMP_SS_OPTIMIZE_FILES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_OPTIMIZE_FILES}" ]]; then
    ss_mv "${TMP_SS_OPTIMIZE_FILES}" "${PATH_SS_OPTIMIZE_FILES}"
fi

## ss-perms ##
VALIDATE2_TMP_SS_PERMS=$(grep 'SS_EOF' "${TMP_SS_PERMS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS}" ]]; then
    ss_mv "${TMP_SS_PERMS}" "${PATH_SS_PERMS}"
fi

## ss-perms-adminer ##
VALIDATE2_TMP_SS_PERMS_ADMINER=$(grep 'SS_EOF' "${TMP_SS_PERMS_ADMINER}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_ADMINER}" ]]; then
    ss_mv "${TMP_SS_PERMS_ADMINER}" "${PATH_SS_PERMS_ADMINER}"
fi

## ss-perms-craft-config ##
VALIDATE2_TMP_SS_PERMS_CRAFT_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_CRAFT_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_CRAFT_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_CRAFT_CONFIG}" "${PATH_SS_PERMS_CRAFT_CONFIG}"
fi

## ss-perms-craft-packages ##
VALIDATE2_TMP_SS_PERMS_CRAFT_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_CRAFT_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_CRAFT_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_CRAFT_PACKAGES}" "${PATH_SS_PERMS_CRAFT_PACKAGES}"
fi

## ss-perms-mediawiki-config ##
VALIDATE2_TMP_SS_PERMS_MEDIAWIKI_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEDIAWIKI_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MEDIAWIKI_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_MEDIAWIKI_CONFIG}" "${PATH_SS_PERMS_MEDIAWIKI_CONFIG}"
fi

## ss-perms-mediawiki-packages ##
VALIDATE2_TMP_SS_PERMS_MEDIAWIKI_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEDIAWIKI_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MEDIAWIKI_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_MEDIAWIKI_PACKAGES}" "${PATH_SS_PERMS_MEDIAWIKI_PACKAGES}"
fi

## ss-perms-memcached-config ##
VALIDATE2_TMP_SS_PERMS_MEMCACHED_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEMCACHED_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MEMCACHED_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_MEMCACHED_CONFIG}" "${PATH_SS_PERMS_MEMCACHED_CONFIG}"
fi

## ss-perms-memcached-packages ##
VALIDATE2_TMP_SS_PERMS_MEMCACHED_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEMCACHED_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MEMCACHED_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_MEMCACHED_PACKAGES}" "${PATH_SS_PERMS_MEMCACHED_PACKAGES}"
fi

## ss-perms-moodle-config ##
VALIDATE2_TMP_SS_PERMS_MOODLE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MOODLE_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MOODLE_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_MOODLE_CONFIG}" "${PATH_SS_PERMS_MOODLE_CONFIG}"
fi

## ss-perms-moodle-packages ##
VALIDATE2_TMP_SS_PERMS_MOODLE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MOODLE_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MOODLE_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_MOODLE_PACKAGES}" "${PATH_SS_PERMS_MOODLE_PACKAGES}"
fi

## ss-perms-mysql-config ##
VALIDATE2_TMP_SS_PERMS_MYSQL_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MYSQL_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_MYSQL_CONFIG}" "${PATH_SS_PERMS_MYSQL_CONFIG}"
fi

## ss-perms-mysql-database ##
VALIDATE2_TMP_SS_PERMS_MYSQL_DATABASE=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_DATABASE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MYSQL_DATABASE}" ]]; then
    ss_mv "${TMP_SS_PERMS_MYSQL_DATABASE}" "${PATH_SS_PERMS_MYSQL_DATABASE}"
fi

## ss-perms-mysql-packages ##
VALIDATE2_TMP_SS_PERMS_MYSQL_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_MYSQL_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_MYSQL_PACKAGES}" "${PATH_SS_PERMS_MYSQL_PACKAGES}"
fi

## ss-perms-nginx-config ##
VALIDATE2_TMP_SS_PERMS_NGINX_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_NGINX_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_NGINX_CONFIG}" "${PATH_SS_PERMS_NGINX_CONFIG}"
fi

## ss-perms-nginx-packages ##
VALIDATE2_TMP_SS_PERMS_NGINX_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_NGINX_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_NGINX_PACKAGES}" "${PATH_SS_PERMS_NGINX_PACKAGES}"
fi

## ss-perms-nginx-ssl ##
VALIDATE2_TMP_SS_PERMS_NGINX_SSL=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_SSL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_NGINX_SSL}" ]]; then
    ss_mv "${TMP_SS_PERMS_NGINX_SSL}" "${PATH_SS_PERMS_NGINX_SSL}"
fi

## ss-perms-opencart-config ##
VALIDATE2_TMP_SS_PERMS_OPENCART_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_OPENCART_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_OPENCART_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_OPENCART_CONFIG}" "${PATH_SS_PERMS_OPENCART_CONFIG}"
fi

## ss-perms-opencart-packages ##
VALIDATE2_TMP_SS_PERMS_OPENCART_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_OPENCART_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_OPENCART_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_OPENCART_PACKAGES}" "${PATH_SS_PERMS_OPENCART_PACKAGES}"
fi

## ss-perms-php-config ##
VALIDATE2_TMP_SS_PERMS_PHP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_PHP_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_PHP_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_PHP_CONFIG}" "${PATH_SS_PERMS_PHP_CONFIG}"
fi

## ss-perms-php-packages ##
VALIDATE2_TMP_SS_PERMS_PHP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_PHP_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_PHP_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_PHP_PACKAGES}" "${PATH_SS_PERMS_PHP_PACKAGES}"
fi

## ss-perms-prestashop-config ##
VALIDATE2_TMP_SS_PERMS_PRESTASHOP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_PRESTASHOP_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_PRESTASHOP_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_PRESTASHOP_CONFIG}" "${PATH_SS_PERMS_PRESTASHOP_CONFIG}"
fi

## ss-perms-prestashop-packages ##
VALIDATE2_TMP_SS_PERMS_PRESTASHOP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_PRESTASHOP_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_PRESTASHOP_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_PRESTASHOP_PACKAGES}" "${PATH_SS_PERMS_PRESTASHOP_PACKAGES}"
fi

## ss-perms-rclone-config ##
VALIDATE2_TMP_SS_PERMS_RCLONE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_RCLONE_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_RCLONE_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_RCLONE_CONFIG}" "${PATH_SS_PERMS_RCLONE_CONFIG}"
fi

## ss-perms-rclone-packages ##
VALIDATE2_TMP_SS_PERMS_RCLONE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_RCLONE_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_RCLONE_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_RCLONE_PACKAGES}" "${PATH_SS_PERMS_RCLONE_PACKAGES}"
fi

## ss-perms-ubuntu-bash ##
VALIDATE2_TMP_SS_PERMS_UBUNTU_BASH=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_BASH}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UBUNTU_BASH}" ]]; then
    ss_mv "${TMP_SS_PERMS_UBUNTU_BASH}" "${PATH_SS_PERMS_UBUNTU_BASH}"
fi

## ss-perms-ubuntu-crontab ##
VALIDATE2_TMP_SS_PERMS_UBUNTU_CRONTAB=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_CRONTAB}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UBUNTU_CRONTAB}" ]]; then
    ss_mv "${TMP_SS_PERMS_UBUNTU_CRONTAB}" "${PATH_SS_PERMS_UBUNTU_CRONTAB}"
fi

## ss-perms-ubuntu-kernel ##
VALIDATE2_TMP_SS_PERMS_UBUNTU_KERNEL=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_KERNEL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UBUNTU_KERNEL}" ]]; then
    ss_mv "${TMP_SS_PERMS_UBUNTU_KERNEL}" "${PATH_SS_PERMS_UBUNTU_KERNEL}"
fi

## ss-perms-ubuntu-ssh ##
VALIDATE2_TMP_SS_PERMS_UBUNTU_SSH=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_SSH}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UBUNTU_SSH}" ]]; then
    ss_mv "${TMP_SS_PERMS_UBUNTU_SSH}" "${PATH_SS_PERMS_UBUNTU_SSH}"
fi

## ss-perms-ubuntu-swapfile ##
VALIDATE2_TMP_SS_PERMS_UBUNTU_SWAPFILE=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_SWAPFILE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UBUNTU_SWAPFILE}" ]]; then
    ss_mv "${TMP_SS_PERMS_UBUNTU_SWAPFILE}" "${PATH_SS_PERMS_UBUNTU_SWAPFILE}"
fi

## ss-perms-ubuntu-users ##
VALIDATE2_TMP_SS_PERMS_UBUNTU_USERS=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_USERS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UBUNTU_USERS}" ]]; then
    ss_mv "${TMP_SS_PERMS_UBUNTU_USERS}" "${PATH_SS_PERMS_UBUNTU_USERS}"
fi

## ss-perms-ubuntu-utils ##
VALIDATE2_TMP_SS_PERMS_UBUNTU_UTILS=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_UTILS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UBUNTU_UTILS}" ]]; then
    ss_mv "${TMP_SS_PERMS_UBUNTU_UTILS}" "${PATH_SS_PERMS_UBUNTU_UTILS}"
fi

## ss-perms-ufw-config ##
VALIDATE2_TMP_SS_PERMS_UFW_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_UFW_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UFW_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_UFW_CONFIG}" "${PATH_SS_PERMS_UFW_CONFIG}"
fi

## ss-perms-ufw-packages ##
VALIDATE2_TMP_SS_PERMS_UFW_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_UFW_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_UFW_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_UFW_PACKAGES}" "${PATH_SS_PERMS_UFW_PACKAGES}"
fi

## ss-perms-wordpress-cli ##
VALIDATE2_TMP_SS_PERMS_WORDPRESS_CLI=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_CLI}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_WORDPRESS_CLI}" ]]; then
    ss_mv "${TMP_SS_PERMS_WORDPRESS_CLI}" "${PATH_SS_PERMS_WORDPRESS_CLI}"
fi

## ss-perms-wordpress-config ##
VALIDATE2_TMP_SS_PERMS_WORDPRESS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_WORDPRESS_CONFIG}" ]]; then
    ss_mv "${TMP_SS_PERMS_WORDPRESS_CONFIG}" "${PATH_SS_PERMS_WORDPRESS_CONFIG}"
fi

## ss-perms-wordpress-mu-plugins ##
VALIDATE2_TMP_SS_PERMS_WORDPRESS_MU_PLUGINS=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" ]]; then
    ss_mv "${TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" "${PATH_SS_PERMS_WORDPRESS_MU_PLUGINS}"
fi

## ss-perms-wordpress-packages ##
VALIDATE2_TMP_SS_PERMS_WORDPRESS_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_PACKAGES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PERMS_WORDPRESS_PACKAGES}" ]]; then
    ss_mv "${TMP_SS_PERMS_WORDPRESS_PACKAGES}" "${PATH_SS_PERMS_WORDPRESS_PACKAGES}"
fi

## ss-purge ##
VALIDATE2_TMP_SS_PURGE_NGINX=$(grep 'SS_EOF' "${TMP_SS_PURGE_NGINX}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PURGE_NGINX}" ]]; then
    ss_mv "${TMP_SS_PURGE_NGINX}" "${PATH_SS_PURGE_NGINX}"
fi

## ss-purge-opcache ##
VALIDATE2_TMP_SS_PURGE_OPCACHE=$(grep 'SS_EOF' "${TMP_SS_PURGE_OPCACHE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PURGE_OPCACHE}" ]]; then
    ss_mv "${TMP_SS_PURGE_OPCACHE}" "${PATH_SS_PURGE_OPCACHE}"
fi

## ss-purge-memcached ##
VALIDATE2_TMP_SS_PURGE_MEMCACHED=$(grep 'SS_EOF' "${TMP_SS_PURGE_MEMCACHED}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PURGE_MEMCACHED}" ]]; then
    ss_mv "${TMP_SS_PURGE_MEMCACHED}" "${PATH_SS_PURGE_MEMCACHED}"
fi

## ss-purge-transients ##
VALIDATE2_TMP_SS_PURGE_TRANSIENTS=$(grep 'SS_EOF' "${TMP_SS_PURGE_TRANSIENTS}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PURGE_TRANSIENTS}" ]]; then
    ss_mv "${TMP_SS_PURGE_TRANSIENTS}" "${PATH_SS_PURGE_TRANSIENTS}"
fi

## ss-push-development ##
VALIDATE2_TMP_SS_PUSH_DEVELOPMENT=$(grep 'SS_EOF' "${TMP_SS_PUSH_DEVELOPMENT}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PUSH_DEVELOPMENT}" ]]; then
    ss_mv "${TMP_SS_PUSH_DEVELOPMENT}" "${PATH_SS_PUSH_DEVELOPMENT}"
fi

## ss-push-staging ##
VALIDATE2_TMP_SS_PUSH_STAGING=$(grep 'SS_EOF' "${TMP_SS_PUSH_STAGING}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_PUSH_STAGING}" ]]; then
    ss_mv "${TMP_SS_PUSH_STAGING}" "${PATH_SS_PUSH_STAGING}"
fi

## ss-reboot-machine ##
VALIDATE2_TMP_SS_REBOOT_MACHINE=$(grep 'SS_EOF' "${TMP_SS_REBOOT_MACHINE}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_REBOOT_MACHINE}" ]]; then
    ss_mv "${TMP_SS_REBOOT_MACHINE}" "${PATH_SS_REBOOT_MACHINE}"
fi

## ss-remote-backup ##
VALIDATE2_TMP_SS_REMOTE_BACKUP=$(grep 'SS_EOF' "${TMP_SS_REMOTE_BACKUP}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_REMOTE_BACKUP}" ]]; then
    ss_mv "${TMP_SS_REMOTE_BACKUP}" "${PATH_SS_REMOTE_BACKUP}"
fi

## ss-reset-password-sftp ##
VALIDATE2_TMP_SS_RESET_PASSWORD_SFTP=$(grep 'SS_EOF' "${TMP_SS_RESET_PASSWORD_SFTP}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_RESET_PASSWORD_SFTP}" ]]; then
    ss_mv "${TMP_SS_RESET_PASSWORD_SFTP}" "${PATH_SS_RESET_PASSWORD_SFTP}"
fi

## ss-restart-memcached ##
VALIDATE2_TMP_SS_RESTART_MEMCACHED=$(grep 'SS_EOF' "${TMP_SS_RESTART_MEMCACHED}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_RESTART_MEMCACHED}" ]]; then
    ss_mv "${TMP_SS_RESTART_MEMCACHED}" "${PATH_SS_RESTART_MEMCACHED}"
fi

## ss-restart-mysql ##
VALIDATE2_TMP_SS_RESTART_MYSQL=$(grep 'SS_EOF' "${TMP_SS_RESTART_MYSQL}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_RESTART_MYSQL}" ]]; then
    ss_mv "${TMP_SS_RESTART_MYSQL}" "${PATH_SS_RESTART_MYSQL}"
fi

## ss-restart-nginx ##
VALIDATE2_TMP_SS_RESTART_NGINX=$(grep 'SS_EOF' "${TMP_SS_RESTART_NGINX}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_RESTART_NGINX}" ]]; then
    ss_mv "${TMP_SS_RESTART_NGINX}" "${PATH_SS_RESTART_NGINX}"
fi

## ss-restart-php ##
VALIDATE2_TMP_SS_RESTART_PHP=$(grep 'SS_EOF' "${TMP_SS_RESTART_PHP}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_RESTART_PHP}" ]]; then
    ss_mv "${TMP_SS_RESTART_PHP}" "${PATH_SS_RESTART_PHP}"
fi

## ss-restart-ufw ##
VALIDATE2_TMP_SS_RESTART_UFW=$(grep 'SS_EOF' "${TMP_SS_RESTART_UFW}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_RESTART_UFW}" ]]; then
    ss_mv "${TMP_SS_RESTART_UFW}" "${PATH_SS_RESTART_UFW}"
fi

## ss-stack-overview ##
VALIDATE2_TMP_SS_STACK_OVERVIEW=$(grep 'SS_EOF' "${TMP_SS_STACK_OVERVIEW}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_STACK_OVERVIEW}" ]]; then
    ss_mv "${TMP_SS_STACK_OVERVIEW}" "${PATH_SS_STACK_OVERVIEW}"
fi

## ss-sync-development ##
VALIDATE2_TMP_SS_SYNC_DEVELOPMENT=$(grep 'SS_EOF' "${TMP_SS_SYNC_DEVELOPMENT}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_SYNC_DEVELOPMENT}" ]]; then
    ss_mv "${TMP_SS_SYNC_DEVELOPMENT}" "${PATH_SS_SYNC_DEVELOPMENT}"
fi

## ss-sync-staging ##
VALIDATE2_TMP_SS_SYNC_STAGING=$(grep 'SS_EOF' "${TMP_SS_SYNC_STAGING}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_SYNC_STAGING}" ]]; then
    ss_mv "${TMP_SS_SYNC_STAGING}" "${PATH_SS_SYNC_STAGING}"
fi

## ss-update-config ##
VALIDATE2_TMP_SS_UPDATE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_UPDATE_CONFIG}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_UPDATE_CONFIG}" ]]; then
    ss_mv "${TMP_SS_UPDATE_CONFIG}" "${PATH_SS_UPDATE_CONFIG}"
fi

## ss-update-modules ##
VALIDATE2_TMP_SS_UPDATE_MODULES=$(grep 'SS_EOF' "${TMP_SS_UPDATE_MODULES}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_UPDATE_MODULES}" ]]; then
    ss_mv "${TMP_SS_UPDATE_MODULES}" "${PATH_SS_UPDATE_MODULES}"
fi

## ss-worker ##
VALIDATE2_TMP_SS_WORKER=$(grep 'SS_EOF' "${TMP_SS_WORKER}" 2> /dev/null)
if [[ -n "${VALIDATE2_TMP_SS_WORKER}" ]]; then
    ss_mv "${TMP_SS_WORKER}" "${PATH_SS_WORKER}"
fi

####################################################################################################
#### SlickStack: Reset Permissions (SlickStack Scripts) ############################################
####################################################################################################

## we include this permissions reset in all cron jobs and bash scripts for redundancy ##
## chmod 0700 means only the root/sudo users can execute any SlickStack scripts ##

## THIS SNIPPET DOES NOT RELY ON SS-CONFIG OR SS-FUNCTIONS
## SNIPPET: ss bash scripts, ss cron jobs
## UPDATED: 02JUL2022

chown root:root /var/www/ss* ## must be root:root
chown root:root /var/www/crons/*cron* ## must be root:root
chown root:root /var/www/crons/custom/*cron* ## must be root:root
chmod 0700 /var/www/ss* ## 0700 means only root/sudo can execute
chmod 0700 /var/www/crons/*cron* ## 0700 means only root/sudo can execute
chmod 0700 /var/www/crons/custom/*cron* ## 0700 means only root/sudo can execute

####################################################################################################
#### SlickStack: External References Used To Improve This Script (Thanks, Interwebz) ###############
####################################################################################################

## Ref: https://linuxize.com/post/bash-functions/
## Ref: https://stackoverflow.com/questions/6366530/bash-syntax-error-unexpected-end-of-file
## Ref: https://gist.github.com/onnimonni/b49779ebc96216771a6be3de46449fa1
## Ref: https://www.putorius.net/linux-checksum-file-integrity-check.html
## Ref: https://unix.stackexchange.com/questions/254868/use-md5sum-to-verify-file-in-a-script
## Ref: https://unix.stackexchange.com/questions/118085/transform-a-directory-into-file-or-a-file-into-directory

## SS_EOF