freedombone-app-pleroma

#!/bin/bash
#  _____               _           _
# |   __|___ ___ ___ _| |___ _____| |_ ___ ___ ___
# |   __|  _| -_| -_| . | . |     | . | . |   | -_|
# |__|  |_| |___|___|___|___|_|_|_|___|___|_|_|___|
#
#                              Freedom in the Cloud
#
# Pleroma backend application
#
# License
# =======
#
# Copyright (C) 2017-2018 Bob Mottram <bob@freedombone.net>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

VARIANTS='full full-vim social'

IN_DEFAULT_INSTALL=0
SHOW_ON_ABOUT=1

PLEROMA_DOMAIN_NAME=
PLEROMA_CODE=
PLEROMA_PORT=4000
PLEROMA_ONION_PORT=8011
PLEROMA_REPO="https://git.pleroma.social/pleroma/pleroma.git"
PLEROMA_COMMIT='4ad7531dc0ae3d27a53f41d77f9a30ac90bf09d5'
PLEROMA_ADMIN_PASSWORD=
PLEROMA_DIR=/etc/pleroma
PLEROMA_SECRET_KEY=""
pleroma_secret=$PLEROMA_DIR/config/dev.secret.exs

PLEROMA_BACKGROUND_IMAGE_URL=

PLEROMA_TITLE='Pleroma Server'

# Number of months after which posts expire
PLEROMA_EXPIRE_MONTHS=3
pleroma_expire_posts_script=/usr/bin/pleroma-expire-posts
blocking_script_file=/usr/bin/pleroma-blocking

PLEROMA_SHORT_DESCRIPTION=$'Federated microblogging'
PLEROMA_DESCRIPTION=$'Federated microblogging'
PLEROMA_MOBILE_APP_URL='https://f-droid.org/packages/com.keylesspalace.tusky'

pleroma_variables=(ONION_ONLY
                   PLEROMA_DOMAIN_NAME
                   PLEROMA_CODE
                   PLEROMA_WELCOME_MESSAGE
                   PLEROMA_BACKGROUND_IMAGE_URL
                   DDNS_PROVIDER
                   PLEROMA_TITLE
                   PLEROMA_EXPIRE_MONTHS
                   MY_EMAIL_ADDRESS
                   MY_USERNAME)

function pleroma_setting_emoji {
    shortcode="$1"
    image_url="$2"
    if [ ! "$shortcode" ]; then
        return
    fi
    if [[ "$shortcode" == *' '* || "$shortcode" == *':'* ]]; then
        return
    fi
    if [ ${#shortcode} -gt 32 ]; then
        return
    fi
    if [[ "$image_url" != 'http'* ]]; then
        return
    fi
    if [ ${#image_url} -gt 256 ]; then
        return
    fi

    image_extension=
    if [[ "$image_url" == *'.jpg' || "$image_url" == *'.jpeg' ]]; then
        image_extension='jpg'
    fi
    if [[ "$image_url" == *'.gif' ]]; then
        image_extension='gif'
    fi
    if [[ "$image_url" == *'.png' ]]; then
        image_extension='png'
    fi
    if [ ! $image_extension ]; then
        echo $'Invalid image type'
        return
    fi

    if [ ! -d $PLEROMA_DIR/priv/static/emoji ]; then
        mkdir -p $PLEROMA_DIR/priv/static/emoji
    fi

    image_filename=$PLEROMA_DIR/priv/static/emoji/${shortcode}.${image_extension}
    if [ -f "$image_filename" ]; then
        mv "$image_filename" "${image_filename}.prev"
    fi
    wget "$image_url" -O "$image_filename"
    if [ ! -f "$image_filename" ]; then
        mv "${image_filename}.prev" "${image_filename}"
        return
    fi
    rm "${image_filename}.prev"

    if [[ "$image_url" == *'.jpg' || "$image_url" == *'.jpeg' || "$image_url" == *'.gif' ]]; then
        convert "$image_filename" -resize "$emoji_resolution" "$PLEROMA_DIR/priv/static/emoji/${shortcode}.png"
        if [ ! -f "$PLEROMA_DIR/priv/static/emoji/${shortcode}.png" ]; then
            return
        fi

        # remove the original
        rm "$image_filename"

        image_extension='png'
        image_filename=$PLEROMA_DIR/priv/static/emoji/${shortcode}.${image_extension}
    else
        convert "$image_filename" -resize "$emoji_resolution" "$image_filename"
    fi

    if ! grep -q "${shortcode}," $PLEROMA_DIR/config/emoji.txt; then
        echo "${shortcode}, /emoji/${shortcode}.${image_extension}" >> $PLEROMA_DIR/config/emoji.txt
    else
        sed -i "s|${shortcode},.*|${shortcode}, /emoji/${shortcode}.${image_extension}|g" $PLEROMA_DIR/config/emoji.txt
    fi

    chown -R pleroma:pleroma $PLEROMA_DIR
    systemctl stop pleroma
    pleroma_recompile
}

function pleroma_setting_registration {
    allow_registration="$1"

    if [[ "$allow_registration" == '1' ]]; then
        sed -i 's|registrations_open: false|registrations_open: true|g' $PLEROMA_DIR/config/config.exs
        sed -i 's|registrations_open: False|registrations_open: true|g' $PLEROMA_DIR/config/config.exs
        sed -i 's|"registrationOpen": false|"registrationOpen": true|g' $PLEROMA_DIR/priv/static/static/config.json
        sed -i 's|"registrationOpen": False|"registrationOpen": true|g' $PLEROMA_DIR/priv/static/static/config.json
        pleroma_recompile
    fi

    if [[ "$allow_registration" == '0' ]]; then
        sed -i 's|registrations_open: true|registrations_open: false|g' $PLEROMA_DIR/config/config.exs
        sed -i 's|registrations_open: True|registrations_open: false|g' $PLEROMA_DIR/config/config.exs
        sed -i 's|"registrationOpen": true|"registrationOpen": false|g' $PLEROMA_DIR/priv/static/static/config.json
        sed -i 's|"registrationOpen": True|"registrationOpen": false|g' $PLEROMA_DIR/priv/static/static/config.json
        pleroma_recompile
    fi
}

function pleroma_enable_chat {
    if [[ "$1" == 't'* || "$1" == 'y'* || "$1" == 'T'* || "$1" == 'Y'* ]]; then
        sed -i 's|"chatDisabled":.*|"chatDisabled": false,|g' $PLEROMA_DIR/priv/static/static/config.json
        sed -i 's|:chat, enabled:.*|:chat, enabled: true|g' $PLEROMA_DIR/config/config.exs
    else
        sed -i 's|"chatDisabled":.*|"chatDisabled": true,|g' $PLEROMA_DIR/priv/static/static/config.json
        sed -i 's|:chat, enabled:.*|:chat, enabled: false|g' $PLEROMA_DIR/config/config.exs
    fi
    pleroma_recompile
}

function create_pleroma_blocklist {
    { echo '#!/bin/bash';
      echo '';
      echo "if [ ! -f /root/${PROJECT_NAME}-firewall-domains.cfg ]; then";
      echo '    exit 0';
      echo 'fi';
      echo '';
      echo 'if [ -f /tmp/pleroma-blocking.lock ]; then';
      echo '    cd /tmp';
      echo '    find ./pleroma*.lock -type f -mmin +5 -exec rm {} \;';
      echo '    if [ -f /tmp/pleroma-blocking.lock ]; then';
      echo '        exit 0';
      echo '    fi';
      echo 'fi';
      echo '';
      echo 'touch /tmp/pleroma-blocking.lock';
      echo 'filter_str=';
      echo '';
      echo 'while read blocked; do';
      echo "    if [[ \"\$blocked\" == *\".\"* && \"\$blocked\" != *\"@\"* ]]; then";
      echo "        if [ \${#blocked} -gt 4 ]; then";
      echo '            # Create a filter string for the pleroma configuration';
      echo "            if [ \"\$filter_str\" ]; then";
      echo "                filter_str=\"\${filter_str}, \\\"\$blocked\\\"\"";
      echo '            else';
      echo "                filter_str=\"\\\"\${blocked}\\\"\"";
      echo '            fi';
      echo '';
      echo "            if ! grep -q \"127.0.0.1  \$blocked\" /etc/hosts; then";
      echo "                echo \"127.0.0.1  \$blocked\" >> /etc/hosts";
      echo '            fi';
      echo '        fi';
      echo '    fi';
      echo 'done </root/freedombone-firewall-domains.cfg';
      echo '';
      echo 'while read blocked; do';
      echo "    if [[ \"\$blocked\" == *\".\"* && \"\$blocked\" == *\"@\"* ]]; then";
      echo "        if [ \${#blocked} -gt 4 ]; then";

      echo "            curr_user_query=\"SELECT nickname FROM users where nickname ilike '%\${blocked}%'\"";
      echo "            curr_user_present=\$(sudo -u postgres psql -d pleroma -c \"\$curr_user_query\")";
      echo "            if [[ \"\$curr_user_present\" != *'(0 '* ]]; then";
      echo "                /bin/bash -c \"cd /etc/pleroma;sudo -u pleroma mix deactivate_user \${blocked}\" &";
      echo '                sleep 1';
      echo '            fi';
      echo '        fi';
      echo '    fi';
      echo 'done </root/freedombone-firewall-domains.cfg';
      echo '';
      echo "if [ \"\$filter_str\" ]; then";
      echo "    if ! grep -q \" \$filter_str \" $pleroma_secret; then";
      echo "        sed -i \"s| media_removal:.*| media_removal: [ \$filter_str ],|g\" $pleroma_secret";
      echo "        sed -i \"s| federated_timeline_removal:.*| federated_timeline_removal: [ \$filter_str ],|g\" $pleroma_secret";
      echo "        sed -i \"s| reject:.*| reject: [ \$filter_str ]|g\" $pleroma_secret";
      echo "        chown -R pleroma:pleroma $PLEROMA_DIR";
      echo '        sudo -u pleroma mix clean';
      echo '        sudo -u pleroma mix deps.compile';
      echo '        sudo -u pleroma mix compile';
      echo '        systemctl restart pleroma';
      echo '    fi';
      echo 'fi';
      echo '';
      echo 'rm /tmp/pleroma-blocking.lock'; } > $blocking_script_file

    chmod +x $blocking_script_file

    if ! grep -q "$blocking_script_file" /etc/crontab; then
        cron_add_mins 1 "$blocking_script_file 2> /dev/null"
    fi
}

function expire_pleroma_posts {
    domain_name=$1
    expire_months=$3

    if [ ! "$expire_months" ]; then
        expire_months=3
    fi

    #expire_days=$((expire_months * 30))

    # files are what take up most of the backup time, so don't keep them for very long
    expire_days_files=7

    # To prevent the database size from growing endlessly this script expires posts
    # after a number of months
    if [ ! -d $PLEROMA_DIR ]; then
        return
    fi

    { echo '#!/bin/bash';
      echo "plmonths=\"$PLEROMA_EXPIRE_MONTHS\"";
      echo "if [ \${#plmonths} -eq 0 ]; then";
      echo '    exit 1';
      echo 'fi';
      echo "if [[ \"\$plmonths\" == \"0\" ]]; then";
      echo '    exit 2';
      echo 'fi';
      echo "oldate=\$(date +%Y-%m-%d --date=\"\$plmonths months ago\")";
      echo 'cd /etc/postgresql';
      echo "sudo -u postgres psql -d pleroma -c \"DELETE FROM notifications WHERE inserted_at <= '\$oldate 01:01:01'\"";
      echo "sudo -u postgres psql -d pleroma -c \"DELETE FROM objects WHERE inserted_at <= '\$oldate 01:01:01'\""; } > $pleroma_expire_posts_script
    chmod +x $pleroma_expire_posts_script

    pleroma_expire_script=/etc/cron.daily/pleroma-expire
    expire_days_files_threshold=$((expire_days_files - 1))
    { echo '#!/bin/bash';
      echo 'cd /etc/postgresql';
      echo "if [ -d $PLEROMA_DIR/tempfiles ]; then";
      echo "    rm -rf $PLEROMA_DIR/tempfiles";
      echo 'fi';
      echo '';
      echo '# make directory to temporarily store local avatars';
      echo "mkdir $PLEROMA_DIR/tempfiles";
      echo '';
      echo '# get the local avatar files';
      echo "avatars=\$(sudo -u postgres psql -d pleroma -c \"select avatar->>'url' from users where avatar->>'url' like '%${domain_name}%'\")";
      echo '';
      echo '# copy the avatar files to a temporary directory';
      echo "arr=( \$avatars )";
      echo "for i in \${arr[@]}; do";
      echo "    if [[ \"\$i\" == *'/media/'* ]]; then";
      echo "        imagefile=$PLEROMA_DIR/uploads/\$(echo \$i | sed 's|\"||g' | sed 's|,||g' | awk -F '/media/' '{print \$2}');";
      echo "        if [ -f \$imagefile ]; then";
      echo "            imagedir=$PLEROMA_DIR/uploads/\$(echo \$imagefile | awk -F '/' '{print \$5}')";
      echo "            nowdate=\$(date +%s)";
      echo "            sinceepoch=\$(date +%s -r \$imagefile)";
      echo "            daysold=\$(((\$nowdate - \$sinceepoch) / 86400))";
      echo "            if [ \$daysold -ge ${expire_days_files_threshold} ]; then";
      echo "                cp -rp \$imagedir $PLEROMA_DIR/tempfiles";
      echo '            fi';
      echo '        fi';
      echo '    fi';
      echo 'done';
      echo '';
      echo '# get the local banner files';
      echo "banners=\$(sudo -u postgres psql -d pleroma -c \"select avatar->>'banner' from users where avatar->>'url' like '%${domain_name}%'\")";
      echo '';
      echo '# copy the banner files to a temporary directory';
      echo "arr=( \$banners )";
      echo "for i in \${arr[@]}; do";
      echo "    if [[ \"\$i\" == *'/media/'* ]]; then";
      echo "        imagefile=$PLEROMA_DIR/uploads/\$(echo \$i | sed 's|\"||g' | sed 's|,||g' | awk -F '/media/' '{print \$2}');";
      echo "        if [ -f \$imagefile ]; then";
      echo "            imagedir=$PLEROMA_DIR/uploads/\$(echo \$imagefile | awk -F '/' '{print \$5}')";
      echo "            nowdate=\$(date +%s)";
      echo "            sinceepoch=\$(date +%s -r \$imagefile)";
      echo "            daysold=\$(((\$nowdate - \$sinceepoch) / 86400))";
      echo "            if [ \$daysold -ge ${expire_days_files_threshold} ]; then";
      echo "                cp -rp \$imagedir $PLEROMA_DIR/tempfiles";
      echo '            fi';
      echo '        fi';
      echo '    fi';
      echo 'done';
      echo '';
      echo '# delete old files';
      echo "find $PLEROMA_DIR/uploads/* -mtime +${expire_days_files} -exec rm -rf {} +";
      echo '';
      echo '# move avatar files back to uploads';
      echo "chown -R pleroma:pleroma $PLEROMA_DIR/tempfiles";
      echo "mv $PLEROMA_DIR/tempfiles/* $PLEROMA_DIR/uploads";
      echo "rm -rf $PLEROMA_DIR/tempfiles";
      echo '';
      echo "$pleroma_expire_posts_script 2> /dev/null"; } > $pleroma_expire_script
    chmod +x $pleroma_expire_script

    # remove any old cron job
    if grep -q "pleroma-expire" /etc/crontab; then
        sed -i "/pleroma-expire/d" /etc/crontab
        rm /usr/bin/pleroma-expire
    fi

    # remove old expire script
    if [ -f /etc/cron.weekly/clear-pleroma-database ]; then
        rm /etc/cron.weekly/clear-pleroma-database
    fi
}

function pleroma_recompile {
    # necessary after parameter changes
    chown -R pleroma:pleroma $PLEROMA_DIR
    sudo -u pleroma mix clean
    sudo -u pleroma mix deps.compile
    sudo -u pleroma mix compile

    if [ -f /etc/systemd/system/pleroma.service ]; then
        systemctl restart pleroma
    fi
}

function logging_on_pleroma {
    echo -n ''
}

function logging_off_pleroma {
    echo -n ''
}

function remove_user_pleroma {
    remove_username="$1"

    cd $PLEROMA_DIR || exit 252498
    sudo -u pleroma mix rm_user "$remove_username"
    "${PROJECT_NAME}-pass" -u "$remove_username" --rmapp pleroma
}

function add_user_pleroma {
    new_username="$1"
    new_user_password="$2"

    cd $PLEROMA_DIR || exit 348346
    sudo -u pleroma mix register_user "$new_username" "$new_username" "$new_username@$HOSTNAME" $"Your bio goes here" "$new_user_password"
    "${PROJECT_NAME}-pass" -u "$new_username" -a pleroma -p "$new_user_password"
    echo '0'
}

function install_interactive_pleroma {
    if [ ! "$ONION_ONLY" ]; then
        ONION_ONLY='no'
    fi

    if [[ $ONION_ONLY != "no" ]]; then
        PLEROMA_DOMAIN_NAME='pleroma.local'
    else
        PLEROMA_DETAILS_COMPLETE=
        while [ ! $PLEROMA_DETAILS_COMPLETE ]
        do
            data=$(mktemp 2>/dev/null)
            if [[ "$DDNS_PROVIDER" == *"freedns"* ]]; then
                dialog --backtitle $"Freedombone Configuration" \
                       --title $"Pleroma Configuration" \
                       --form $"\\nPlease enter your Pleroma details. The background image URL can be left blank.\\n\\nIMPORTANT: This should be a domain name which is supported by Let's Encrypt:" 16 65 4 \
                       $"Domain:" 1 1 "$(grep 'PLEROMA_DOMAIN_NAME' temp.cfg | awk -F '=' '{print $2}')" 1 25 33 40 \
                       $"Title:" 2 1 "$(grep "$PLEROMA_TITLE" temp.cfg | awk -F '=' '{print $2}')" 2 25 255 255 \
                       $"Background image URL:" 3 1 "$(grep "$PLEROMA_BACKGROUND_IMAGE_URL" temp.cfg | awk -F '=' '{print $2}')" 3 25 255 255 \
                       $"Code:" 4 1 "$(grep 'PLEROMA_CODE' temp.cfg | awk -F '=' '{print $2}')" 4 25 33 255 \
                       2> "$data"
            else
                dialog --backtitle $"Freedombone Configuration" \
                       --title $"Pleroma Configuration" \
                       --form $"\\nPlease enter your Pleroma details. The background image URL can be left blank.\\n\\nIMPORTANT: This should be a domain name which is supported by Let's Encrypt:" 16 65 4 \
                       $"Domain:" 1 1 "$(grep 'PLEROMA_DOMAIN_NAME' temp.cfg | awk -F '=' '{print $2}')" 1 25 33 40 \
                       $"Title:" 2 1 "$(grep "$PLEROMA_TITLE" temp.cfg | awk -F '=' '{print $2}')" 2 25 255 255 \
                       $"Background image URL:" 3 1 "$(grep "$PLEROMA_BACKGROUND_IMAGE_URL" temp.cfg | awk -F '=' '{print $2}')" 3 25 255 255 \
                       2> "$data"
            fi
            sel=$?
            case $sel in
                1) rm -f "$data"
                   exit 1;;
                255) rm -f "$data"
                     exit 1;;
            esac
            PLEROMA_DOMAIN_NAME=$(sed -n 1p < "$data")
            title=$(sed -n 2p < "$data")
            if [ ${#title} -gt 1 ]; then
                PLEROMA_TITLE="$title"
            fi
            img_url=$(sed -n 3p < "$data")
            if [ ${#img_url} -gt 1 ]; then
                PLEROMA_BACKGROUND_IMAGE_URL=$img_url
            fi
            if [ "$PLEROMA_DOMAIN_NAME" ]; then
                if [[ $PLEROMA_DOMAIN_NAME == "$HUBZILLA_DOMAIN_NAME" ]]; then
                    PLEROMA_DOMAIN_NAME=""
                fi
                TEST_DOMAIN_NAME=$PLEROMA_DOMAIN_NAME
                validate_domain_name
                if [[ "$TEST_DOMAIN_NAME" != "$PLEROMA_DOMAIN_NAME" ]]; then
                    PLEROMA_DOMAIN_NAME=
                    dialog --title $"Domain name validation" --msgbox "$TEST_DOMAIN_NAME" 15 50
                else
                    if [[ "$DDNS_PROVIDER" == *"freedns"* ]]; then
                        PLEROMA_CODE=$(sed -n 4p < "$data")
                        validate_freedns_code "$PLEROMA_CODE"
                        if [ ! "$VALID_CODE" ]; then
                            PLEROMA_DOMAIN_NAME=
                        fi
                    fi
                fi
            fi
            if [ $PLEROMA_DOMAIN_NAME ]; then
                PLEROMA_DETAILS_COMPLETE="yes"
            fi
            rm -f "$data"
        done

        # remove any invalid characters
        if [ ${#PLEROMA_TITLE} -gt 0 ]; then
            new_title=${PLEROMA_TITLE//\'/}
            PLEROMA_TITLE="$new_title"
        fi

        # save the results in the config file
        write_config_param "PLEROMA_CODE" "$PLEROMA_CODE"
        write_config_param "PLEROMA_TITLE" "$PLEROMA_TITLE"
        write_config_param "PLEROMA_BACKGROUND_IMAGE_URL" "$PLEROMA_BACKGROUND_IMAGE_URL"
    fi
    write_config_param "PLEROMA_DOMAIN_NAME" "$PLEROMA_DOMAIN_NAME"
    APP_INSTALLED=1
}

function change_password_pleroma {
#    curr_username="$1"
    new_user_password="$2"

    #${PROJECT_NAME}-pass -u "$curr_username" -a pleroma -p "$new_user_password"
}

function pleroma_create_database_failed {
    run_system_query_postgresql "ALTER USER pleroma NOSUPERUSER;"
    run_system_query_postgresql "ALTER USER pleroma NOCREATEDB;"
}

function pleroma_create_config {
    config_filename="$1"
    domain=$PLEROMA_DOMAIN_NAME
    domain_scheme='https'
    domain_port=443

    if [[ "$ONION_ONLY" != 'no' ]]; then
        domain=$PLEROMA_ONION_HOSTNAME
        domain_scheme='http'
        domain_port=80
    fi

    { echo 'use Mix.Config';
      echo '';
      echo 'config :pleroma, Pleroma.Web.Endpoint,';
      echo '  pubsub: [name: Pleroma.Web.PubSub, adapter: Phoenix.PubSub.PG2],';
      echo "  secret_key_base: \"$PLEROMA_SECRET_KEY\",";
      echo "  http: [port: $PLEROMA_PORT],";
      echo '  protocol: "http",';
      echo '  debug_errors: true,';
      echo '  code_reloader: true,';
      echo '  check_origin: true,';
      echo '  watchers: [],';
      echo "  url: [host: \"$domain\", scheme: \"$domain_scheme\", port: $domain_port]";
      echo '';
      echo "config :pleroma, :http, proxy_url: {:socks5, :localhost, 9050}";
      echo '';
      # shellcheck disable=SC2028
      echo "config :logger, :console, format: \"[\$level] \$message\\n\"";
      echo '';
      echo 'config :comeonin, :pbkdf2_rounds, 1';
      echo '';
      echo 'config :pleroma, Pleroma.Upload,';
      echo '  uploads: "uploads",';
      echo '  strip_exif: true';
      echo '';
      echo '# begin filtering';
      echo 'config :pleroma, :mrf_simple,';
      echo '  media_removal: [],';
      echo '  media_nsfw: [],';
      echo '  federated_timeline_removal: [],';
      echo '  accept: [],';
      echo '  reject: []';
      echo '';
      echo 'config :phoenix, :stacktrace_depth, 20';
      echo '';
      echo 'config :pleroma, Pleroma.Repo,';
      echo '  adapter: Ecto.Adapters.Postgres,';
      echo '  username: "pleroma",';
      echo "  password: \"$PLEROMA_ADMIN_PASSWORD\",";
      echo '  database: "pleroma",';
      echo '  hostname: "localhost",';
      echo '  pool_size: 10';
      echo '';
      echo 'config :pleroma, :fe,';
      echo '  scope_options_enabled: true';
      echo '';
      echo 'try do';
      echo '  # import_config "dev.secret.exs"';
      echo 'rescue';
      # shellcheck disable=SC2028
      echo '  _-> IO.puts("!!! RUNNING IN LOCALHOST DEV MODE! !!!\nFEDERATION WONT WORK UNTIL YOU CONFIGURE A dev.secret.exs")';
      echo 'end'; } > "$config_filename"
}

function pleroma_create_database {
    if [ -f "$IMAGE_PASSWORD_FILE" ]; then
        PLEROMA_ADMIN_PASSWORD="$(printf "%s" "$(cat "$IMAGE_PASSWORD_FILE")")"
    else
        if [ ! "$PLEROMA_ADMIN_PASSWORD" ]; then
            PLEROMA_ADMIN_PASSWORD="$(create_password "${MINIMUM_PASSWORD_LENGTH}")"
        fi
    fi
    if [ ! "$PLEROMA_ADMIN_PASSWORD" ]; then
        return
    fi

    systemctl restart postgresql
    add_postgresql_user pleroma "$PLEROMA_ADMIN_PASSWORD" encrypted
    run_system_query_postgresql "create database pleroma;"
    # temporarily allow the user to create databases
    run_system_query_postgresql "ALTER USER pleroma CREATEDB;"
    run_system_query_postgresql "ALTER USER pleroma SUPERUSER;"
    run_system_query_postgresql "GRANT ALL ON ALL tables IN SCHEMA public TO pleroma;"
    run_system_query_postgresql "GRANT ALL ON ALL sequences IN SCHEMA public TO pleroma;"
    run_system_query_postgresql "CREATE EXTENSION citext;"
    run_system_query_postgresql "set statement_timeout to 40000;"

    read_config_param "PLEROMA_SECRET_KEY"
    if [ ${#PLEROMA_SECRET_KEY} -lt 64 ]; then
        PLEROMA_SECRET_KEY="$(create_password 30)$(create_password 30)$(create_password 30)"
        if [ ${#PLEROMA_SECRET_KEY} -lt 64 ]; then
            pleroma_create_database_failed
            echo $'Pleroma secret key not created'
            exit 6782352
        fi
        write_config_param "PLEROMA_SECRET_KEY" "$PLEROMA_SECRET_KEY"
    fi

    if [ ! -d $PLEROMA_DIR/config ]; then
        echo $"Missing directory $PLEROMA_DIR/config"
        exit 7835393
    fi
    if [ ! -f $PLEROMA_DIR/config/dev.exs ]; then
        echo $"Did not find $PLEROMA_DIR/config/dev.exs"
        exit 78923528
    fi

    pleroma_create_config $pleroma_secret

    cd "$PLEROMA_DIR" || exit 678245245724
    chown -R pleroma:pleroma $PLEROMA_DIR/*
    if ! sudo -u pleroma mix local.rebar --force; then
        pleroma_create_database_failed
        echo $'mix local.rebar failed'
        exit 73528562
    fi
    sudo -u pleroma mix local.hex --force
    sudo -u pleroma mix deps.compile mimerl
    systemctl restart postgresql
    if ! sudo -u pleroma mix ecto.create --force; then
        pleroma_create_database_failed
        echo $'mix ecto.create failed'
        exit 83653582
    fi
    if ! sudo -u pleroma mix ecto.migrate --force; then
        pleroma_create_database_failed
        echo $'mix ecto.migrate failed'
        exit 73752573
    fi

    # revoke the ability to create databases for this user
    run_system_query_postgresql "ALTER USER pleroma NOSUPERUSER;"
    run_system_query_postgresql "ALTER USER pleroma NOCREATEDB;"
}

function reconfigure_pleroma {
    echo -n ''
}

function pleroma_set_background_image {
    PLEROMA_DOMAIN_NAME=$(get_completion_param "pleroma domain")

    data=$(mktemp 2>/dev/null)
    dialog --title $"Pleroma" \
           --backtitle $"Freedombone Control Panel" \
           --inputbox $'Set a background image URL' 10 60 2>"$data"
    sel=$?
    case $sel in
        0)
            temp_background=$(<"$data")
            if [ ${#temp_background} -gt 0 ]; then
                PLEROMA_BACKGROUND_IMAGE_URL="$temp_background"
                write_config_param "PLEROMA_BACKGROUND_IMAGE_URL" "$PLEROMA_BACKGROUND_IMAGE_URL"
                if [[ $(pleroma_set_background_image_from_url $PLEROMA_DIR "$PLEROMA_DOMAIN_NAME" "$PLEROMA_BACKGROUND_IMAGE_URL" "$PLEROMA_TITLE" | tail -n 1) == "0" ]]; then
                    chown -R pleroma:pleroma "$PLEROMA_DIR/priv/static/static"
                    pleroma_recompile

                    dialog --title $"Set Pleroma login background" \
                           --msgbox $"The background image has been set" 6 60
                fi
            fi
           ;;
    esac
    rm -f "$data"
}

function pleroma_set_title {
    data=$(mktemp 2>/dev/null)
    dialog --title $"Pleroma" \
           --backtitle $"Freedombone Control Panel" \
           --inputbox $'Set a title' 10 60 2>"$data"
    sel=$?
    case $sel in
        0)
            new_title=$(<"$data")
            if [ ${#new_title} -gt 0 ]; then
                PLEROMA_TITLE="$new_title"
                PLEROMA_DOMAIN_NAME=$(get_completion_param "pleroma domain")
                write_config_param "PLEROMA_TITLE" "$PLEROMA_TITLE"
                sed -i "s|\"name\":.*|\"name\": \"${PLEROMA_TITLE}\",|g" $PLEROMA_DIR/static/config.json
                sed -i "s|\"name\":.*|\"name\": \"${PLEROMA_TITLE}\",|g" $PLEROMA_DIR/priv/static/static/config.json
                sed -i "s|name: .*|name: \"${PLEROMA_TITLE}\",|g" $PLEROMA_DIR/config/config.exs
                systemctl restart pleroma
                dialog --title $"Set Pleroma title" \
                       --msgbox $"The title has been set" 6 60
            fi
           ;;
    esac
    rm -f "$data"
}

function pleroma_set_expire_months {
    PLEROMA_DOMAIN_NAME=$(get_completion_param "pleroma domain")
    read_config_param "PLEROMA_DOMAIN_NAME"
    read_config_param "PLEROMA_EXPIRE_MONTHS"

    data=$(mktemp 2>/dev/null)
    dialog --title $"Pleroma" \
           --backtitle $"Freedombone Control Panel" \
           --inputbox $'Set an expiry period for posts in months. Anything older will be deleted. Lower values help to keep the database size small and as fast as possible.' 12 60 "$PLEROMA_EXPIRE_MONTHS" 2>"$data"
    sel=$?
    case $sel in
        0)
            new_expiry_months=$(<"$data")
            if [ ${#new_expiry_months} -gt 0 ]; then
                # should contain no spaces
                if [[ "$new_expiry_months" == *" "* ]]; then
                    rm -f "$data"
                    return
                fi
                # should be a number
                re='^[0-9]+$'
                if ! [[ $new_expiry_months =~ $re ]] ; then
                    rm -f "$data"
                    return
                fi
                # set the new value
                PLEROMA_EXPIRE_MONTHS=$new_expiry_months
                write_config_param "PLEROMA_EXPIRE_MONTHS" "$PLEROMA_EXPIRE_MONTHS"

                expire_pleroma_posts "$PLEROMA_DOMAIN_NAME" "$PLEROMA_EXPIRE_MONTHS"
                create_pleroma_blocklist

                dialog --title $"Set Pleroma post expiry period" \
                       --msgbox $"Expiry period set to $PLEROMA_EXPIRE_MONTHS months" 6 60
            fi
           ;;
    esac
    rm -f "$data"
}

function pleroma_disable_registrations {
    dialog --title $"Disable new Pleroma user registrations" \
           --backtitle $"Freedombone Control Panel" \
           --yesno $"\\nDo you wish to disable new registrations?" 10 60
    sel=$?
    case $sel in
        0) sed -i 's|registrations_open: true|registrations_open: false|g' $PLEROMA_DIR/config/config.exs
           sed -i 's|registrations_open: True|registrations_open: false|g' $PLEROMA_DIR/config/config.exs
           sed -i 's|"registrationOpen": true|"registrationOpen": false|g' $PLEROMA_DIR/priv/static/static/config.json
           sed -i 's|"registrationOpen": True|"registrationOpen": false|g' $PLEROMA_DIR/priv/static/static/config.json
           ;;
        1) sed -i 's|registrations_open: false|registrations_open: true|g' $PLEROMA_DIR/config/config.exs
           sed -i 's|registrations_open: False|registrations_open: true|g' $PLEROMA_DIR/config/config.exs
           sed -i 's|"registrationOpen": false|"registrationOpen": true|g' $PLEROMA_DIR/priv/static/static/config.json
           sed -i 's|"registrationOpen": False|"registrationOpen": true|g' $PLEROMA_DIR/priv/static/static/config.json
           ;;
        255) return;;
    esac
    pleroma_recompile
}

function pleroma_add_emoji {
    emoji_resolution='128x128'

    data=$(mktemp 2>/dev/null)
    dialog --backtitle $"Freedombone Control Panel" \
           --title $"Add Custom Emoji" \
           --form "\\n" 8 75 2 \
           $"Shortcode:" 1 1 "" 1 18 16 15 \
           $"ImageURL:" 2 1 "" 2 18 512 10000 \
           2> "$data"
    sel=$?
    case $sel in
        1) rm -f "$data"
           return;;
        255) rm -f "$data"
             return;;
    esac
    shortcode=$(sed -n 1p < "$data")
    image_url=$(sed -n 2p < "$data")
    rm -f "$data"
    if [ ${#shortcode} -lt 2 ]; then
        return
    fi
    if [ ${#image_url} -lt 2 ]; then
        return
    fi
    if [[ "$image_url" != *'.'* ]]; then
        return
    fi
    if [[ "$image_url" != *'.png' && "$image_url" != *'.jpg' && "$image_url" != *'.jpeg' && "$image_url" != *'.gif' ]]; then
        dialog --title $"Add Custom Emoji" \
               --msgbox $"The image must be png/jpg/gif format" 6 60
        return
    fi
    if [[ "$shortcode" == *':'* || "$shortcode" == *' '* || "$shortcode" == *'.'* || "$shortcode" == *'!'* ]]; then
        dialog --title $"Add Custom Emoji" \
               --msgbox $"The shortcode contains invalid characters" 6 60
        return
    fi

    image_extension='png'
    if [[ "$image_url" == *'.jpg' || "$image_url" == *'.jpeg' ]]; then
        image_extension='jpg'
    fi
    if [[ "$image_url" == *'.gif' ]]; then
        image_extension='gif'
    fi

    if [ ! -d $PLEROMA_DIR/priv/static/emoji ]; then
        mkdir -p $PLEROMA_DIR/priv/static/emoji
    fi

    image_filename=$PLEROMA_DIR/priv/static/emoji/${shortcode}.${image_extension}
    if [ -f "$image_filename" ]; then
        mv "$image_filename" "${image_filename}.prev"
    fi
    wget "$image_url" -O "$image_filename"
    if [ ! -f "$image_filename" ]; then
        mv "${image_filename}.prev" "${image_filename}"
        dialog --title $"Add Custom Emoji" \
               --msgbox $"Unable to download the image" 6 60
        return
    fi

    if [[ "$image_url" == *'.jpg' || "$image_url" == *'.jpeg' || "$image_url" == *'.gif' ]]; then
        convert "$image_filename" -resize "$emoji_resolution" "$PLEROMA_DIR/priv/static/emoji/${shortcode}.png"
        if [ ! -f "$PLEROMA_DIR/priv/static/emoji/${shortcode}.png" ]; then
            dialog --title $"Add Custom Emoji" \
                   --msgbox $"Unable to convert empji image to png format" 6 60
            return
        fi

        # remove the original
        rm "$image_filename"

        image_extension='png'
        image_filename=$PLEROMA_DIR/priv/static/emoji/${shortcode}.${image_extension}
    else
        convert "$image_filename" -resize "$emoji_resolution" "$image_filename"
    fi

    if ! grep -q "${shortcode}," $PLEROMA_DIR/config/emoji.txt; then
        echo "${shortcode}, /emoji/${shortcode}.${image_extension}" >> $PLEROMA_DIR/config/emoji.txt
    else
        sed -i "s|${shortcode},.*|${shortcode}, /emoji/${shortcode}.${image_extension}|g" $PLEROMA_DIR/config/emoji.txt
    fi

    chown -R pleroma:pleroma $PLEROMA_DIR
    clear
    echo ''
    echo $'Recompiling Pleroma with the new emoji'
    systemctl stop pleroma
    pleroma_recompile

    dialog --title $"Add Custom Emoji" \
           --msgbox $"Custom emoji :${shortcode}: has been added" 6 70
}

function pleroma_whitelist {
    whitelist_filename=$PLEROMA_DIR/whitelist.txt
    if [ ! -f $whitelist_filename ]; then
        { echo '# Domain whitelist';
          echo '';
          echo '# If you add domains to this list then pleroma will be';
          echo '# restricted to federating only with those domains';
          echo '';
          echo '# Do not include your own instance domain in this list!';
          echo ''; } > $whitelist_filename
    fi

    editor $whitelist_filename

    first_line=1
    domain_list=
    while read -r domain; do
        if [[ "$domain" == *'#'* || "$domain" != *'.'* ]]; then
            continue
        fi

        if [ ! $first_line ]; then
            domain_list="${domain_list}, \"$domain\""
        else
            domain_list="\"$domain\""
        fi

        first_line=
    done <$whitelist_filename

    if [ ! "$domain_list" ]; then
        sed -i "s|accept: .*|accept: [],|g" $pleroma_secret
    else
        if [[ "$ONION_ONLY" == 'no' ]]; then
            sed -i "s|accept: .*|accept: [ \"$PLEROMA_DOMAIN_NAME\", ${domain_list} ],|g" $pleroma_secret
        else
            pleroma_onion_domain=$(cat /var/lib/tor/hidden_service_pleroma/hostname)
            sed -i "s|accept: .*|accept: [ \"$pleroma_onion_domain\", ${domain_list} ],|g" $pleroma_secret
        fi
    fi

    pleroma_recompile

    if [ "$domain_list" ]; then
        dialog --title $"Pleroma Whitelist" \
               --msgbox $"\\nYou are now only federating with the whitelisted domains" 8 60
    else
        dialog --title $"Pleroma Whitelist" \
               --msgbox $"\\nWhitelist is disabled" 8 40
    fi
}

function configure_interactive_pleroma {
    read_config_param ONION_ONLY
    read_config_param PLEROMA_DOMAIN_NAME
    read_config_param PLEROMA_EXPIRE_MONTHS
    while true
    do
        chatenabled=
        enablechatstr=$'Enable chat system'
        if grep -q ':chat, enabled: true' $PLEROMA_DIR/config/config.exs; then
            chatenabled=1
            enablechatstr=$'Disable chat system'
        fi

        pleromatorstr=$'Enable routing through Tor for onion addresses'
        if grep -q '9050' $pleroma_secret; then
            pleromatorstr=$'Disable routing through Tor'
        fi

        W=(1 $"Set a background image"
           2 $"Set the title"
           3 $"Disable new account registrations"
           4 $"Add a custom emoji"
           5 $"Set post expiry period (currently $PLEROMA_EXPIRE_MONTHS months)"
           6 "$enablechatstr"
           7 "$pleromatorstr"
           8 $'Domain whitelist')

        # shellcheck disable=SC2068
        selection=$(dialog --backtitle $"Freedombone Administrator Control Panel" --title $"Pleroma" --menu $"Choose an operation, or ESC to exit:" 15 60 8 "${W[@]}" 3>&2 2>&1 1>&3)

        if [ ! "$selection" ]; then
            break
        fi

        case $selection in
            1) pleroma_set_background_image;;
            2) pleroma_set_title;;
            3) pleroma_disable_registrations;;
            4) pleroma_add_emoji;;
            5) pleroma_set_expire_months;;
            6) if [ $chatenabled ]; then
                   pleroma_enable_chat false
               else
                   pleroma_enable_chat true
               fi
               ;;
            7) if grep -q '9050' $pleroma_secret; then
                   pleroma_disable_tor
               else
                   pleroma_enable_tor
               fi
               ;;
            8) pleroma_whitelist;;
        esac
    done
}

function pleroma_disable_tor {
    if grep -q '9050' $pleroma_secret; then
        sed -i '/9050/d' $pleroma_secret
        sed -i 's|# config :pleroma, :http, proxy_url:|config :pleroma, :http, proxy_url:|g' $PLEROMA_DIR/config/config.exs
        pleroma_recompile
    fi
}

function pleroma_enable_tor {
    pleroma_tor_update=

    if ! grep -q '{:socks5, :localhost, 9050}' $pleroma_secret; then
        pleroma_tor_update=1
    fi

    if ! grep -q '# config :pleroma, :http, proxy_url:' $PLEROMA_DIR/config/config.exs; then
        pleroma_tor_update=1
    fi

    if [ ! $pleroma_tor_update ]; then
        return
    fi

    if ! grep -q '{:socks5, :localhost, 9050}' $pleroma_secret; then
        sed -i '/9050/d' $pleroma_secret
        sed -i '/url:/a config :pleroma, :http, proxy_url: {:socks5, :localhost, 9050}' $pleroma_secret
    fi

    if ! grep -q '# config :pleroma, :http, proxy_url:' $PLEROMA_DIR/config/config.exs; then
        sed -i 's|config :pleroma, :http, proxy_url:|# config :pleroma, :http, proxy_url:|g' $PLEROMA_DIR/config/config.exs
    fi

    pleroma_recompile
}

function upgrade_pleroma {
    read_config_param PLEROMA_DOMAIN_NAME
    read_config_param PLEROMA_EXPIRE_MONTHS

    expire_pleroma_posts "$PLEROMA_DOMAIN_NAME" "$PLEROMA_EXPIRE_MONTHS"
    create_pleroma_blocklist

    #pleroma_enable_tor

    CURR_PLEROMA_COMMIT=$(get_completion_param "pleroma commit")
    if [[ "$CURR_PLEROMA_COMMIT" == "$PLEROMA_COMMIT" ]]; then
        return
    fi

    pleroma_registrations=open
    if grep -q 'registrations_open: false' $PLEROMA_DIR/config/config.exs; then
        pleroma_registrations=