dev.old

#!/bin/bash
# Helper script for commands related to this repository.
#
# Notes:
#  - Changes to template only require user to refresh browser.
#  - Changes to static files require the 'static' command to be run.
#  - Changes to Python code are detected by gunicorn and should take effect
#    on the server after a few seconds.

set -e

RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m' # No Color

cmd_helps=()
dev_cmd_helps=()

defhelp() {
  local command="${1?}"
  local text="${2?}"
  local help_str
  help_str="$(printf '   %-28s %s' "$command" "$text")"
  cmd_helps+=("$help_str")
}

# Print out help information
cmd_help() {
  echo "Script for performing tasks related to the codeWOF repository."
  echo
  echo "Usage: ./dev [COMMAND]"
  echo "Replace [COMMAND] with a word from the list below."
  echo
  echo "COMMAND list:"
  for str in "${cmd_helps[@]}"; do
    echo -e "$str"
  done
}

defhelp help 'View all help.'
defhelp 'dev [DEV_COMMAND]' 'Run a developer command.'

# Start development environment
cmd_start() {
  echo "Creating systems..."
  docker-compose up -d
  echo ""
  # Alert user that system is ready
  echo -e "\n${GREEN}System is up!${NC}"
  echo "Run the command ./dev update to load content."
}

defhelp start 'Start development environment.'

# Stop development environment
cmd_end() {
  echo "Stopping systems... (takes roughly 10 to 20 seconds)"
  docker-compose down
  echo
  echo "Deleting system volumes..."
  volumes=($(docker volume ls -qf dangling=true ))
  for volume in "${volumes[@]}"; do
      docker volume rm "${volume}"
  done
}
defhelp end 'Stop development environment.'

cmd_restart() {
  cmd_end
  cmd_start
}
defhelp restart 'Stop and then restart development environment.'

# Run Django migrate and updatedata commands
cmd_update() {
  cmd_static

  echo ""
  cmd_migrate

  echo ""
  cmd_load_questions
  cmd_load_style_errors

  echo ""
  cmd_collect_static
  echo ""
  echo -e "\n${GREEN}Content is loaded!${NC}"
  echo "Open your preferred web browser to the URL 'localhost:83'"
}
defhelp update 'Update system ready for use.'

# Collecting static files
cmd_collect_static() {
  echo
  echo "Collecting static files..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py collectstatic --no-input --clear
}
defhelp collect_static "Collecting static files."

# Run Django flush command
cmd_flush() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py flush
}
defhelp flush 'Run Django flush command.'

# Run Django makemigrations command
cmd_makemigrations() {
  echo "Creating database migrations..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py makemigrations
}
defhelp makemigrations 'Run Django makemigrations command.'

# Run Django migrate command
cmd_migrate() {
  echo "Applying database migrations..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py migrate
}
defhelp migrate 'Run Django migrate command.'

# Build Docker images
cmd_build() {
  echo "Building Docker images..."
  docker-compose build
  echo
  echo "Deleting untagged images..."
  untagged_images=($(docker images --no-trunc | grep '<none>' | awk '{print $3}'))
  if [[ ${#untagged_images[@]} -gt 0 ]]; then
      docker rmi "${untagged_images[@]}"
  fi
}
defhelp build 'Build or rebuild Docker images.'

# Build static files
cmd_static() {
  echo "Building static files..."
  docker-compose exec nginx gulp build
}
defhelp static 'Build static files.'

# Build production static files
cmd_static_prod() {
  echo "Building production static files..."
  docker-compose exec nginx gulp build --production
}
defhelp static_prod 'Build production static files.'

# Update and collect static files
cmd_update_static() {
  cmd_static

  echo ""
  cmd_collect_static
  echo ""
  echo -e "\n${GREEN}Static files are updated!${NC}"
}
defhelp update_static 'Update and collect static files.'

# Run shell
cmd_shell() {
  docker-compose exec django bash
}
defhelp shell "Open shell to Django folder."

# Run shell
cmd_django_shell() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py shell
}
defhelp django_shell "Open Django shell."

# Run load_questions command
cmd_load_questions() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py load_questions
}
defhelp load_questions "Load questions."

# Run load_style_errors command
cmd_load_style_errors() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py load_style_errors
}
defhelp load_style_errors "Load style errors."

# Run load_achievements command
cmd_load_achievements() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py load_achievements
}
defhelp load_achievements "Load achievements."

cmd_createsuperuser() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py createsuperuser
}
defhelp createsuperuser "Create superuser in Django system."

cmd_sampledata() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py sampledata $1
}
defhelp sampledata "Add sample data to website."

cmd_raise_backdate_flags() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py raise_backdate_flags
}
defhelp raise_backdate_flags 'Raise a flag on all user profiles, requiring a backdate be done on them.'

cmd_backdate() {
  docker-compose exec django /docker_venv/bin/python3 ./manage.py backdate_points_and_achievements --ignore_flags
}
defhelp backdate 'Re-calculate points and achievements earned for all user profiles.'

# Reboot Django Docker container
cmd_reboot_django() {
  echo "Rebooting Django Docker container..."
  docker-compose restart django
}
defhelp reboot_django 'Reboot Django Docker container.'

# Run style checks
cmd_style() {
  echo "Running PEP8 style checker..."
  docker-compose exec django /docker_venv/bin/flake8
  pep8_status=$?
  echo
  echo "Running Python docstring checker..."
  docker-compose exec django /docker_venv/bin/pydocstyle --count --explain
  pydocstyle_status=$?
  ! (( pep8_status || pydocstyle_status ))
}
defhelp style 'Run style checks.'

# Run test suite
cmd_test_suite() {
  echo "Running test suite..."
  docker-compose exec django /docker_venv/bin/coverage run --rcfile=/codewof/.coveragerc -m pytest --ds=config.settings.test
  # docker-compose exec django /docker_venv/bin/mypy /codewof/codewof/
}
defhelp test_suite 'Run test suite with code coverage.'

# Run specific test suite
cmd_test_specific() {
  echo "Running specific test suite..."
  docker-compose exec django /docker_venv/bin/pytest --ds=config.settings.test "${1}"
}
defhelp test_specific 'Run specific test suite. Pass in parameter of Python test module.'

# Display test coverage table
cmd_test_coverage() {
  echo "Displaying test suite coverage..."
  docker-compose exec django /docker_venv/bin/coverage xml -i
  docker-compose exec django /docker_venv/bin/coverage report -m
}
defhelp test_coverage 'Display code coverage report.'

# Delete all untagged dangling Docker images
cmd_clean() {
  echo "If the following commands return an argument not found error,"
  echo "this is because there is nothing to delete for clean up."

  echo
  echo "Deleting unused volumes..."

  unused_volumes=($(docker volume ls -qf dangling=true))
  for vol in "${unused_volumes[@]}"; do
      docker volume rm "${vol}"
  done

  echo
  echo "Deleting exited containers..."
  exited_containers=($(docker ps --filter status=dead --filter status=exited -aq))
  for container in "${exited_containers[@]}"; do
      docker rm -v "${container}"
  done
  echo
  echo "Deleting dangling images..."
  dangling_images=($(docker images -f "dangling=true" -q))
  if [[ ${#dangling_images[@]} -gt 0 ]]; then
      docker rmi "${dangling_images[@]}"
  fi
}
defhelp clean 'Delete unused Docker files.'

# Delete all Docker containers and images
cmd_wipe() {
  docker ps -a -q | xargs docker rm
  docker images -q | xargs docker rmi
}
defhelp wipe 'Delete all Docker containers and images.'

# View logs
cmd_logs() {
  docker-compose logs django
}
defhelp logs 'View logs.'

ci_test_suite() {
  cmd_static
  cmd_collect_static
  cmd_test_suite
  test_status=$?
  cmd_test_coverage
  coverage_status=$?
  bash <(curl -s https://codecov.io/bash)
  ! (( $test_status || $coverage_status ))
}

ci_style() {
  cmd_style
}

ci_test_backwards() {
  cmd_static
  cmd_collect_static
  cmd_test_backwards
}

cmd_ci() {
  cmd_start
  local cmd="$1"
  shift
  if [ -z "$cmd" ]; then
    echo -e "${RED}ERROR: ci command requires one parameter!${NC}"
    cmd_help
    exit 1
  fi
  if silent type "ci_$cmd"; then
    "ci_$cmd" "$@"
    exit $?
  else
    echo -e "${RED}ERROR: Unknown command!${NC}"
    echo "Type './dev help' for available commands."
    return 1
  fi
}

silent() {
  "$@" > /dev/null 2>&1
}

cmd_dev() {
  local cmd="$1"
  shift
  if [ -z "$cmd" ]; then
    echo -e "${RED}ERROR: command requires one parameter!${NC}"
    cmd_help
    return 1
  fi
  if silent type "cmd_$cmd"; then
    "cmd_$cmd" "$@"
    exit $?
  else
    echo -e "${RED}ERROR: Unknown command!${NC}"
    echo "Type './dev help' for available commands."
    return 1
  fi
}

# If no command given
if [ $# -eq 0 ]; then
  echo -e "${RED}ERROR: This script requires a command!${NC}"
  cmd_help
  exit 1
fi
cmd="$1"
shift
if silent type "cmd_$cmd"; then
  "cmd_$cmd" "$@"
  exit $?
else
  echo -e "${RED}ERROR: Unknown command!${NC}"
  echo "Type './dev help' for available commands."
  exit 1
fi