Release 0.11.0

.devcontainer/.env.example

@@ -23,7 +23,7 @@ POSTGRES_USER=postgres
 POSTGRES_PASS=postgrespass
 
 # DEV SETTINGS
-APP_PORT=443
+APP_PORT=80
 API_PORT=80
 HTTP_PROTOCOL=https
 DOCKER_NETWORK=172.21.0.0/24

.devcontainer/api.dockerfile

@@ -1,11 +1,4 @@
-# pulls community scripts from git repo
-FROM python:3.10.8-slim AS GET_SCRIPTS_STAGE
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends git && \
-    git clone https://github.com/amidaware/community-scripts.git /community-scripts
-
-FROM python:3.10.8-slim
+FROM python:3.9.9-slim
 
 ENV TACTICAL_DIR /opt/tactical
 ENV TACTICAL_READY_FILE ${TACTICAL_DIR}/tmp/tactical.ready
@@ -17,15 +10,9 @@ ENV PYTHONUNBUFFERED=1
 
 EXPOSE 8000 8383 8005
 
-RUN apt-get update && \
-    apt-get install -y build-essential
-
 RUN groupadd -g 1000 tactical && \
     useradd -u 1000 -g 1000 tactical
 
-# copy community scripts
-COPY --from=GET_SCRIPTS_STAGE /community-scripts /community-scripts
-
 # Copy dev python reqs
 COPY .devcontainer/requirements.txt  /
 

.devcontainer/docker-compose.debug.yml

@@ -0,0 +1,19 @@
+version: '3.4'
+
+services:
+  api-dev:
+    image: api-dev
+    build:
+      context: .
+      dockerfile: ./api.dockerfile
+    command: ["sh", "-c", "pip install debugpy -t /tmp && python /tmp/debugpy --wait-for-client --listen 0.0.0.0:5678 manage.py runserver 0.0.0.0:8000 --nothreading --noreload"]
+    ports:
+      - 8000:8000
+      - 5678:5678
+    volumes:
+      - tactical-data-dev:/opt/tactical
+      - ..:/workspace:cached
+    networks:
+      dev:
+        aliases: 
+          - tactical-backend

.devcontainer/docker-compose.yml

@@ -5,7 +5,6 @@ services:
     container_name: trmm-api-dev
     image: api-dev
     restart: always
-    user: 1000:1000
     build:
       context: ..
       dockerfile: .devcontainer/api.dockerfile
@@ -22,12 +21,27 @@ services:
         aliases:
           - tactical-backend
 
+  app-dev:
+    container_name: trmm-app-dev
+    image: node:14-alpine
+    restart: always
+    command: /bin/sh -c "npm install npm@latest -g && npm install && npm run serve
+      -- --host 0.0.0.0 --port ${APP_PORT}"
+    working_dir: /workspace/web
+    volumes:
+      - ..:/workspace:cached
+    ports:
+      - "8080:${APP_PORT}"
+    networks:
+      dev:
+        aliases:
+          - tactical-frontend
+
   # nats
   nats-dev:
     container_name: trmm-nats-dev
     image: ${IMAGE_REPO}tactical-nats:${VERSION}
     restart: always
-    user: 1000:1000
     environment:
       API_HOST: ${API_HOST}
       API_PORT: ${API_PORT}
@@ -48,7 +62,6 @@ services:
     container_name: trmm-meshcentral-dev
     image: ${IMAGE_REPO}tactical-meshcentral:${VERSION}
     restart: always
-    user: 1000:1000
     environment:
       MESH_HOST: ${MESH_HOST}
       MESH_USER: ${MESH_USER}
@@ -72,7 +85,6 @@ services:
     container_name: trmm-mongodb-dev
     image: mongo:4.4
     restart: always
-    user: 1000:1000
     environment:
       MONGO_INITDB_ROOT_USERNAME: ${MONGODB_USER}
       MONGO_INITDB_ROOT_PASSWORD: ${MONGODB_PASSWORD}
@@ -90,7 +102,7 @@ services:
     image: postgres:13-alpine
     restart: always
     environment:
-      POSTGRES_DB: ${POSTGRES_DB}
+      POSTGRES_DB: tacticalrmm
       POSTGRES_USER: ${POSTGRES_USER}
       POSTGRES_PASSWORD: ${POSTGRES_PASS}
     volumes:
@@ -104,8 +116,7 @@ services:
   redis-dev:
     container_name: trmm-redis-dev
     restart: always
-    user: 1000:1000
-    command: redis-server
+    command: redis-server --appendonly yes
     image: redis:6.0-alpine
     volumes:
       - redis-data-dev:/data
@@ -130,7 +141,6 @@ services:
       TRMM_PASS: ${TRMM_PASS}
       HTTP_PROTOCOL: ${HTTP_PROTOCOL}
       APP_PORT: ${APP_PORT}
-      POSTGRES_DB: ${POSTGRES_DB}
     depends_on:
       - postgres-dev
       - meshcentral-dev
@@ -138,9 +148,6 @@ services:
       - dev
     volumes:
       - tactical-data-dev:/opt/tactical
-      - mesh-data-dev:/meshcentral-data
-      - redis-data-dev:/redis/data
-      - mongo-dev-data:/mongo/data/db
       - ..:/workspace:cached
 
   # container for celery worker service
@@ -149,7 +156,6 @@ services:
     image: api-dev
     command: [ "tactical-celery-dev" ]
     restart: always
-    user: 1000:1000
     networks:
       - dev
     volumes:
@@ -165,7 +171,6 @@ services:
     image: api-dev
     command: [ "tactical-celerybeat-dev" ]
     restart: always
-    user: 1000:1000
     networks:
       - dev
     volumes:
@@ -181,7 +186,6 @@ services:
     image: api-dev
     command: [ "tactical-websockets-dev" ]
     restart: always
-    user: 1000:1000
     networks:
       dev:
         aliases:
@@ -198,7 +202,6 @@ services:
     container_name: trmm-nginx-dev
     image: ${IMAGE_REPO}tactical-nginx:${VERSION}
     restart: always
-    user: 1000:1000
     environment:
       APP_HOST: ${APP_HOST}
       API_HOST: ${API_HOST}
@@ -212,11 +215,23 @@ services:
       dev:
         ipv4_address: ${DOCKER_NGINX_IP}
     ports:
-      - "80:8080"
-      - "443:4443"
+      - "80:80"
+      - "443:443"
     volumes:
       - tactical-data-dev:/opt/tactical
 
+  mkdocs-dev:
+    container_name: trmm-mkdocs-dev
+    image: api-dev
+    restart: always
+    command: [ "tactical-mkdocs-dev" ]
+    ports:
+      - "8005:8005"
+    volumes:
+      - ..:/workspace:cached
+    networks:
+      - dev
+
 volumes:
   tactical-data-dev: null
   postgres-data-dev: null

.devcontainer/entrypoint.sh

@@ -10,12 +10,15 @@ set -e
 : "${POSTGRES_PASS:=tactical}"
 : "${POSTGRES_DB:=tacticalrmm}"
 : "${MESH_SERVICE:=tactical-meshcentral}"
-: "${MESH_WS_URL:=ws://${MESH_SERVICE}:4443}"
+: "${MESH_WS_URL:=ws://${MESH_SERVICE}:443}"
 : "${MESH_USER:=meshcentral}"
 : "${MESH_PASS:=meshcentralpass}"
 : "${MESH_HOST:=tactical-meshcentral}"
 : "${API_HOST:=tactical-backend}"
+: "${APP_HOST:=tactical-frontend}"
 : "${REDIS_HOST:=tactical-redis}"
+: "${HTTP_PROTOCOL:=http}"
+: "${APP_PORT:=8080}"
 : "${API_PORT:=8000}"
 
 : "${CERT_PRIV_PATH:=${TACTICAL_DIR}/certs/privkey.pem}"
@@ -38,7 +41,7 @@ function django_setup {
     sleep 5
   done
 
-  until (echo > /dev/tcp/"${MESH_SERVICE}"/4443) &> /dev/null; do
+  until (echo > /dev/tcp/"${MESH_SERVICE}"/443) &> /dev/null; do
     echo "waiting for meshcentral container to be ready..."
     sleep 5
   done
@@ -57,12 +60,10 @@ DEBUG = True
 
 DOCKER_BUILD = True
 
-SWAGGER_ENABLED = True
-
 CERT_FILE = '${CERT_PUB_PATH}'
 KEY_FILE = '${CERT_PRIV_PATH}'
 
-SCRIPTS_DIR = '/community-scripts'
+SCRIPTS_DIR = '${WORKSPACE_DIR}/scripts'
 
 ALLOWED_HOSTS = ['${API_HOST}', '*']
 
@@ -93,7 +94,6 @@ EOF
   echo "${localvars}" > ${WORKSPACE_DIR}/api/tacticalrmm/tacticalrmm/local_settings.py
 
   # run migrations and init scripts
-  "${VIRTUAL_ENV}"/bin/python manage.py pre_update_tasks
   "${VIRTUAL_ENV}"/bin/python manage.py migrate --no-input
   "${VIRTUAL_ENV}"/bin/python manage.py collectstatic --no-input
   "${VIRTUAL_ENV}"/bin/python manage.py initial_db_setup
@@ -103,7 +103,7 @@ EOF
   "${VIRTUAL_ENV}"/bin/python manage.py reload_nats
   "${VIRTUAL_ENV}"/bin/python manage.py create_natsapi_conf
   "${VIRTUAL_ENV}"/bin/python manage.py create_installer_user
-  "${VIRTUAL_ENV}"/bin/python manage.py post_update_tasks
+    "${VIRTUAL_ENV}"/bin/python manage.py post_update_tasks
   
 
   # create super user 
@@ -117,28 +117,22 @@ if [ "$1" = 'tactical-init-dev' ]; then
 
   test -f "${TACTICAL_READY_FILE}" && rm "${TACTICAL_READY_FILE}"
 
-  mkdir -p /meshcentral-data
-  mkdir -p ${TACTICAL_DIR}/tmp
-  mkdir -p ${TACTICAL_DIR}/certs
-  mkdir -p /mongo/data/db
-  mkdir -p /redis/data
-  touch /meshcentral-data/.initialized && chown -R 1000:1000 /meshcentral-data
-  touch ${TACTICAL_DIR}/tmp/.initialized && chown -R 1000:1000 ${TACTICAL_DIR}
-  touch ${TACTICAL_DIR}/certs/.initialized && chown -R 1000:1000 ${TACTICAL_DIR}/certs
-  touch /mongo/data/db/.initialized && chown -R 1000:1000 /mongo/data/db
-  touch /redis/data/.initialized && chown -R 1000:1000 /redis/data
-  mkdir -p ${TACTICAL_DIR}/api/tacticalrmm/private/exe
-  mkdir -p ${TACTICAL_DIR}/api/tacticalrmm/private/log
-  touch ${TACTICAL_DIR}/api/tacticalrmm/private/log/django_debug.log
-
   # setup Python virtual env and install dependencies
   ! test -e "${VIRTUAL_ENV}" && python -m venv ${VIRTUAL_ENV}
-  "${VIRTUAL_ENV}"/bin/python -m pip install --upgrade pip
-  "${VIRTUAL_ENV}"/bin/pip install --no-cache-dir setuptools wheel
   "${VIRTUAL_ENV}"/bin/pip install --no-cache-dir -r /requirements.txt
 
   django_setup
 
+  # create .env file for frontend
+  webenv="$(cat << EOF
+PROD_URL = "${HTTP_PROTOCOL}://${API_HOST}"
+DEV_URL = "${HTTP_PROTOCOL}://${API_HOST}"
+APP_URL = "https://${APP_HOST}"
+DOCKER_BUILD = 1
+EOF
+)"
+  echo "${webenv}" | tee "${WORKSPACE_DIR}"/web/.env > /dev/null
+
   # chown everything to tactical user
   chown -R "${TACTICAL_USER}":"${TACTICAL_USER}" "${WORKSPACE_DIR}"
   chown -R "${TACTICAL_USER}":"${TACTICAL_USER}" "${TACTICAL_DIR}"
@@ -167,3 +161,8 @@ if [ "$1" = 'tactical-websockets-dev' ]; then
   check_tactical_ready
   "${VIRTUAL_ENV}"/bin/daphne tacticalrmm.asgi:application --port 8383 -b 0.0.0.0
 fi
+
+if [ "$1" = 'tactical-mkdocs-dev' ]; then
+  cd "${WORKSPACE_DIR}/docs"
+  "${VIRTUAL_ENV}"/bin/mkdocs serve
+fi

.devcontainer/requirements.txt

@@ -1,3 +1,39 @@
--r /workspace/api/tacticalrmm/requirements.txt
--r /workspace/api/tacticalrmm/requirements-dev.txt
--r /workspace/api/tacticalrmm/requirements-test.txt
+# To ensure app dependencies are ported from your virtual environment/host machine into your container, run 'pip freeze > requirements.txt' in the terminal to overwrite this file
+asyncio-nats-client
+celery
+channels
+channels_redis
+django-ipware
+Django==3.2.10
+django-cors-headers
+django-rest-knox
+djangorestframework
+loguru
+msgpack
+psycopg2-binary
+pycparser
+pycryptodome
+pyotp
+pyparsing
+pytz
+qrcode
+redis
+twilio
+packaging
+validators
+websockets
+black
+Werkzeug
+django-extensions
+coverage
+coveralls
+model_bakery
+mkdocs
+mkdocs-material
+pymdown-extensions
+Pygments
+mypy
+pysnooper
+isort
+drf_spectacular
+pandas

.github/FUNDING.yml

@@ -1,9 +1,9 @@
 # These are supported funding model platforms
 
-github: amidaware
+github: wh1te909
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
-ko_fi: # tacticalrmm
+ko_fi: tacticalrmm
 tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 liberapay: # Replace with a single Liberapay username

.github/workflows/ci-tests.yml

@@ -1,74 +0,0 @@
-name: Tests CI
-
-on:
-  push:
-    branches:
-      - "*"
-  pull_request:
-    branches:
-      - "*"
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    name: Tests
-    strategy:
-      matrix:
-        python-version: ["3.10.8"]
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: harmon758/postgresql-action@v1
-        with:
-          postgresql version: "14"
-          postgresql db: "pipeline"
-          postgresql user: "pipeline"
-          postgresql password: "pipeline123456"
-
-      - name: Setup Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-          check-latest: true
-
-      - name: Install redis
-        run: |
-          sudo apt update
-          sudo apt install -y redis
-          redis-server --version
-
-      - name: Install requirements
-        working-directory: api/tacticalrmm
-        run: |
-          python --version
-          SETTINGS_FILE="tacticalrmm/settings.py"
-          SETUPTOOLS_VER=$(grep "^SETUPTOOLS_VER" "$SETTINGS_FILE" | awk -F'[= "]' '{print $5}')
-          WHEEL_VER=$(grep "^WHEEL_VER" "$SETTINGS_FILE" | awk -F'[= "]' '{print $5}')
-          pip install --upgrade pip
-          pip install setuptools==${SETUPTOOLS_VER} wheel==${WHEEL_VER}
-          pip install -r requirements.txt -r requirements-test.txt
-
-      - name: Codestyle black
-        working-directory: api
-        run: |
-          black --exclude migrations/ --check tacticalrmm
-          if [ $? -ne 0 ]; then
-              exit 1
-          fi
-
-      - name: Run django tests
-        env:
-          GHACTIONS: "yes"
-        working-directory: api/tacticalrmm
-        run: |
-          pytest
-          if [ $? -ne 0 ]; then
-              exit 1
-          fi
-
-      - uses: codecov/codecov-action@v3
-        with:
-          directory: ./api/tacticalrmm
-          files: ./api/tacticalrmm/coverage.xml
-          verbose: true

.github/workflows/codeql-analysis.yml

@@ -32,7 +32,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        language: [ 'go', 'python' ]
+        language: [ 'go', 'javascript', 'python' ]
         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
         # Learn more about CodeQL language support at https://git.io/codeql-language-support
 

.github/workflows/deploy-docs.yml

@@ -0,0 +1,22 @@
+name: Deploy Docs
+on:
+  push:
+    branches:
+      - master
+
+defaults:
+  run:
+    working-directory: docs
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+      - run: pip install --upgrade pip
+      - run: pip install --upgrade setuptools wheel
+      - run: pip install mkdocs mkdocs-material pymdown-extensions
+      - run: mkdocs gh-deploy --force

.github/workflows/devskim-analysis.yml

@@ -0,0 +1,34 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: DevSkim
+
+on:
+  push:
+    branches: [ develop ]
+  pull_request:
+    branches: [ develop ]
+  schedule:
+    - cron: '19 5 * * 0'
+
+jobs:
+  lint:
+    name: DevSkim
+    runs-on: ubuntu-20.04
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Run DevSkim scanner
+        uses: microsoft/DevSkim-Action@v1
+        
+      - name: Upload DevSkim scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@v1
+        with:
+          sarif_file: devskim-results.sarif

.gitignore

@@ -50,9 +50,4 @@ docs/site/
 reset_db.sh
 run_go_cmd.py
 nats-api.conf
-ignore/
-coverage.lcov
-daphne.sock.lock
-.pytest_cache
-coverage.xml
-setup_dev.yml
+

.vscode/extensions.json

@@ -1,23 +0,0 @@
-{
-  "recommendations": [
-    // frontend
-    "dbaeumer.vscode-eslint",
-    "esbenp.prettier-vscode",
-    "editorconfig.editorconfig",
-    "vue.volar",
-    "wayou.vscode-todo-highlight",
-
-    // python
-    "matangover.mypy",
-    "ms-python.python",
-
-    // golang
-    "golang.go"
-  ],
-  "unwantedRecommendations": [
-    "octref.vetur",
-    "hookyqr.beautify",
-    "dbaeumer.jshint",
-    "ms-vscode.vscode-typescript-tslint-plugin"
-  ]
-}

.vscode/settings.json

@@ -1,78 +1,70 @@
 {
-  "python.defaultInterpreterPath": "api/env/bin/python",
-  "python.languageServer": "Pylance",
-  "python.analysis.extraPaths": [
-    "api/tacticalrmm",
-    "api/env"
-  ],
-  "python.analysis.diagnosticSeverityOverrides": {
-    "reportUnusedImport": "error",
-    "reportDuplicateImport": "error",
-    "reportGeneralTypeIssues": "none"
-  },
-  "python.analysis.typeCheckingMode": "basic",
-  "python.linting.enabled": true,
-  "python.linting.mypyEnabled": true,
-  "python.linting.mypyArgs": [
-    "--ignore-missing-imports",
-    "--follow-imports=silent",
-    "--show-column-numbers",
-    "--strict"
-  ],
-  "python.linting.ignorePatterns": [
-    "**/site-packages/**/*.py",
-    ".vscode/*.py",
-    "**env/**"
-  ],
-  "python.formatting.provider": "black",
-  "mypy.targets": [
-    "api/tacticalrmm"
-  ],
-  "mypy.runUsingActiveInterpreter": true,
-  "editor.bracketPairColorization.enabled": true,
-  "editor.guides.bracketPairs": true,
-  "editor.formatOnSave": true,
-  "files.associations": {
-    "**/ansible/**/*.yml": "ansible",
-    "**/docker/**/docker-compose*.yml": "dockercompose"
-  },
-  "files.watcherExclude": {
-    "files.watcherExclude": {
-      "**/.git/objects/**": true,
-      "**/.git/subtree-cache/**": true,
-      "**/node_modules/": true,
-      "/node_modules/**": true,
-      "**/env/": true,
-      "/env/**": true,
-      "**/__pycache__": true,
-      "/__pycache__/**": true,
-      "**/.cache": true,
-      "**/.eggs": true,
-      "**/.ipynb_checkpoints": true,
-      "**/.mypy_cache": true,
-      "**/.pytest_cache": true,
-      "**/*.egg-info": true,
-      "**/*.feather": true,
-      "**/*.parquet*": true,
-      "**/*.pyc": true,
-      "**/*.zip": true
-    }
-  },
-  "go.useLanguageServer": true,
-  "[go]": {
-    "editor.codeActionsOnSave": {
-      "source.organizeImports": false
+    "python.pythonPath": "api/tacticalrmm/env/bin/python",
+    "python.languageServer": "Pylance",
+    "python.analysis.extraPaths": [
+        "api/tacticalrmm",
+        "api/env",
+    ],
+    "python.analysis.diagnosticSeverityOverrides": {
+        "reportUnusedImport": "error",
+        "reportDuplicateImport": "error",
     },
-    "editor.snippetSuggestions": "none"
-  },
-  "[go.mod]": {
-    "editor.codeActionsOnSave": {
-      "source.organizeImports": true
+    "python.analysis.memory.keepLibraryAst": true,
+    "python.linting.mypyEnabled": true,
+    "python.analysis.typeCheckingMode": "basic",
+    "python.formatting.provider": "black",
+    "editor.formatOnSave": true,
+    "vetur.format.defaultFormatter.js": "prettier",
+    "vetur.format.defaultFormatterOptions": {
+        "prettier": {
+            "semi": true,
+            "printWidth": 120,
+            "tabWidth": 2,
+            "useTabs": false,
+            "arrowParens": "avoid",
+        }
+    },
+    "vetur.format.options.tabSize": 2,
+    "vetur.format.options.useTabs": false,
+    "files.watcherExclude": {
+        "files.watcherExclude": {
+            "**/.git/objects/**": true,
+            "**/.git/subtree-cache/**": true,
+            "**/node_modules/": true,
+            "/node_modules/**": true,
+            "**/env/": true,
+            "/env/**": true,
+            "**/__pycache__": true,
+            "/__pycache__/**": true,
+            "**/.cache": true,
+            "**/.eggs": true,
+            "**/.ipynb_checkpoints": true,
+            "**/.mypy_cache": true,
+            "**/.pytest_cache": true,
+            "**/*.egg-info": true,
+            "**/*.feather": true,
+            "**/*.parquet*": true,
+            "**/*.pyc": true,
+            "**/*.zip": true
+        },
+    },
+    "go.useLanguageServer": true,
+    "[go]": {
+        "editor.formatOnSave": true,
+        "editor.codeActionsOnSave": {
+            "source.organizeImports": false,
+        },
+        "editor.snippetSuggestions": "none",
+    },
+    "[go.mod]": {
+        "editor.formatOnSave": true,
+        "editor.codeActionsOnSave": {
+            "source.organizeImports": true,
+        },
+    },
+    "gopls": {
+        "usePlaceholders": true,
+        "completeUnimported": true,
+        "staticcheck": true,
     }
-  },
-  "gopls": {
-    "usePlaceholders": true,
-    "completeUnimported": true,
-    "staticcheck": true
-  }
 }

.vscode/tasks.json

@@ -0,0 +1,23 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "docker debug",
+            "type": "shell",
+            "command": "docker-compose",
+            "args": [
+                "-p",
+                "trmm",
+                "-f",
+                ".devcontainer/docker-compose.yml",
+                "-f",
+                ".devcontainer/docker-compose.debug.yml",
+                "up",
+                "-d",
+                "--build"
+            ]
+        }
+    ]
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present wh1te909
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.md

@@ -1,74 +0,0 @@
-### Tactical RMM License Version 1.0
-
-Text of license:&emsp;&emsp;&emsp;Copyright © 2022 AmidaWare LLC.  All rights reserved.<br>
-&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&nbsp;Amending the text of this license is not permitted.
-
-Trade Mark:&emsp;&emsp;&emsp;&emsp;"Tactical RMM" is a trade mark of AmidaWare LLC.
-
-Licensor:&emsp;&emsp;&emsp;&emsp;&emsp;&nbsp;&nbsp;AmidaWare LLC of 1968 S Coast Hwy PMB 3847 Laguna Beach, CA, USA.
-
-Licensed Software:&emsp;&nbsp;The software known as Tactical RMM Version v0.12.0 (and all subsequent releases and versions) and the Tactical RMM Agent v2.0.0 (and all subsequent releases and versions).
-
-### 1. Preamble
-The Licensed Software is designed to facilitate the remote monitoring and management (RMM) of networks, systems, servers, computers and other devices.  The Licensed Software is made available primarily for use by organisations and managed service providers for monitoring and management purposes.
-
-The Tactical RMM License is not an open-source software license.  This license contains certain restrictions on the use of the Licensed Software.  For example the functionality of the Licensed Software may not be made available as part of a SaaS (Software-as-a-Service) service or product to provide a commercial or for-profit service without the express prior permission of the Licensor.
-
-### 2. License Grant
-Permission is hereby granted, free of charge, on a non-exclusive basis, to copy, modify, create derivative works and use the Licensed Software in source and binary forms subject to the following terms and conditions.  No additional rights will be implied under this license.
-
-* The hosting and use of the Licensed Software to monitor and manage in-house networks/systems and/or customer networks/systems is permitted.
-
-This license does not allow the functionality of the Licensed Software (whether in whole or in part) or a modified version of the Licensed Software or a derivative work to be used or otherwise made available as part of any other commercial or for-profit service, including, without limitation, any of the following:
-* a service allowing third parties to interact remotely through a computer network;
-* as part of a SaaS service or product;
-* as part of the provision of a managed hosting service or product;
-* the offering of installation and/or configuration services;
-* the offer for sale, distribution or sale of any service or product (whether or not branded as Tactical RMM).
-
-The prior written approval of AmidaWare LLC must be obtained for all commercial use and/or for-profit service use of the (i) Licensed Software (whether in whole or in part), (ii) a modified version of the Licensed Software and/or (iii) a derivative work.
-
-The terms of this license apply to all copies of the Licensed Software (including modified versions) and derivative works.
-
-All use of the Licensed Software must immediately cease if use breaches the terms of this license.
-
-### 3. Derivative Works
-If a derivative work is created which is based on or otherwise incorporates all or any part of the Licensed Software, and the derivative work is made available to any other person, the complete corresponding machine readable source code (including all changes made to the Licensed Software) must accompany the derivative work and be made publicly available online.
-
-### 4. Copyright Notice
-The following copyright notice shall be included in all copies of the Licensed Software:
-
-&emsp;&emsp;&emsp;Copyright © 2022 AmidaWare LLC.
-
-&emsp;&emsp;&emsp;Licensed under the Tactical RMM License Version 1.0 (the “License”).<br>
-&emsp;&emsp;&emsp;You may only use the Licensed Software in accordance with the License.<br>
-&emsp;&emsp;&emsp;A copy of the License is available at: https://license.tacticalrmm.com
-
-### 5. Disclaimer of Warranty
-THE LICENSED SOFTWARE IS PROVIDED "AS IS".  TO THE FULLEST EXTENT PERMISSIBLE AT LAW ALL CONDITIONS, WARRANTIES OR OTHER TERMS OF ANY KIND WHICH MIGHT HAVE EFFECT OR BE IMPLIED OR INCORPORATED, WHETHER BY STATUTE, COMMON LAW OR OTHERWISE ARE HEREBY EXCLUDED, INCLUDING THE CONDITIONS, WARRANTIES OR OTHER TERMS AS TO SATISFACTORY QUALITY AND/OR MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, THE USE OF REASONABLE SKILL AND CARE AND NON-INFRINGEMENT.
-
-### 6. Limits of Liability
-THE FOLLOWING EXCLUSIONS SHALL APPLY TO THE FULLEST EXTENT PERMISSIBLE AT LAW.  NEITHER THE AUTHORS NOR THE COPYRIGHT HOLDERS SHALL IN ANY CIRCUMSTANCES HAVE ANY LIABILITY FOR ANY CLAIM, LOSSES, DAMAGES OR OTHER LIABILITY, WHETHER THE SAME ARE SUFFERED DIRECTLY OR INDIRECTLY OR ARE IMMEDIATE OR CONSEQUENTIAL, AND WHETHER THE SAME ARISE IN CONTRACT, TORT OR DELICT (INCLUDING NEGLIGENCE) OR OTHERWISE HOWSOEVER ARISING FROM, OUT OF OR IN CONNECTION WITH THE LICENSED SOFTWARE OR THE USE OR INABILITY TO USE THE LICENSED SOFTWARE OR OTHER DEALINGS IN THE LICENSED SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE.  THE FOREGOING EXCLUSIONS SHALL INCLUDE, WITHOUT LIMITATION, LIABILITY FOR ANY LOSSES OR DAMAGES WHICH FALL WITHIN ANY OF THE FOLLOWING CATEGORIES: SPECIAL, EXEMPLARY, OR INCIDENTAL LOSS OR DAMAGE, LOSS OF PROFITS, LOSS OF ANTICIPATED SAVINGS, LOSS OF BUSINESS OPPORTUNITY, LOSS OF GOODWILL, AND LOSS OR CORRUPTION OF DATA.
-
-### 7. Termination
-This license shall terminate with immediate effect if there is a material breach of any of its terms.
-
-### 8. No partnership, agency or joint venture
-Nothing in this license agreement is intended to, or shall be deemed to, establish any partnership or joint venture or any relationship of agency between AmidaWare LLC and any other person.
-
-### 9. No endorsement
-The names of the authors and/or the copyright holders must not be used to promote or endorse any products or services which are in any way derived from the Licensed Software without prior written consent.
-
-### 10. Trademarks
-No permission is granted to use the trademark “Tactical RMM” or any other trade name, trademark, service mark or product name of AmidaWare LLC except to the extent necessary to comply with the notice requirements in Section 4 (Copyright Notice).
-
-### 11. Entire agreement
-This license contains the whole agreement relating to its subject matter.
-
-
-
-### 12. Severance
-If any provision or part-provision of this license is or becomes invalid, illegal or unenforceable, it shall be deemed deleted, but that shall not affect the validity and enforceability of the rest of this license.
-
-### 13. Acceptance of these terms
-The terms and conditions of this license are accepted by copying, downloading, installing, redistributing, or otherwise using the Licensed Software.

README.md

@@ -1,18 +1,19 @@
 # Tactical RMM
 
-![CI Tests](https://github.com/amidaware/tacticalrmm/actions/workflows/ci-tests.yml/badge.svg?branch=develop)
-[![codecov](https://codecov.io/gh/amidaware/tacticalrmm/branch/develop/graph/badge.svg?token=8ACUPVPTH6)](https://codecov.io/gh/amidaware/tacticalrmm)
+[![Build Status](https://dev.azure.com/dcparsi/Tactical%20RMM/_apis/build/status/wh1te909.tacticalrmm?branchName=develop)](https://dev.azure.com/dcparsi/Tactical%20RMM/_build/latest?definitionId=4&branchName=develop)
+[![Coverage Status](https://coveralls.io/repos/github/wh1te909/tacticalrmm/badge.png?branch=develop&kill_cache=1)](https://coveralls.io/github/wh1te909/tacticalrmm?branch=develop)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
 
-Tactical RMM is a remote monitoring & management tool, built with Django and Vue.\
-It uses an [agent](https://github.com/amidaware/rmmagent) written in golang and integrates with [MeshCentral](https://github.com/Ylianst/MeshCentral)
+Tactical RMM is a remote monitoring & management tool for Windows computers, built with Django and Vue.\
+It uses an [agent](https://github.com/wh1te909/rmmagent) written in golang and integrates with [MeshCentral](https://github.com/Ylianst/MeshCentral)
 
-# [LIVE DEMO](https://demo.tacticalrmm.com/)
+# [LIVE DEMO](https://rmm.tacticalrmm.io/)
 Demo database resets every hour. A lot of features are disabled for obvious reasons due to the nature of this app.
 
 ### [Discord Chat](https://discord.gg/upGTkWp)
 
-### [Documentation](https://docs.tacticalrmm.com)
+### [Documentation](https://wh1te909.github.io/tacticalrmm/)
 
 ## Features
 
@@ -28,16 +29,10 @@ Demo database resets every hour. A lot of features are disabled for obvious reas
 - Remote software installation via chocolatey
 - Software and hardware inventory
 
-## Windows agent versions supported
+## Windows versions supported
 
-- Windows 7, 8.1, 10, 11, Server 2008R2, 2012R2, 2016, 2019, 2022
-
-## Linux agent versions supported
-- Any distro with systemd which includes but is not limited to: Debian (10, 11), Ubuntu x86_64 (18.04, 20.04, 22.04), Synology 7, centos, freepbx and more!
-
-## Mac agent versions supported
-- 64 bit Intel and Apple Silicon (M1, M2)
+- Windows 7, 8.1, 10, Server 2008R2, 2012R2, 2016, 2019
 
 ## Installation / Backup / Restore / Usage
 
-### Refer to the [documentation](https://docs.tacticalrmm.com)
+### Refer to the [documentation](https://wh1te909.github.io/tacticalrmm/)

SECURITY.md

@@ -2,8 +2,18 @@
 
 ## Supported Versions
 
-[Latest](https://github.com/amidaware/tacticalrmm/releases/latest) release
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 0.10.4   | :white_check_mark: |
+| < 0.10.4| :x:                |
 
 ## Reporting a Vulnerability
 
-https://docs.tacticalrmm.com/security
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.

ansible/README.md

@@ -1,3 +0,0 @@
-### tacticalrmm ansible WIP
-
-ansible role to setup a Debian 11 VM for tacticalrmm local development

ansible/roles/trmm_dev/defaults/main.yml

@@ -1,40 +0,0 @@
----
-user: "tactical"
-python_ver: "3.10.8"
-go_ver: "1.18.5"
-backend_repo: "https://github.com/amidaware/tacticalrmm.git"
-frontend_repo: "https://github.com/amidaware/tacticalrmm-web.git"
-scripts_repo: "https://github.com/amidaware/community-scripts.git"
-backend_dir: "/opt/trmm"
-frontend_dir: "/opt/trmm-web"
-scripts_dir: "/opt/trmm-community-scripts"
-trmm_dir: "{{ backend_dir }}/api/tacticalrmm/tacticalrmm"
-mesh_dir: "/opt/meshcentral"
-settings_file: "{{ trmm_dir }}/settings.py"
-local_settings_file: "{{ trmm_dir }}/local_settings.py"
-fullchain_dest: /etc/ssl/certs/fullchain.pem
-privkey_dest: /etc/ssl/certs/privkey.pem
-
-base_pkgs:
-  - build-essential
-  - curl
-  - wget
-  - dirmngr
-  - gnupg
-  - openssl
-  - gcc
-  - g++
-  - make
-  - ca-certificates
-  - git
-
-python_pkgs:
-  - zlib1g-dev
-  - libncurses5-dev
-  - libgdbm-dev
-  - libnss3-dev
-  - libssl-dev
-  - libreadline-dev
-  - libffi-dev
-  - libsqlite3-dev
-  - libbz2-dev

ansible/roles/trmm_dev/files/nginx-default.conf

@@ -1,31 +0,0 @@
-worker_rlimit_nofile 1000000;
-user www-data;
-worker_processes auto;
-pid /run/nginx.pid;
-include /etc/nginx/modules-enabled/*.conf;
-
-events {
-        worker_connections 4096;
-}
-
-http {
-        sendfile on;
-        server_tokens off;
-        tcp_nopush on;
-        types_hash_max_size 2048;
-        server_names_hash_bucket_size 64;
-        include /etc/nginx/mime.types;
-        default_type application/octet-stream;
-        ssl_protocols TLSv1.2 TLSv1.3;
-        ssl_prefer_server_ciphers on;
-        ssl_ciphers EECDH+AESGCM:EDH+AESGCM;
-        ssl_ecdh_curve secp384r1;
-        ssl_stapling on;
-        ssl_stapling_verify on;
-        add_header X-Content-Type-Options nosniff;
-        access_log /var/log/nginx/access.log;
-        error_log /var/log/nginx/error.log;
-        gzip on;
-        include /etc/nginx/conf.d/*.conf;
-        include /etc/nginx/sites-enabled/*;
-}

ansible/roles/trmm_dev/files/nginx.repo

@@ -1,2 +0,0 @@
-deb https://nginx.org/packages/debian/ bullseye nginx
-deb-src https://nginx.org/packages/debian/ bullseye nginx

ansible/roles/trmm_dev/files/vimrc.local

@@ -1,20 +0,0 @@
-" This file loads the default vim options at the beginning and prevents
-" that they are being loaded again later. All other options that will be set,
-" are added, or overwrite the default settings. Add as many options as you
-" whish at the end of this file.
-
-" Load the defaults
-source $VIMRUNTIME/defaults.vim
-
-" Prevent the defaults from being loaded again later, if the user doesn't
-" have a local vimrc (~/.vimrc)
-let skip_defaults_vim = 1
-
-
-" Set more options (overwrites settings from /usr/share/vim/vim80/defaults.vim)
-" Add as many options as you whish
-
-" Set the mouse mode to 'r'
-if has('mouse')
-  set mouse=r
-endif

ansible/roles/trmm_dev/tasks/main.yml

@@ -1,633 +0,0 @@
----
-- name: set mouse mode for vim
-  tags: vim
-  become: yes
-  ansible.builtin.copy:
-    src: vimrc.local
-    dest: /etc/vim/vimrc.local
-    owner: "root"
-    group: "root"
-    mode: "0644"
-
-- name: set max_user_watches
-  tags: sysctl
-  become: yes
-  ansible.builtin.lineinfile:
-    path: /etc/sysctl.conf
-    line: fs.inotify.max_user_watches=524288
-
-- name: reload sysctl
-  tags: sysctl
-  become: yes
-  ansible.builtin.command:
-    cmd: sysctl -p
-
-- name: install base packages
-  tags: base
-  become: yes
-  ansible.builtin.apt:
-    pkg: "{{ item }}"
-    state: present
-    update_cache: yes
-  with_items:
-    - "{{ base_pkgs }}"
-
-- name: download and install golang
-  tags: golang
-  become: yes
-  ansible.builtin.unarchive:
-    src: "https://go.dev/dl/go{{ go_ver }}.linux-amd64.tar.gz"
-    dest: /usr/local
-    remote_src: yes
-
-- name: add golang to path
-  become: yes
-  tags: golang
-  ansible.builtin.copy:
-    dest: /etc/profile.d/golang.sh
-    content: "PATH=$PATH:/usr/local/go/bin"
-
-- name: install python prereqs
-  tags: python
-  become: yes
-  ansible.builtin.apt:
-    pkg: "{{ item }}"
-    state: present
-  with_items:
-    - "{{ python_pkgs }}"
-
-- name: get cpu core count
-  tags: python
-  ansible.builtin.command: nproc
-  register: numprocs
-
-- name: Create python tmpdir
-  tags: python
-  ansible.builtin.tempfile:
-    state: directory
-    suffix: python
-  register: python_tmp
-
-- name: download and extract python
-  tags: python
-  ansible.builtin.unarchive:
-    src: "https://www.python.org/ftp/python/{{ python_ver }}/Python-{{ python_ver }}.tgz"
-    dest: "{{ python_tmp.path }}"
-    remote_src: yes
-
-- name: compile python
-  tags: python
-  ansible.builtin.shell:
-    chdir: "{{ python_tmp.path }}/Python-{{ python_ver }}"
-    cmd: |
-      ./configure --enable-optimizations
-      make -j {{ numprocs.stdout }}
-
-- name: alt install python
-  tags: python
-  become: yes
-  ansible.builtin.shell:
-    chdir: "{{ python_tmp.path }}/Python-{{ python_ver }}"
-    cmd: |
-      make altinstall
-
-- name: install redis
-  tags: redis
-  become: yes
-  ansible.builtin.apt:
-    pkg: redis
-    state: present
-
-- name: create postgres repo
-  tags: postgres
-  become: yes
-  ansible.builtin.copy:
-    content: "deb http://apt.postgresql.org/pub/repos/apt bullseye-pgdg main"
-    dest: /etc/apt/sources.list.d/pgdg.list
-    owner: root
-    group: root
-    mode: "0644"
-
-- name: import postgres repo signing key
-  tags: postgres
-  become: yes
-  ansible.builtin.apt_key:
-    url: https://www.postgresql.org/media/keys/ACCC4CF8.asc
-    state: present
-
-- name: install postgresql
-  tags: postgres
-  become: yes
-  ansible.builtin.apt:
-    pkg: postgresql-14
-    state: present
-    update_cache: yes
-
-- name: ensure postgres enabled and started
-  tags: postgres
-  become: yes
-  ansible.builtin.service:
-    name: postgresql
-    enabled: yes
-    state: started
-
-- name: setup database
-  tags: postgres
-  become: yes
-  become_user: postgres
-  ansible.builtin.shell:
-    cmd: |
-      psql -c "CREATE DATABASE tacticalrmm"
-      psql -c "CREATE USER {{ db_user }} WITH PASSWORD '{{ db_passwd }}'"
-      psql -c "ALTER ROLE {{ db_user }} SET client_encoding TO 'utf8'"
-      psql -c "ALTER ROLE {{ db_user }} SET default_transaction_isolation TO 'read committed'"
-      psql -c "ALTER ROLE {{ db_user }} SET timezone TO 'UTC'"
-      psql -c "ALTER ROLE {{ db_user }} CREATEDB"
-      psql -c "GRANT ALL PRIVILEGES ON DATABASE tacticalrmm TO {{ db_user }}"
-
-- name: create repo dirs
-  become: yes
-  tags: git
-  ansible.builtin.file:
-    path: "{{ item }}"
-    state: directory
-    owner: "{{ user }}"
-    group: "{{ user }}"
-    mode: "0755"
-  with_items:
-    - "{{ backend_dir }}"
-    - "{{ frontend_dir }}"
-    - "{{ scripts_dir }}"
-
-- name: git clone repos
-  tags: git
-  ansible.builtin.git:
-    repo: "{{ item.repo }}"
-    dest: "{{ item.dest }}"
-    version: "{{ item.version }}"
-  with_items:
-    - {
-        repo: "{{ backend_repo }}",
-        dest: "{{ backend_dir }}",
-        version: develop,
-      }
-    - {
-        repo: "{{ frontend_repo }}",
-        dest: "{{ frontend_dir }}",
-        version: develop,
-      }
-    - { repo: "{{ scripts_repo }}", dest: "{{ scripts_dir }}", version: main }
-
-- name: get nats_server_ver
-  tags: nats
-  ansible.builtin.shell: grep "^NATS_SERVER_VER" {{ settings_file }} | awk -F'[= "]' '{print $5}'
-  register: nats_server_ver
-
-- name: Create nats tmpdir
-  tags: nats
-  ansible.builtin.tempfile:
-    state: directory
-    suffix: nats
-  register: nats_tmp
-
-- name: download and extract nats
-  tags: nats
-  ansible.builtin.unarchive:
-    src: "https://github.com/nats-io/nats-server/releases/download/v{{ nats_server_ver.stdout }}/nats-server-v{{ nats_server_ver.stdout }}-linux-amd64.tar.gz"
-    dest: "{{ nats_tmp.path }}"
-    remote_src: yes
-
-- name: install nats
-  tags: nats
-  become: yes
-  ansible.builtin.copy:
-    remote_src: yes
-    src: "{{ nats_tmp.path }}/nats-server-v{{ nats_server_ver.stdout }}-linux-amd64/nats-server"
-    dest: /usr/local/bin/nats-server
-    owner: "{{ user }}"
-    group: "{{ user }}"
-    mode: "0755"
-
-- name: Create nodejs tmpdir
-  tags: nodejs
-  ansible.builtin.tempfile:
-    state: directory
-    suffix: nodejs
-  register: nodejs_tmp
-
-- name: download nodejs setup
-  tags: nodejs
-  ansible.builtin.get_url:
-    url: https://deb.nodesource.com/setup_16.x
-    dest: "{{ nodejs_tmp.path }}/setup_node.sh"
-    mode: "0755"
-
-- name: run node setup script
-  tags: nodejs
-  become: yes
-  ansible.builtin.command:
-    cmd: "{{ nodejs_tmp.path }}/setup_node.sh"
-
-- name: install nodejs
-  tags: nodejs
-  become: yes
-  ansible.builtin.apt:
-    pkg: nodejs
-    state: present
-    update_cache: yes
-
-- name: update npm
-  tags: nodejs
-  become: yes
-  ansible.builtin.shell:
-    cmd: npm install -g npm
-
-- name: install quasar cli
-  tags: quasar
-  become: yes
-  ansible.builtin.shell:
-    cmd: npm install -g @quasar/cli
-
-- name: install frontend
-  tags: quasar
-  ansible.builtin.shell:
-    chdir: "{{ frontend_dir }}"
-    cmd: npm install
-
-- name: add quasar env
-  tags: quasar
-  ansible.builtin.template:
-    src: quasar.env.j2
-    dest: "{{ frontend_dir }}/.env"
-    owner: "{{ user }}"
-    group: "{{ user }}"
-    mode: "0644"
-
-- name: remove tempdirs
-  tags: cleanup
-  become: yes
-  ignore_errors: yes
-  ansible.builtin.file:
-    path: "{{ item }}"
-    state: absent
-  with_items:
-    - "{{ nats_tmp.path }}"
-    - "{{ python_tmp.path }}"
-    - "{{ nodejs_tmp.path }}"
-
-- name: deploy fullchain
-  tags: certs
-  become: yes
-  ansible.builtin.copy:
-    src: "{{ fullchain_src }}"
-    dest: "{{ fullchain_dest }}"
-    owner: "{{ user }}"
-    group: "{{ user }}"
-    mode: "0440"
-
-- name: deploy privkey
-  tags: certs
-  become: yes
-  ansible.builtin.copy:
-    src: "{{ privkey_src }}"
-    dest: "{{ privkey_dest }}"
-    owner: "{{ user }}"
-    group: "{{ user }}"
-    mode: "0440"
-
-- name: import nginx signing key
-  tags: nginx
-  become: yes
-  ansible.builtin.apt_key:
-    url: https://nginx.org/packages/keys/nginx_signing.key
-    state: present
-
-- name: add nginx repo
-  tags: nginx
-  become: yes
-  ansible.builtin.copy:
-    src: nginx.repo
-    dest: /etc/apt/sources.list.d/nginx.list
-    owner: "root"
-    group: "root"
-    mode: "0644"
-
-- name: install nginx
-  tags: nginx
-  become: yes
-  ansible.builtin.apt:
-    pkg: nginx
-    state: present
-    update_cache: yes
-
-- name: set nginx default conf
-  tags: nginx
-  become: yes
-  ansible.builtin.copy:
-    src: nginx-default.conf
-    dest: /etc/nginx/nginx.conf
-    owner: "root"
-    group: "root"
-    mode: "0644"
-
-- name: create nginx dirs
-  become: yes
-  tags: nginx
-  ansible.builtin.file:
-    state: directory
-    path: "{{ item }}"
-    mode: "0755"
-  with_items:
-    - /etc/nginx/sites-available
-    - /etc/nginx/sites-enabled
-
-- name: deploy nginx sites
-  become: yes
-  tags: nginx
-  ansible.builtin.template:
-    src: "{{ item.src }}"
-    dest: "{{ item.dest }}"
-    mode: "0644"
-    owner: root
-    group: root
-  with_items:
-    - { src: backend.nginx.j2, dest: /etc/nginx/sites-available/backend.conf }
-    - { src: mesh.nginx.j2, dest: /etc/nginx/sites-available/mesh.conf }
-
-- name: enable nginx sites
-  become: yes
-  tags: nginx
-  ansible.builtin.file:
-    src: "{{ item.src }}"
-    dest: "{{ item.dest }}"
-    mode: "0644"
-    owner: root
-    group: root
-    state: link
-  with_items:
-    - {
-        src: /etc/nginx/sites-available/backend.conf,
-        dest: /etc/nginx/sites-enabled/backend.conf,
-      }
-    - {
-        src: /etc/nginx/sites-available/mesh.conf,
-        dest: /etc/nginx/sites-enabled/mesh.conf,
-      }
-
-- name: ensure nginx enabled and restarted
-  tags: nginx
-  become: yes
-  ansible.builtin.service:
-    name: nginx
-    enabled: yes
-    state: restarted
-
-- name: copy nats-api bin
-  tags: nats-api
-  become: yes
-  ansible.builtin.copy:
-    remote_src: yes
-    src: "{{ backend_dir }}/natsapi/bin/nats-api"
-    dest: /usr/local/bin/nats-api
-    owner: "{{ user }}"
-    group: "{{ user }}"
-    mode: "0755"
-
-- name: get setuptools_ver
-  tags: pip
-  ansible.builtin.shell: grep "^SETUPTOOLS_VER" {{ settings_file }} | awk -F'[= "]' '{print $5}'
-  register: setuptools_ver
-
-- name: get wheel_ver
-  tags: pip
-  ansible.builtin.shell: grep "^WHEEL_VER" {{ settings_file }} | awk -F'[= "]' '{print $5}'
-  register: wheel_ver
-
-- name: setup virtual env
-  tags: pip
-  ansible.builtin.shell:
-    chdir: "{{ backend_dir }}/api"
-    cmd: python3.10 -m venv env
-
-- name: update pip to latest
-  tags: pip
-  ansible.builtin.pip:
-    virtualenv: "{{ backend_dir }}/api/env"
-    name: pip
-    state: latest
-
-- name: install setuptools and wheel
-  tags: pip
-  ansible.builtin.pip:
-    virtualenv: "{{ backend_dir }}/api/env"
-    name: "{{ item }}"
-  with_items:
-    - "setuptools=={{ setuptools_ver.stdout }}"
-    - "wheel=={{ wheel_ver.stdout }}"
-
-- name: install python packages
-  tags: pip
-  ansible.builtin.pip:
-    virtualenv: "{{ backend_dir }}/api/env"
-    chdir: "{{ backend_dir }}/api/tacticalrmm"
-    requirements: "{{ item }}"
-  with_items:
-    - requirements.txt
-    - requirements-dev.txt
-    - requirements-test.txt
-
-- name: deploy django local settings
-  tags: django
-  ansible.builtin.template:
-    src: local_settings.j2
-    dest: "{{ local_settings_file }}"
-    mode: "0644"
-    owner: "{{ user }}"
-    group: "{{ user }}"
-
-- name: setup django
-  tags: django
-  ansible.builtin.shell:
-    chdir: "{{ backend_dir }}/api/tacticalrmm"
-    cmd: |
-      . ../env/bin/activate
-      python manage.py migrate --no-input
-      python manage.py collectstatic --no-input
-      python manage.py create_natsapi_conf
-      python manage.py load_chocos
-      python manage.py load_community_scripts
-      echo "from accounts.models import User; User.objects.create_superuser('{{ django_user }}', '{{ github_email }}', '{{ django_password }}') if not User.objects.filter(username='{{ django_user }}').exists() else 0;" | python manage.py shell
-      python manage.py create_installer_user
-
-- name: deploy services
-  tags: services
-  become: yes
-  ansible.builtin.template:
-    src: "{{ item.src }}"
-    dest: "{{ item.dest }}"
-    mode: "0644"
-    owner: "root"
-    group: "root"
-  with_items:
-    - { src: nats-api.systemd.j2, dest: /etc/systemd/system/nats-api.service }
-    - { src: nats-server.systemd.j2, dest: /etc/systemd/system/nats.service }
-    - { src: mesh.systemd.j2, dest: /etc/systemd/system/meshcentral.service }
-
-- name: import mongodb repo signing key
-  tags: mongo
-  become: yes
-  ansible.builtin.apt_key:
-    url: https://www.mongodb.org/static/pgp/server-4.4.asc
-    state: present
-
-- name: setup mongodb repo
-  tags: mongo
-  become: yes
-  ansible.builtin.copy:
-    content: "deb https://repo.mongodb.org/apt/debian buster/mongodb-org/4.4 main"
-    dest: /etc/apt/sources.list.d/mongodb-org-4.4.list
-    owner: root
-    group: root
-    mode: "0644"
-
-- name: install mongodb
-  tags: mongo
-  become: yes
-  ansible.builtin.apt:
-    pkg: mongodb-org
-    state: present
-    update_cache: yes
-
-- name: ensure mongodb enabled and started
-  tags: mongo
-  become: yes
-  ansible.builtin.service:
-    name: mongod
-    enabled: yes
-    state: started
-
-- name: get mesh_ver
-  tags: mesh
-  ansible.builtin.shell: grep "^MESH_VER" {{ settings_file }} | awk -F'[= "]' '{print $5}'
-  register: mesh_ver
-
-- name: create meshcentral data directory
-  tags: mesh
-  become: yes
-  ansible.builtin.file:
-    path: "{{ mesh_dir }}/meshcentral-data"
-    state: directory
-    owner: "{{ user }}"
-    group: "{{ user }}"
-    mode: "0755"
-
-- name: install meshcentral
-  tags: mesh
-  ansible.builtin.command:
-    chdir: "{{ mesh_dir }}"
-    cmd: "npm install meshcentral@{{ mesh_ver.stdout }}"
-
-- name: deploy mesh config
-  tags: mesh
-  ansible.builtin.template:
-    src: mesh.cfg.j2
-    dest: "{{ mesh_dir }}/meshcentral-data/config.json"
-    mode: "0644"
-    owner: "{{ user }}"
-    group: "{{ user }}"
-
-- name: start meshcentral
-  tags: mesh
-  become: yes
-  ansible.builtin.systemd:
-    name: meshcentral.service
-    state: started
-    enabled: yes
-    daemon_reload: yes
-
-- name: wait for meshcentral to be ready
-  tags: mesh
-  uri:
-    url: "https://{{ mesh }}"
-    return_content: yes
-    validate_certs: yes
-    status_code: 200
-  register: mesh_status
-  until: mesh_status.status == 200
-  retries: 20
-  delay: 3
-
-- name: get meshcentral login token key
-  tags: mesh_key
-  ansible.builtin.command:
-    chdir: "{{ mesh_dir }}"
-    cmd: node node_modules/meshcentral --logintokenkey
-  register: mesh_token_key
-
-- name: add mesh key to django settings file
-  tags: mesh_key
-  ansible.builtin.lineinfile:
-    path: "{{ local_settings_file }}"
-    line: 'MESH_TOKEN_KEY = "{{ mesh_token_key.stdout }}"'
-
-- name: stop meshcentral service
-  tags: mesh_user
-  become: yes
-  ansible.builtin.service:
-    name: meshcentral.service
-    state: stopped
-
-- name: create mesh user
-  tags: mesh_user
-  ansible.builtin.shell:
-    chdir: "{{ mesh_dir }}"
-    cmd: |
-      node node_modules/meshcentral --createaccount {{ mesh_user }} --pass {{ mesh_password }} --email {{ github_email }}
-      node node_modules/meshcentral --adminaccount {{ mesh_user }}
-
-- name: start meshcentral service
-  tags: mesh_user
-  become: yes
-  ansible.builtin.service:
-    name: meshcentral.service
-    state: started
-
-- name: wait for meshcentral to be ready
-  tags: mesh_user
-  uri:
-    url: "https://{{ mesh }}"
-    return_content: yes
-    validate_certs: yes
-    status_code: 200
-  register: mesh_status
-  until: mesh_status.status == 200
-  retries: 20
-  delay: 3
-
-- name: create mesh device group
-  tags: mesh_user
-  ansible.builtin.shell:
-    chdir: "{{ mesh_dir }}"
-    cmd: |
-      node node_modules/meshcentral/meshctrl.js --url wss://{{ mesh }}:443 --loginuser {{ mesh_user }} --loginpass {{ mesh_password }} AddDeviceGroup --name TacticalRMM
-
-- name: finish up django
-  tags: mesh_user
-  ansible.builtin.shell:
-    chdir: "{{ backend_dir }}/api/tacticalrmm"
-    cmd: |
-      . ../env/bin/activate
-      python manage.py initial_db_setup
-      python manage.py reload_nats
-
-- name: restart services
-  tags: services
-  become: yes
-  ansible.builtin.systemd:
-    daemon_reload: yes
-    enabled: yes
-    state: restarted
-    name: "{{ item }}.service"
-  with_items:
-    - nats
-    - nats-api

ansible/roles/trmm_dev/templates/backend.nginx.j2

@@ -1,20 +0,0 @@
-server {
-    listen 443 ssl reuseport;
-    listen [::]:443 ssl;
-    server_name {{ api }};
-    client_max_body_size 300M;
-    ssl_certificate {{ fullchain_dest }};
-    ssl_certificate_key {{ privkey_dest }};
-
-
-    location ~ ^/natsws {
-        proxy_pass http://127.0.0.1:9235;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_set_header X-Forwarded-Host $host:$server_port;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-}

ansible/roles/trmm_dev/templates/local_settings.j2

@@ -1,25 +0,0 @@
-SECRET_KEY = "{{ django_secret }}"
-DEBUG = True
-ALLOWED_HOSTS = ['{{ api }}']
-ADMIN_URL = "admin/"
-CORS_ORIGIN_WHITELIST = [
-    "http://{{ rmm }}:8080",
-    "https://{{ rmm }}:8080",
-]
-CORS_ORIGIN_ALLOW_ALL = True
-DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.postgresql',
-        'NAME': 'tacticalrmm',
-        'USER': '{{ db_user }}',
-        'PASSWORD': '{{ db_passwd }}',
-        'HOST': 'localhost',
-        'PORT': '5432',
-    }
-}
-REDIS_HOST    = "localhost"
-ADMIN_ENABLED = True
-CERT_FILE = "{{ fullchain_src }}"
-KEY_FILE = "{{ privkey_src }}"
-MESH_USERNAME = "{{ mesh_user }}"
-MESH_SITE = "https://{{ mesh }}"

ansible/roles/trmm_dev/templates/mesh.cfg.j2

@@ -1,33 +0,0 @@
-{
-  "settings": {
-    "Cert": "{{ mesh }}",
-    "MongoDb": "mongodb://127.0.0.1:27017",
-    "MongoDbName": "meshcentral",
-    "WANonly": true,
-    "Minify": 1,
-    "Port": 4430,
-    "AliasPort": 443,
-    "RedirPort": 800,
-    "AllowLoginToken": true,
-    "AllowFraming": true,
-    "AgentPong": 300,
-    "AllowHighQualityDesktop": true,
-    "TlsOffload": "127.0.0.1",
-    "agentCoreDump": false,
-    "Compression": true,
-    "WsCompression": true,
-    "AgentWsCompression": true,
-    "MaxInvalidLogin": { "time": 5, "count": 5, "coolofftime": 30 }
-  },
-  "domains": {
-    "": {
-      "Title": "Tactical RMM",
-      "Title2": "Tactical RMM",
-      "NewAccounts": false,
-      "CertUrl": "https://{{ mesh }}:443/",
-      "GeoLocation": true,
-      "CookieIpCheck": false,
-      "mstsc": true
-    }
-  }
-}

ansible/roles/trmm_dev/templates/mesh.nginx.j2

@@ -1,22 +0,0 @@
-server {
-    listen 443 ssl;
-    listen [::]:443 ssl;
-    proxy_send_timeout 330s;
-    proxy_read_timeout 330s;
-    server_name {{ mesh }};
-    ssl_certificate {{ fullchain_dest }};
-    ssl_certificate_key {{ privkey_dest }};
-
-    ssl_session_cache shared:WEBSSL:10m;
-
-    location / {
-        proxy_pass http://127.0.0.1:4430/;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_set_header X-Forwarded-Host $host:$server_port;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-}

ansible/roles/trmm_dev/templates/mesh.systemd.j2

@@ -1,17 +0,0 @@
-[Unit]
-Description=MeshCentral Server
-After=network.target mongod.service nginx.service
-
-[Service]
-Type=simple
-LimitNOFILE=1000000
-ExecStart=/usr/bin/node node_modules/meshcentral
-Environment=NODE_ENV=production
-WorkingDirectory={{ mesh_dir }}
-User={{ user }}
-Group={{ user }}
-Restart=always
-RestartSec=10s
-
-[Install]
-WantedBy=multi-user.target

ansible/roles/trmm_dev/templates/nats-api.systemd.j2

@@ -1,14 +0,0 @@
-[Unit]
-Description=TacticalRMM Nats Api
-After=nats.service
-
-[Service]
-Type=simple
-ExecStart=/usr/local/bin/nats-api -config {{ backend_dir }}/api/tacticalrmm/nats-api.conf
-User={{ user }}
-Group={{ user }}
-Restart=always
-RestartSec=5s
-
-[Install]
-WantedBy=multi-user.target

ansible/roles/trmm_dev/templates/nats-server.systemd.j2

@@ -1,18 +0,0 @@
-[Unit]
-Description=NATS Server
-After=network.target
-
-[Service]
-PrivateTmp=true
-Type=simple
-ExecStart=/usr/local/bin/nats-server -c {{ backend_dir }}/api/tacticalrmm/nats-rmm.conf
-ExecReload=/usr/bin/kill -s HUP $MAINPID
-ExecStop=/usr/bin/kill -s SIGINT $MAINPID
-User={{ user }}
-Group={{ user }}
-Restart=always
-RestartSec=5s
-LimitNOFILE=1000000
-
-[Install]
-WantedBy=multi-user.target

ansible/roles/trmm_dev/templates/quasar.env.j2

@@ -1,4 +0,0 @@
-DEV_URL = "http://{{ api }}:8000"
-DEV_HOST = "{{ rmm }}"
-DEV_PORT = "8080"
-USE_HTTPS = false

ansible/setup_dev.yml.example

@@ -1,20 +0,0 @@
----
-- hosts: "{{ target }}"
-  vars:
-    ansible_user: tactical
-    fullchain_src: /path/to/fullchain.pem
-    privkey_src: /path/to/privkey.pem
-    api: "api.example.com"
-    rmm: "rmm.example.com"
-    mesh: "mesh.example.com"
-    github_username: "changeme"
-    github_email: "changeme@example.com"
-    mesh_user: "changeme"
-    mesh_password: "changeme"
-    db_user: "changeme"
-    db_passwd: "changeme"
-    django_secret: "changeme"
-    django_user: "changeme"
-    django_password: "changeme"
-  roles:
-    - trmm_dev

api/tacticalrmm/.coveragerc

@@ -1,15 +1,26 @@
 [run]
-include = *.py
-omit =
-    tacticalrmm/asgi.py
-    tacticalrmm/wsgi.py
-    manage.py
-    */__pycache__/*
-    */env/*
-    */baker_recipes.py
-    /usr/local/lib/*
-    **/migrations/*
-    **/test*.py
-    
+source = .
 [report]
 show_missing = True
+include = *.py
+omit =
+    */__pycache__/*
+    */env/*
+    */management/*
+    */migrations/*
+    */static/*
+    manage.py
+    */local_settings.py
+    */apps.py
+    */admin.py
+    */celery.py
+    */wsgi.py
+    */settings.py
+    */baker_recipes.py
+    */urls.py
+    */tests.py
+    */test.py
+    checks/utils.py
+    */asgi.py
+    */demo_views.py
+    

api/tacticalrmm/accounts/admin.py

@@ -1,7 +1,7 @@
 from django.contrib import admin
 from rest_framework.authtoken.admin import TokenAdmin
 
-from .models import Role, User
+from .models import User, Role
 
 admin.site.register(User)
 TokenAdmin.raw_id_fields = ("user",)

api/tacticalrmm/accounts/management/commands/create_installer_user.py

@@ -1,23 +1,19 @@
 import uuid
 
 from django.core.management.base import BaseCommand
-
 from accounts.models import User
 
 
 class Command(BaseCommand):
     help = "Creates the installer user"
 
-    def handle(self, *args, **kwargs):  # type: ignore
-        self.stdout.write("Checking if installer user has been created...")
+    def handle(self, *args, **kwargs):
         if User.objects.filter(is_installer_user=True).exists():
-            self.stdout.write("Installer user already exists")
             return
 
-        User.objects.create_user(
+        User.objects.create_user(  # type: ignore
             username=uuid.uuid4().hex,
             is_installer_user=True,
-            password=User.objects.make_random_password(60),
+            password=User.objects.make_random_password(60),  # type: ignore
             block_dashboard_login=True,
         )
-        self.stdout.write("Installer user has been created")

api/tacticalrmm/accounts/management/commands/delete_tokens.py

@@ -6,7 +6,7 @@ from knox.models import AuthToken
 class Command(BaseCommand):
     help = "Deletes all knox web tokens"
 
-    def handle(self, *args, **kwargs):  # type: ignore
+    def handle(self, *args, **kwargs):
         # only delete web tokens, not any generated by the installer or deployments
         dont_delete = djangotime.now() + djangotime.timedelta(hours=23)
         tokens = AuthToken.objects.exclude(deploytokens__isnull=False).filter(

api/tacticalrmm/accounts/management/commands/reset_2fa.py

@@ -1,6 +1,5 @@
 import os
 import subprocess
-from contextlib import suppress
 
 import pyotp
 from django.core.management.base import BaseCommand
@@ -26,7 +25,7 @@ class Command(BaseCommand):
         nginx = "/etc/nginx/sites-available/frontend.conf"
         found = None
         if os.path.exists(nginx):
-            with suppress(Exception):
+            try:
                 with open(nginx, "r") as f:
                     for line in f:
                         if "server_name" in line:
@@ -36,6 +35,8 @@ class Command(BaseCommand):
                 if found:
                     rep = found.replace("server_name", "").replace(";", "")
                     domain = "".join(rep.split())
+            except:
+                pass
 
         code = pyotp.random_base32()
         user.totp_key = code

api/tacticalrmm/accounts/management/commands/reset_password.py

@@ -1,5 +1,4 @@
 from django.core.management.base import BaseCommand
-
 from accounts.models import User
 
 

api/tacticalrmm/accounts/migrations/0019_user_role.py

@@ -1,7 +1,7 @@
 # Generated by Django 3.2.1 on 2021-05-11 02:33
 
-import django.db.models.deletion
 from django.db import migrations, models
+import django.db.models.deletion
 
 
 class Migration(migrations.Migration):

api/tacticalrmm/accounts/migrations/0027_auto_20210903_0054.py

@@ -1,7 +1,7 @@
 # Generated by Django 3.2.6 on 2021-09-03 00:54
 
-import django.db.models.deletion
 from django.db import migrations, models
+import django.db.models.deletion
 
 
 class Migration(migrations.Migration):

api/tacticalrmm/accounts/migrations/0028_auto_20211010_0249.py

@@ -1,7 +1,7 @@
 # Generated by Django 3.2.6 on 2021-10-10 02:49
 
-import django.db.models.deletion
 from django.db import migrations, models
+import django.db.models.deletion
 
 
 class Migration(migrations.Migration):

api/tacticalrmm/accounts/migrations/0031_user_date_format.py

@@ -1,18 +0,0 @@
-# Generated by Django 3.2.12 on 2022-04-02 15:57
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('accounts', '0030_auto_20211104_0221'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='user',
-            name='date_format',
-            field=models.CharField(blank=True, max_length=30, null=True),
-        ),
-    ]

api/tacticalrmm/accounts/models.py

@@ -1,17 +1,26 @@
-from typing import Optional
-
 from django.contrib.auth.models import AbstractUser
-from django.core.cache import cache
 from django.db import models
 from django.db.models.fields import CharField, DateTimeField
 
 from logs.models import BaseAuditModel
-from tacticalrmm.constants import (
-    ROLE_CACHE_PREFIX,
-    AgentDblClick,
-    AgentTableTabs,
-    ClientTreeSort,
-)
+
+AGENT_DBLCLICK_CHOICES = [
+    ("editagent", "Edit Agent"),
+    ("takecontrol", "Take Control"),
+    ("remotebg", "Remote Background"),
+    ("urlaction", "URL Action"),
+]
+
+AGENT_TBL_TAB_CHOICES = [
+    ("server", "Servers"),
+    ("workstation", "Workstations"),
+    ("mixed", "Mixed"),
+]
+
+CLIENT_TREE_SORT_CHOICES = [
+    ("alphafail", "Move failing clients to the top"),
+    ("alpha", "Sort alphabetically"),
+]
 
 
 class User(AbstractUser, BaseAuditModel):
@@ -20,8 +29,8 @@ class User(AbstractUser, BaseAuditModel):
     totp_key = models.CharField(max_length=50, null=True, blank=True)
     dark_mode = models.BooleanField(default=True)
     show_community_scripts = models.BooleanField(default=True)
-    agent_dblclick_action: "AgentDblClick" = models.CharField(
-        max_length=50, choices=AgentDblClick.choices, default=AgentDblClick.EDIT_AGENT
+    agent_dblclick_action = models.CharField(
+        max_length=50, choices=AGENT_DBLCLICK_CHOICES, default="editagent"
     )
     url_action = models.ForeignKey(
         "core.URLAction",
@@ -31,16 +40,15 @@ class User(AbstractUser, BaseAuditModel):
         on_delete=models.SET_NULL,
     )
     default_agent_tbl_tab = models.CharField(
-        max_length=50, choices=AgentTableTabs.choices, default=AgentTableTabs.SERVER
+        max_length=50, choices=AGENT_TBL_TAB_CHOICES, default="server"
     )
     agents_per_page = models.PositiveIntegerField(default=50)  # not currently used
     client_tree_sort = models.CharField(
-        max_length=50, choices=ClientTreeSort.choices, default=ClientTreeSort.ALPHA_FAIL
+        max_length=50, choices=CLIENT_TREE_SORT_CHOICES, default="alphafail"
     )
     client_tree_splitter = models.PositiveIntegerField(default=11)
     loading_bar_color = models.CharField(max_length=255, default="red")
     clear_search_when_switching = models.BooleanField(default=True)
-    date_format = models.CharField(max_length=30, blank=True, null=True)
     is_installer_user = models.BooleanField(default=False)
     last_login_ip = models.GenericIPAddressField(default=None, blank=True, null=True)
 
@@ -67,23 +75,6 @@ class User(AbstractUser, BaseAuditModel):
 
         return UserSerializer(user).data
 
-    def get_and_set_role_cache(self) -> "Optional[Role]":
-        role = cache.get(f"{ROLE_CACHE_PREFIX}{self.role}")
-
-        if role and isinstance(role, Role):
-            return role
-        elif not role and not self.role:
-            return None
-        else:
-            models.prefetch_related_objects(
-                [self.role],
-                "can_view_clients",
-                "can_view_sites",
-            )
-
-            cache.set(f"{ROLE_CACHE_PREFIX}{self.role}", self.role, 600)
-            return self.role
-
 
 class Role(BaseAuditModel):
     name = models.CharField(max_length=255, unique=True)
@@ -184,12 +175,6 @@ class Role(BaseAuditModel):
     def __str__(self):
         return self.name
 
-    def save(self, *args, **kwargs) -> None:
-
-        # delete cache on save
-        cache.delete(f"{ROLE_CACHE_PREFIX}{self.name}")
-        super(BaseAuditModel, self).save(*args, **kwargs)
-
     @staticmethod
     def serialize(role):
         # serializes the agent and returns json

api/tacticalrmm/accounts/permissions.py

@@ -4,7 +4,7 @@ from tacticalrmm.permissions import _has_perm
 
 
 class AccountsPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         if r.method == "GET":
             return _has_perm(r, "can_list_accounts")
         else:
@@ -28,15 +28,15 @@ class AccountsPerms(permissions.BasePermission):
 
 
 class RolesPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         if r.method == "GET":
             return _has_perm(r, "can_list_roles")
-
-        return _has_perm(r, "can_manage_roles")
+        else:
+            return _has_perm(r, "can_manage_roles")
 
 
 class APIKeyPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         if r.method == "GET":
             return _has_perm(r, "can_list_api_keys")
 

api/tacticalrmm/accounts/serializers.py

@@ -1,11 +1,11 @@
 import pyotp
 from rest_framework.serializers import (
     ModelSerializer,
-    ReadOnlyField,
     SerializerMethodField,
+    ReadOnlyField,
 )
 
-from .models import APIKey, Role, User
+from .models import APIKey, User, Role
 
 
 class UserUISerializer(ModelSerializer):
@@ -22,7 +22,6 @@ class UserUISerializer(ModelSerializer):
             "loading_bar_color",
             "clear_search_when_switching",
             "block_dashboard_login",
-            "date_format",
         ]
 
 
@@ -40,7 +39,6 @@ class UserSerializer(ModelSerializer):
             "last_login_ip",
             "role",
             "block_dashboard_login",
-            "date_format",
         ]
 
 

api/tacticalrmm/accounts/tests.py

@@ -2,16 +2,15 @@ from unittest.mock import patch
 
 from django.test import override_settings
 from model_bakery import baker, seq
-
-from accounts.models import APIKey, User
-from accounts.serializers import APIKeySerializer
-from tacticalrmm.constants import AgentDblClick, AgentTableTabs, ClientTreeSort
+from accounts.models import User, APIKey
 from tacticalrmm.test import TacticalTestCase
 
+from accounts.serializers import APIKeySerializer
+
 
 class TestAccounts(TacticalTestCase):
     def setUp(self):
-        self.setup_client()
+        self.client_setup()
         self.bob = User(username="bob")
         self.bob.set_password("hunter2")
         self.bob.save()
@@ -70,17 +69,17 @@ class TestAccounts(TacticalTestCase):
         self.assertEqual(r.status_code, 400)
         self.assertIn("non_field_errors", r.data.keys())
 
-    # @override_settings(DEBUG=True)
-    # @patch("pyotp.TOTP.verify")
-    # def test_debug_login_view(self, mock_verify):
-    #     url = "/login/"
-    #     mock_verify.return_value = True
+    @override_settings(DEBUG=True)
+    @patch("pyotp.TOTP.verify")
+    def test_debug_login_view(self, mock_verify):
+        url = "/login/"
+        mock_verify.return_value = True
 
-    #     data = {"username": "bob", "password": "hunter2", "twofactor": "sekret"}
-    #     r = self.client.post(url, data, format="json")
-    #     self.assertEqual(r.status_code, 200)
-    #     self.assertIn("expiry", r.data.keys())
-    #     self.assertIn("token", r.data.keys())
+        data = {"username": "bob", "password": "hunter2", "twofactor": "sekret"}
+        r = self.client.post(url, data, format="json")
+        self.assertEqual(r.status_code, 200)
+        self.assertIn("expiry", r.data.keys())
+        self.assertIn("token", r.data.keys())
 
 
 class TestGetAddUsers(TacticalTestCase):
@@ -284,9 +283,9 @@ class TestUserAction(TacticalTestCase):
         data = {
             "dark_mode": True,
             "show_community_scripts": True,
-            "agent_dblclick_action": AgentDblClick.EDIT_AGENT,
-            "default_agent_tbl_tab": AgentTableTabs.MIXED,
-            "client_tree_sort": ClientTreeSort.ALPHA,
+            "agent_dblclick_action": "editagent",
+            "default_agent_tbl_tab": "mixed",
+            "client_tree_sort": "alpha",
             "client_tree_splitter": 14,
             "loading_bar_color": "green",
             "clear_search_when_switching": False,
@@ -309,7 +308,7 @@ class TestAPIKeyViews(TacticalTestCase):
         serializer = APIKeySerializer(apikeys, many=True)
         resp = self.client.get(url, format="json")
         self.assertEqual(resp.status_code, 200)
-        self.assertEqual(serializer.data, resp.data)
+        self.assertEqual(serializer.data, resp.data)  # type: ignore
 
         self.check_not_authenticated("get", url)
 
@@ -332,14 +331,14 @@ class TestAPIKeyViews(TacticalTestCase):
         self.assertEqual(resp.status_code, 404)
 
         apikey = baker.make("accounts.APIKey", name="Test")
-        url = f"/accounts/apikeys/{apikey.pk}/"
+        url = f"/accounts/apikeys/{apikey.pk}/"  # type: ignore
 
-        data = {"name": "New Name"}
+        data = {"name": "New Name"}  # type: ignore
 
         resp = self.client.put(url, data, format="json")
         self.assertEqual(resp.status_code, 200)
-        apikey = APIKey.objects.get(pk=apikey.pk)
-        self.assertEqual(apikey.name, "New Name")
+        apikey = APIKey.objects.get(pk=apikey.pk)  # type: ignore
+        self.assertEquals(apikey.name, "New Name")
 
         self.check_not_authenticated("put", url)
 
@@ -350,11 +349,11 @@ class TestAPIKeyViews(TacticalTestCase):
 
         # test delete api key
         apikey = baker.make("accounts.APIKey")
-        url = f"/accounts/apikeys/{apikey.pk}/"
+        url = f"/accounts/apikeys/{apikey.pk}/"  # type: ignore
         resp = self.client.delete(url, format="json")
         self.assertEqual(resp.status_code, 200)
 
-        self.assertFalse(APIKey.objects.filter(pk=apikey.pk).exists())
+        self.assertFalse(APIKey.objects.filter(pk=apikey.pk).exists())  # type: ignore
 
         self.check_not_authenticated("delete", url)
 
@@ -394,7 +393,7 @@ class TestAPIAuthentication(TacticalTestCase):
             name="Test Token", key="123456", user=self.user
         )
 
-        self.setup_client()
+        self.client_setup()
 
     def test_api_auth(self):
         url = "/clients/"

api/tacticalrmm/accounts/utils.py

@@ -1,18 +0,0 @@
-from typing import TYPE_CHECKING
-from django.conf import settings
-
-if TYPE_CHECKING:
-    from django.http import HttpRequest
-    from accounts.models import User
-
-
-def is_root_user(*, request: "HttpRequest", user: "User") -> bool:
-    root = (
-        hasattr(settings, "ROOT_USER")
-        and request.user != user
-        and user.username == settings.ROOT_USER
-    )
-    demo = (
-        getattr(settings, "DEMO", False) and request.user.username == settings.ROOT_USER
-    )
-    return root or demo

api/tacticalrmm/accounts/views.py

@@ -5,16 +5,15 @@ from django.db import IntegrityError
 from django.shortcuts import get_object_or_404
 from ipware import get_client_ip
 from knox.views import LoginView as KnoxLoginView
+from logs.models import AuditLog
 from rest_framework.authtoken.serializers import AuthTokenSerializer
 from rest_framework.permissions import AllowAny, IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.views import APIView
-
-from logs.models import AuditLog
-from tacticalrmm.helpers import notify_error
+from tacticalrmm.utils import notify_error
 
 from .models import APIKey, Role, User
-from .permissions import AccountsPerms, APIKeyPerms, RolesPerms
+from .permissions import APIKeyPerms, AccountsPerms, RolesPerms
 from .serializers import (
     APIKeySerializer,
     RoleSerializer,
@@ -22,7 +21,18 @@ from .serializers import (
     UserSerializer,
     UserUISerializer,
 )
-from accounts.utils import is_root_user
+
+
+def _is_root_user(request, user) -> bool:
+    root = (
+        hasattr(settings, "ROOT_USER")
+        and request.user != user
+        and user.username == settings.ROOT_USER
+    )
+    demo = (
+        getattr(settings, "DEMO", False) and request.user.username == settings.ROOT_USER
+    )
+    return root or demo
 
 
 class CheckCreds(KnoxLoginView):
@@ -82,7 +92,7 @@ class LoginView(KnoxLoginView):
             login(request, user)
 
             # save ip information
-            client_ip, _ = get_client_ip(request)
+            client_ip, is_routable = get_client_ip(request)
             user.last_login_ip = client_ip
             user.save()
 
@@ -148,7 +158,7 @@ class GetUpdateDeleteUser(APIView):
     def put(self, request, pk):
         user = get_object_or_404(User, pk=pk)
 
-        if is_root_user(request=request, user=user):
+        if _is_root_user(request, user):
             return notify_error("The root user cannot be modified from the UI")
 
         serializer = UserSerializer(instance=user, data=request.data, partial=True)
@@ -159,7 +169,7 @@ class GetUpdateDeleteUser(APIView):
 
     def delete(self, request, pk):
         user = get_object_or_404(User, pk=pk)
-        if is_root_user(request=request, user=user):
+        if _is_root_user(request, user):
             return notify_error("The root user cannot be deleted from the UI")
 
         user.delete()
@@ -172,7 +182,7 @@ class UserActions(APIView):
     # reset password
     def post(self, request):
         user = get_object_or_404(User, pk=request.data["id"])
-        if is_root_user(request=request, user=user):
+        if _is_root_user(request, user):
             return notify_error("The root user cannot be modified from the UI")
 
         user.set_password(request.data["password"])
@@ -183,7 +193,7 @@ class UserActions(APIView):
     # reset two factor token
     def put(self, request):
         user = get_object_or_404(User, pk=request.data["id"])
-        if is_root_user(request=request, user=user):
+        if _is_root_user(request, user):
             return notify_error("The root user cannot be modified from the UI")
 
         user.totp_key = ""

api/tacticalrmm/agents/admin.py

@@ -1,8 +1,9 @@
 from django.contrib import admin
 
-from .models import Agent, AgentCustomField, AgentHistory, Note
+from .models import Agent, AgentCustomField, Note, RecoveryAction, AgentHistory
 
 admin.site.register(Agent)
+admin.site.register(RecoveryAction)
 admin.site.register(Note)
 admin.site.register(AgentCustomField)
 admin.site.register(AgentHistory)

api/tacticalrmm/agents/baker_recipes.py

@@ -1,6 +1,6 @@
 import json
 import os
-import secrets
+import random
 import string
 from itertools import cycle
 
@@ -8,11 +8,10 @@ from django.conf import settings
 from django.utils import timezone as djangotime
 from model_bakery.recipe import Recipe, foreign_key, seq
 
-from tacticalrmm.constants import AgentMonType, AgentPlat
 
-
-def generate_agent_id() -> str:
-    return "".join(secrets.choice(string.ascii_letters) for i in range(39))
+def generate_agent_id(hostname):
+    rand = "".join(random.choice(string.ascii_letters) for _ in range(35))
+    return f"{rand}-{hostname}"
 
 
 site = Recipe("clients.Site")
@@ -25,34 +24,25 @@ def get_wmi_data():
         return json.load(f)
 
 
-def get_win_svcs():
-    svcs = settings.BASE_DIR.joinpath("tacticalrmm/test_data/winsvcs.json")
-    with open(svcs) as f:
-        return json.load(f)
-
-
 agent = Recipe(
     "agents.Agent",
     site=foreign_key(site),
     hostname="DESKTOP-TEST123",
     version="1.3.0",
-    monitoring_type=cycle(AgentMonType.values),
-    agent_id=seq(generate_agent_id()),
+    monitoring_type=cycle(["workstation", "server"]),
+    agent_id=seq(generate_agent_id("DESKTOP-TEST123")),
     last_seen=djangotime.now() - djangotime.timedelta(days=5),
-    plat=AgentPlat.WINDOWS,
 )
 
 server_agent = agent.extend(
-    monitoring_type=AgentMonType.SERVER,
+    monitoring_type="server",
 )
 
 workstation_agent = agent.extend(
-    monitoring_type=AgentMonType.WORKSTATION,
+    monitoring_type="workstation",
 )
 
-online_agent = agent.extend(
-    last_seen=djangotime.now(), services=get_win_svcs(), wmi_detail=get_wmi_data()
-)
+online_agent = agent.extend(last_seen=djangotime.now())
 
 offline_agent = agent.extend(
     last_seen=djangotime.now() - djangotime.timedelta(minutes=7)
@@ -87,4 +77,4 @@ agent_with_services = agent.extend(
     ],
 )
 
-agent_with_wmi = agent.extend(wmi_detail=get_wmi_data())
+agent_with_wmi = agent.extend(wmi=get_wmi_data())

api/tacticalrmm/agents/consumers.py

@@ -1,83 +0,0 @@
-from agents.models import Agent, AgentHistory
-from channels.db import database_sync_to_async
-from channels.generic.websocket import AsyncJsonWebsocketConsumer
-from django.contrib.auth.models import AnonymousUser
-from django.shortcuts import get_object_or_404
-from tacticalrmm.constants import AGENT_DEFER, AgentHistoryType
-from tacticalrmm.permissions import _has_perm_on_agent
-
-
-class SendCMD(AsyncJsonWebsocketConsumer):
-    async def connect(self):
-
-        self.user = self.scope["user"]
-
-        if isinstance(self.user, AnonymousUser):
-            await self.close()
-
-        await self.accept()
-
-    async def receive_json(self, payload, **kwargs):
-        auth = await self.has_perm(payload["agent_id"])
-        if not auth:
-            await self.send_json(
-                {"ret": "You do not have permission to perform this action."}
-            )
-            return
-
-        agent = await self.get_agent(payload["agent_id"])
-        timeout = int(payload["timeout"])
-        if payload["shell"] == "custom" and payload["custom_shell"]:
-            shell = payload["custom_shell"]
-        else:
-            shell = payload["shell"]
-
-        hist_pk = await self.get_history_id(agent, payload["cmd"])
-
-        data = {
-            "func": "rawcmd",
-            "timeout": timeout,
-            "payload": {
-                "command": payload["cmd"],
-                "shell": shell,
-            },
-            "id": hist_pk,
-        }
-
-        ret = await agent.nats_cmd(data, timeout=timeout + 2)
-        await self.send_json({"ret": ret})
-
-    async def disconnect(self, _):
-        await self.close()
-
-    def _has_perm(self, perm: str) -> bool:
-        if self.user.is_superuser or (
-            self.user.role and getattr(self.user.role, "is_superuser")
-        ):
-            return True
-
-        # make sure non-superusers with empty roles aren't permitted
-        elif not self.user.role:
-            return False
-
-        return self.user.role and getattr(self.user.role, perm)
-
-    @database_sync_to_async  # type: ignore
-    def get_agent(self, agent_id: str) -> "Agent":
-        return get_object_or_404(Agent.objects.defer(*AGENT_DEFER), agent_id=agent_id)
-
-    @database_sync_to_async  # type: ignore
-    def get_history_id(self, agent: "Agent", cmd: str) -> int:
-        hist = AgentHistory.objects.create(
-            agent=agent,
-            type=AgentHistoryType.CMD_RUN,
-            command=cmd,
-            username=self.user.username[:50],
-        )
-        return hist.pk
-
-    @database_sync_to_async  # type: ignore
-    def has_perm(self, agent_id: str) -> bool:
-        return self._has_perm("can_send_cmd") and _has_perm_on_agent(
-            self.user, agent_id
-        )

api/tacticalrmm/agents/management/commands/bulk_delete_agents.py

@@ -5,8 +5,7 @@ from django.utils import timezone as djangotime
 from packaging import version as pyver
 
 from agents.models import Agent
-from tacticalrmm.constants import AGENT_DEFER
-from tacticalrmm.utils import reload_nats
+from tacticalrmm.utils import AGENT_DEFER, reload_nats
 
 
 class Command(BaseCommand):
@@ -64,7 +63,7 @@ class Command(BaseCommand):
                 try:
                     agent.delete()
                 except Exception as e:
-                    err = f"Failed to delete agent {agent.hostname}: {e}"
+                    err = f"Failed to delete agent {agent.hostname}: {str(e)}"
                     self.stdout.write(self.style.ERROR(err))
                 else:
                     deleted_count += 1

api/tacticalrmm/agents/management/commands/demo_cron.py

@@ -3,9 +3,7 @@ import random
 
 from django.core.management.base import BaseCommand
 from django.utils import timezone as djangotime
-
 from agents.models import Agent
-from core.tasks import cache_db_fields_task, handle_resolved_stuff
 
 
 class Command(BaseCommand):
@@ -24,10 +22,15 @@ class Command(BaseCommand):
             rand = now - djangotime.timedelta(minutes=random.randint(10, 20))
             random_dates.append(rand)
 
+        """ for _ in range(5):
+            rand = djangotime.now() - djangotime.timedelta(hours=random.randint(1, 10))
+            random_dates.append(rand)
+
+        for _ in range(5):
+            rand = djangotime.now() - djangotime.timedelta(days=random.randint(40, 90))
+            random_dates.append(rand) """
+
         agents = Agent.objects.only("last_seen")
         for agent in agents:
             agent.last_seen = random.choice(random_dates)
             agent.save(update_fields=["last_seen"])
-
-        cache_db_fields_task()
-        handle_resolved_stuff()

api/tacticalrmm/agents/management/commands/find_services.py

@@ -1,30 +0,0 @@
-from django.core.management.base import BaseCommand
-
-from agents.models import Agent
-from tacticalrmm.constants import AGENT_DEFER
-
-
-class Command(BaseCommand):
-    help = "Find all agents that have a certain service installed"
-
-    def add_arguments(self, parser):
-        parser.add_argument("name", type=str)
-
-    def handle(self, *args, **kwargs):
-        search = kwargs["name"].lower()
-
-        agents = Agent.objects.defer(*AGENT_DEFER)
-        for agent in agents:
-            try:
-                for svc in agent.services:
-                    if (
-                        search in svc["name"].lower()
-                        or search in svc["display_name"].lower()
-                    ):
-                        self.stdout.write(
-                            self.style.SUCCESS(
-                                f"{agent.hostname} - {svc['name']} ({svc['display_name']}) - {svc['status']}"
-                            )
-                        )
-            except:
-                continue

api/tacticalrmm/agents/management/commands/fix_salt_key.py

@@ -0,0 +1,16 @@
+from django.core.management.base import BaseCommand
+
+from agents.models import Agent
+
+
+class Command(BaseCommand):
+    help = "Changes existing agents salt_id from a property to a model field"
+
+    def handle(self, *args, **kwargs):
+        agents = Agent.objects.filter(salt_id=None)
+        for agent in agents:
+            self.stdout.write(
+                self.style.SUCCESS(f"Setting salt_id on {agent.hostname}")
+            )
+            agent.salt_id = f"{agent.hostname}-{agent.pk}"
+            agent.save(update_fields=["salt_id"])

api/tacticalrmm/agents/management/commands/show_outdated_agents.py

@@ -2,16 +2,16 @@ from django.conf import settings
 from django.core.management.base import BaseCommand
 
 from agents.models import Agent
-from tacticalrmm.constants import AGENT_STATUS_ONLINE, ONLINE_AGENTS
 
 
 class Command(BaseCommand):
     help = "Shows online agents that are not on the latest version"
 
     def handle(self, *args, **kwargs):
-        only = ONLINE_AGENTS + ("hostname",)
-        q = Agent.objects.exclude(version=settings.LATEST_AGENT_VER).only(*only)
-        agents = [i for i in q if i.status == AGENT_STATUS_ONLINE]
+        q = Agent.objects.exclude(version=settings.LATEST_AGENT_VER).only(
+            "pk", "version", "last_seen", "overdue_time", "offline_time"
+        )
+        agents = [i for i in q if i.status == "online"]
         for agent in agents:
             self.stdout.write(
                 self.style.SUCCESS(f"{agent.hostname} - v{agent.version}")

api/tacticalrmm/agents/management/commands/update_agents.py

@@ -3,17 +3,17 @@ from django.core.management.base import BaseCommand
 from packaging import version as pyver
 
 from agents.models import Agent
+from core.models import CoreSettings
 from agents.tasks import send_agent_update_task
-from core.utils import get_core_settings, token_is_valid
-from tacticalrmm.constants import AGENT_DEFER
+from tacticalrmm.utils import AGENT_DEFER
 
 
 class Command(BaseCommand):
     help = "Triggers an agent update task to run"
 
     def handle(self, *args, **kwargs):
-        core = get_core_settings()
-        if not core.agent_auto_update:
+        core = CoreSettings.objects.first()
+        if not core.agent_auto_update:  # type: ignore
             return
 
         q = Agent.objects.defer(*AGENT_DEFER).exclude(version=settings.LATEST_AGENT_VER)
@@ -22,5 +22,4 @@ class Command(BaseCommand):
             for i in q
             if pyver.parse(i.version) < pyver.parse(settings.LATEST_AGENT_VER)
         ]
-        token, _ = token_is_valid()
-        send_agent_update_task.delay(agent_ids=agent_ids, token=token, force=False)
+        send_agent_update_task.delay(agent_ids=agent_ids)

api/tacticalrmm/agents/migrations/0038_agenthistory.py

@@ -1,7 +1,7 @@
 # Generated by Django 3.2.1 on 2021-07-06 02:01
 
-import django.db.models.deletion
 from django.db import migrations, models
+import django.db.models.deletion
 
 
 class Migration(migrations.Migration):

api/tacticalrmm/agents/migrations/0039_auto_20210714_0738.py

@@ -1,7 +1,7 @@
 # Generated by Django 3.2.5 on 2021-07-14 07:38
 
-import django.db.models.deletion
 from django.db import migrations, models
+import django.db.models.deletion
 
 
 class Migration(migrations.Migration):

api/tacticalrmm/agents/migrations/0043_auto_20220227_0554.py

@@ -1,25 +0,0 @@
-# Generated by Django 3.2.12 on 2022-02-27 05:54
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0042_alter_agent_time_zone'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='agent',
-            name='antivirus',
-        ),
-        migrations.RemoveField(
-            model_name='agent',
-            name='local_ip',
-        ),
-        migrations.RemoveField(
-            model_name='agent',
-            name='used_ram',
-        ),
-    ]

api/tacticalrmm/agents/migrations/0044_auto_20220227_0717.py

@@ -1,22 +0,0 @@
-# Generated by Django 3.2.12 on 2022-02-27 07:17
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0043_auto_20220227_0554'),
-    ]
-
-    operations = [
-        migrations.RenameField(
-            model_name='agent',
-            old_name='salt_id',
-            new_name='goarch',
-        ),
-        migrations.RemoveField(
-            model_name='agent',
-            name='salt_ver',
-        ),
-    ]

api/tacticalrmm/agents/migrations/0045_delete_recoveryaction.py

@@ -1,16 +0,0 @@
-# Generated by Django 3.2.12 on 2022-03-12 02:30
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0044_auto_20220227_0717'),
-    ]
-
-    operations = [
-        migrations.DeleteModel(
-            name='RecoveryAction',
-        ),
-    ]

api/tacticalrmm/agents/migrations/0046_alter_agenthistory_command.py

@@ -1,18 +0,0 @@
-# Generated by Django 3.2.12 on 2022-03-17 17:15
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0045_delete_recoveryaction'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='agenthistory',
-            name='command',
-            field=models.TextField(blank=True, default='', null=True),
-        ),
-    ]

api/tacticalrmm/agents/migrations/0047_alter_agent_plat_alter_agent_site.py

@@ -1,26 +0,0 @@
-# Generated by Django 4.0.3 on 2022-04-07 17:28
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('clients', '0020_auto_20211226_0547'),
-        ('agents', '0046_alter_agenthistory_command'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='agent',
-            name='plat',
-            field=models.CharField(default='windows', max_length=255),
-        ),
-        migrations.AlterField(
-            model_name='agent',
-            name='site',
-            field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.RESTRICT, related_name='agents', to='clients.site'),
-            preserve_default=False,
-        ),
-    ]

api/tacticalrmm/agents/migrations/0048_remove_agent_has_patches_pending_and_more.py

@@ -1,21 +0,0 @@
-# Generated by Django 4.0.3 on 2022-04-16 17:39
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0047_alter_agent_plat_alter_agent_site'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='agent',
-            name='has_patches_pending',
-        ),
-        migrations.RemoveField(
-            model_name='agent',
-            name='pending_actions_count',
-        ),
-    ]

api/tacticalrmm/agents/migrations/0049_agent_agents_agen_monitor_df8816_idx.py

@@ -1,17 +0,0 @@
-# Generated by Django 4.0.3 on 2022-04-18 14:29
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0048_remove_agent_has_patches_pending_and_more'),
-    ]
-
-    operations = [
-        migrations.AddIndex(
-            model_name='agent',
-            index=models.Index(fields=['monitoring_type'], name='agents_agen_monitor_df8816_idx'),
-        ),
-    ]

api/tacticalrmm/agents/migrations/0050_remove_agent_plat_release.py

@@ -1,17 +0,0 @@
-# Generated by Django 4.0.4 on 2022-04-25 06:51
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0049_agent_agents_agen_monitor_df8816_idx'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='agent',
-            name='plat_release',
-        ),
-    ]

api/tacticalrmm/agents/migrations/0051_alter_agent_plat.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.0.4 on 2022-05-18 03:50
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0050_remove_agent_plat_release'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='agent',
-            name='plat',
-            field=models.CharField(choices=[('windows', 'Windows'), ('linux', 'Linux'), ('darwin', 'macOS')], default='windows', max_length=255),
-        ),
-    ]

api/tacticalrmm/agents/migrations/0052_alter_agent_monitoring_type.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.0.4 on 2022-05-18 05:28
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0051_alter_agent_plat'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='agent',
-            name='monitoring_type',
-            field=models.CharField(choices=[('server', 'Server'), ('workstation', 'Workstation')], default='server', max_length=30),
-        ),
-    ]

api/tacticalrmm/agents/migrations/0053_remove_agenthistory_status.py

@@ -1,17 +0,0 @@
-# Generated by Django 4.0.4 on 2022-05-18 06:10
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0052_alter_agent_monitoring_type'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='agenthistory',
-            name='status',
-        ),
-    ]

api/tacticalrmm/agents/migrations/0054_alter_agent_goarch.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.0.4 on 2022-06-06 04:03
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('agents', '0053_remove_agenthistory_status'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='agent',
-            name='goarch',
-            field=models.CharField(blank=True, choices=[('amd64', 'amd64'), ('386', '386'), ('arm64', 'arm64'), ('arm', 'arm')], max_length=255, null=True),
-        ),
-    ]

api/tacticalrmm/agents/migrations/0055_alter_agent_time_zone.py

@@ -1,631 +0,0 @@
-# Generated by Django 4.1 on 2022-08-24 07:32
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("agents", "0054_alter_agent_goarch"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="agent",
-            name="time_zone",
-            field=models.CharField(
-                blank=True,
-                choices=[
-                    ("Africa/Abidjan", "Africa/Abidjan"),
-                    ("Africa/Accra", "Africa/Accra"),
-                    ("Africa/Addis_Ababa", "Africa/Addis_Ababa"),
-                    ("Africa/Algiers", "Africa/Algiers"),
-                    ("Africa/Asmara", "Africa/Asmara"),
-                    ("Africa/Asmera", "Africa/Asmera"),
-                    ("Africa/Bamako", "Africa/Bamako"),
-                    ("Africa/Bangui", "Africa/Bangui"),
-                    ("Africa/Banjul", "Africa/Banjul"),
-                    ("Africa/Bissau", "Africa/Bissau"),
-                    ("Africa/Blantyre", "Africa/Blantyre"),
-                    ("Africa/Brazzaville", "Africa/Brazzaville"),
-                    ("Africa/Bujumbura", "Africa/Bujumbura"),
-                    ("Africa/Cairo", "Africa/Cairo"),
-                    ("Africa/Casablanca", "Africa/Casablanca"),
-                    ("Africa/Ceuta", "Africa/Ceuta"),
-                    ("Africa/Conakry", "Africa/Conakry"),
-                    ("Africa/Dakar", "Africa/Dakar"),
-                    ("Africa/Dar_es_Salaam", "Africa/Dar_es_Salaam"),
-                    ("Africa/Djibouti", "Africa/Djibouti"),
-                    ("Africa/Douala", "Africa/Douala"),
-                    ("Africa/El_Aaiun", "Africa/El_Aaiun"),
-                    ("Africa/Freetown", "Africa/Freetown"),
-                    ("Africa/Gaborone", "Africa/Gaborone"),
-                    ("Africa/Harare", "Africa/Harare"),
-                    ("Africa/Johannesburg", "Africa/Johannesburg"),
-                    ("Africa/Juba", "Africa/Juba"),
-                    ("Africa/Kampala", "Africa/Kampala"),
-                    ("Africa/Khartoum", "Africa/Khartoum"),
-                    ("Africa/Kigali", "Africa/Kigali"),
-                    ("Africa/Kinshasa", "Africa/Kinshasa"),
-                    ("Africa/Lagos", "Africa/Lagos"),
-                    ("Africa/Libreville", "Africa/Libreville"),
-                    ("Africa/Lome", "Africa/Lome"),
-                    ("Africa/Luanda", "Africa/Luanda"),
-                    ("Africa/Lubumbashi", "Africa/Lubumbashi"),
-                    ("Africa/Lusaka", "Africa/Lusaka"),
-                    ("Africa/Malabo", "Africa/Malabo"),
-                    ("Africa/Maputo", "Africa/Maputo"),
-                    ("Africa/Maseru", "Africa/Maseru"),
-                    ("Africa/Mbabane", "Africa/Mbabane"),
-                    ("Africa/Mogadishu", "Africa/Mogadishu"),
-                    ("Africa/Monrovia", "Africa/Monrovia"),
-                    ("Africa/Nairobi", "Africa/Nairobi"),
-                    ("Africa/Ndjamena", "Africa/Ndjamena"),
-                    ("Africa/Niamey", "Africa/Niamey"),
-                    ("Africa/Nouakchott", "Africa/Nouakchott"),
-                    ("Africa/Ouagadougou", "Africa/Ouagadougou"),
-                    ("Africa/Porto-Novo", "Africa/Porto-Novo"),
-                    ("Africa/Sao_Tome", "Africa/Sao_Tome"),
-                    ("Africa/Timbuktu", "Africa/Timbuktu"),
-                    ("Africa/Tripoli", "Africa/Tripoli"),
-                    ("Africa/Tunis", "Africa/Tunis"),
-                    ("Africa/Windhoek", "Africa/Windhoek"),
-                    ("America/Adak", "America/Adak"),
-                    ("America/Anchorage", "America/Anchorage"),
-                    ("America/Anguilla", "America/Anguilla"),
-                    ("America/Antigua", "America/Antigua"),
-                    ("America/Araguaina", "America/Araguaina"),
-                    (
-                        "America/Argentina/Buenos_Aires",
-                        "America/Argentina/Buenos_Aires",
-                    ),
-                    ("America/Argentina/Catamarca", "America/Argentina/Catamarca"),
-                    (
-                        "America/Argentina/ComodRivadavia",
-                        "America/Argentina/ComodRivadavia",
-                    ),
-                    ("America/Argentina/Cordoba", "America/Argentina/Cordoba"),
-                    ("America/Argentina/Jujuy", "America/Argentina/Jujuy"),
-                    ("America/Argentina/La_Rioja", "America/Argentina/La_Rioja"),
-                    ("America/Argentina/Mendoza", "America/Argentina/Mendoza"),
-                    (
-                        "America/Argentina/Rio_Gallegos",
-                        "America/Argentina/Rio_Gallegos",
-                    ),
-                    ("America/Argentina/Salta", "America/Argentina/Salta"),
-                    ("America/Argentina/San_Juan", "America/Argentina/San_Juan"),
-                    ("America/Argentina/San_Luis", "America/Argentina/San_Luis"),
-                    ("America/Argentina/Tucuman", "America/Argentina/Tucuman"),
-                    ("America/Argentina/Ushuaia", "America/Argentina/Ushuaia"),
-                    ("America/Aruba", "America/Aruba"),
-                    ("America/Asuncion", "America/Asuncion"),
-                    ("America/Atikokan", "America/Atikokan"),
-                    ("America/Atka", "America/Atka"),
-                    ("America/Bahia", "America/Bahia"),
-                    ("America/Bahia_Banderas", "America/Bahia_Banderas"),
-                    ("America/Barbados", "America/Barbados"),
-                    ("America/Belem", "America/Belem"),
-                    ("America/Belize", "America/Belize"),
-                    ("America/Blanc-Sablon", "America/Blanc-Sablon"),
-                    ("America/Boa_Vista", "America/Boa_Vista"),
-                    ("America/Bogota", "America/Bogota"),
-                    ("America/Boise", "America/Boise"),
-                    ("America/Buenos_Aires", "America/Buenos_Aires"),
-                    ("America/Cambridge_Bay", "America/Cambridge_Bay"),
-                    ("America/Campo_Grande", "America/Campo_Grande"),
-                    ("America/Cancun", "America/Cancun"),
-                    ("America/Caracas", "America/Caracas"),
-                    ("America/Catamarca", "America/Catamarca"),
-                    ("America/Cayenne", "America/Cayenne"),
-                    ("America/Cayman", "America/Cayman"),
-                    ("America/Chicago", "America/Chicago"),
-                    ("America/Chihuahua", "America/Chihuahua"),
-                    ("America/Coral_Harbour", "America/Coral_Harbour"),
-                    ("America/Cordoba", "America/Cordoba"),
-                    ("America/Costa_Rica", "America/Costa_Rica"),
-                    ("America/Creston", "America/Creston"),
-                    ("America/Cuiaba", "America/Cuiaba"),
-                    ("America/Curacao", "America/Curacao"),
-                    ("America/Danmarkshavn", "America/Danmarkshavn"),
-                    ("America/Dawson", "America/Dawson"),
-                    ("America/Dawson_Creek", "America/Dawson_Creek"),
-                    ("America/Denver", "America/Denver"),
-                    ("America/Detroit", "America/Detroit"),
-                    ("America/Dominica", "America/Dominica"),
-                    ("America/Edmonton", "America/Edmonton"),
-                    ("America/Eirunepe", "America/Eirunepe"),
-                    ("America/El_Salvador", "America/El_Salvador"),
-                    ("America/Ensenada", "America/Ensenada"),
-                    ("America/Fort_Nelson", "America/Fort_Nelson"),
-                    ("America/Fort_Wayne", "America/Fort_Wayne"),
-                    ("America/Fortaleza", "America/Fortaleza"),
-                    ("America/Glace_Bay", "America/Glace_Bay"),
-                    ("America/Godthab", "America/Godthab"),
-                    ("America/Goose_Bay", "America/Goose_Bay"),
-                    ("America/Grand_Turk", "America/Grand_Turk"),
-                    ("America/Grenada", "America/Grenada"),
-                    ("America/Guadeloupe", "America/Guadeloupe"),
-                    ("America/Guatemala", "America/Guatemala"),
-                    ("America/Guayaquil", "America/Guayaquil"),
-                    ("America/Guyana", "America/Guyana"),
-                    ("America/Halifax", "America/Halifax"),
-                    ("America/Havana", "America/Havana"),
-                    ("America/Hermosillo", "America/Hermosillo"),
-                    ("America/Indiana/Indianapolis", "America/Indiana/Indianapolis"),
-                    ("America/Indiana/Knox", "America/Indiana/Knox"),
-                    ("America/Indiana/Marengo", "America/Indiana/Marengo"),
-                    ("America/Indiana/Petersburg", "America/Indiana/Petersburg"),
-                    ("America/Indiana/Tell_City", "America/Indiana/Tell_City"),
-                    ("America/Indiana/Vevay", "America/Indiana/Vevay"),
-                    ("America/Indiana/Vincennes", "America/Indiana/Vincennes"),
-                    ("America/Indiana/Winamac", "America/Indiana/Winamac"),
-                    ("America/Indianapolis", "America/Indianapolis"),
-                    ("America/Inuvik", "America/Inuvik"),
-                    ("America/Iqaluit", "America/Iqaluit"),
-                    ("America/Jamaica", "America/Jamaica"),
-                    ("America/Jujuy", "America/Jujuy"),
-                    ("America/Juneau", "America/Juneau"),
-                    ("America/Kentucky/Louisville", "America/Kentucky/Louisville"),
-                    ("America/Kentucky/Monticello", "America/Kentucky/Monticello"),
-                    ("America/Knox_IN", "America/Knox_IN"),
-                    ("America/Kralendijk", "America/Kralendijk"),
-                    ("America/La_Paz", "America/La_Paz"),
-                    ("America/Lima", "America/Lima"),
-                    ("America/Los_Angeles", "America/Los_Angeles"),
-                    ("America/Louisville", "America/Louisville"),
-                    ("America/Lower_Princes", "America/Lower_Princes"),
-                    ("America/Maceio", "America/Maceio"),
-                    ("America/Managua", "America/Managua"),
-                    ("America/Manaus", "America/Manaus"),
-                    ("America/Marigot", "America/Marigot"),
-                    ("America/Martinique", "America/Martinique"),
-                    ("America/Matamoros", "America/Matamoros"),
-                    ("America/Mazatlan", "America/Mazatlan"),
-                    ("America/Mendoza", "America/Mendoza"),
-                    ("America/Menominee", "America/Menominee"),
-                    ("America/Merida", "America/Merida"),
-                    ("America/Metlakatla", "America/Metlakatla"),
-                    ("America/Mexico_City", "America/Mexico_City"),
-                    ("America/Miquelon", "America/Miquelon"),
-                    ("America/Moncton", "America/Moncton"),
-                    ("America/Monterrey", "America/Monterrey"),
-                    ("America/Montevideo", "America/Montevideo"),
-                    ("America/Montreal", "America/Montreal"),
-                    ("America/Montserrat", "America/Montserrat"),
-                    ("America/Nassau", "America/Nassau"),
-                    ("America/New_York", "America/New_York"),
-                    ("America/Nipigon", "America/Nipigon"),
-                    ("America/Nome", "America/Nome"),
-                    ("America/Noronha", "America/Noronha"),
-                    ("America/North_Dakota/Beulah", "America/North_Dakota/Beulah"),
-                    ("America/North_Dakota/Center", "America/North_Dakota/Center"),
-                    (
-                        "America/North_Dakota/New_Salem",
-                        "America/North_Dakota/New_Salem",
-                    ),
-                    ("America/Nuuk", "America/Nuuk"),
-                    ("America/Ojinaga", "America/Ojinaga"),
-                    ("America/Panama", "America/Panama"),
-                    ("America/Pangnirtung", "America/Pangnirtung"),
-                    ("America/Paramaribo", "America/Paramaribo"),
-                    ("America/Phoenix", "America/Phoenix"),
-                    ("America/Port-au-Prince", "America/Port-au-Prince"),
-                    ("America/Port_of_Spain", "America/Port_of_Spain"),
-                    ("America/Porto_Acre", "America/Porto_Acre"),
-                    ("America/Porto_Velho", "America/Porto_Velho"),
-                    ("America/Puerto_Rico", "America/Puerto_Rico"),
-                    ("America/Punta_Arenas", "America/Punta_Arenas"),
-                    ("America/Rainy_River", "America/Rainy_River"),
-                    ("America/Rankin_Inlet", "America/Rankin_Inlet"),
-                    ("America/Recife", "America/Recife"),
-                    ("America/Regina", "America/Regina"),
-                    ("America/Resolute", "America/Resolute"),
-                    ("America/Rio_Branco", "America/Rio_Branco"),
-                    ("America/Rosario", "America/Rosario"),
-                    ("America/Santa_Isabel", "America/Santa_Isabel"),
-                    ("America/Santarem", "America/Santarem"),
-                    ("America/Santiago", "America/Santiago"),
-                    ("America/Santo_Domingo", "America/Santo_Domingo"),
-                    ("America/Sao_Paulo", "America/Sao_Paulo"),
-                    ("America/Scoresbysund", "America/Scoresbysund"),
-                    ("America/Shiprock", "America/Shiprock"),
-                    ("America/Sitka", "America/Sitka"),
-                    ("America/St_Barthelemy", "America/St_Barthelemy"),
-                    ("America/St_Johns", "America/St_Johns"),
-                    ("America/St_Kitts", "America/St_Kitts"),
-                    ("America/St_Lucia", "America/St_Lucia"),
-                    ("America/St_Thomas", "America/St_Thomas"),
-                    ("America/St_Vincent", "America/St_Vincent"),
-                    ("America/Swift_Current", "America/Swift_Current"),
-                    ("America/Tegucigalpa", "America/Tegucigalpa"),
-                    ("America/Thule", "America/Thule"),
-                    ("America/Thunder_Bay", "America/Thunder_Bay"),
-                    ("America/Tijuana", "America/Tijuana"),
-                    ("America/Toronto", "America/Toronto"),
-                    ("America/Tortola", "America/Tortola"),
-                    ("America/Vancouver", "America/Vancouver"),
-                    ("America/Virgin", "America/Virgin"),
-                    ("America/Whitehorse", "America/Whitehorse"),
-                    ("America/Winnipeg", "America/Winnipeg"),
-                    ("America/Yakutat", "America/Yakutat"),
-                    ("America/Yellowknife", "America/Yellowknife"),
-                    ("Antarctica/Casey", "Antarctica/Casey"),
-                    ("Antarctica/Davis", "Antarctica/Davis"),
-                    ("Antarctica/DumontDUrville", "Antarctica/DumontDUrville"),
-                    ("Antarctica/Macquarie", "Antarctica/Macquarie"),
-                    ("Antarctica/Mawson", "Antarctica/Mawson"),
-                    ("Antarctica/McMurdo", "Antarctica/McMurdo"),
-                    ("Antarctica/Palmer", "Antarctica/Palmer"),
-                    ("Antarctica/Rothera", "Antarctica/Rothera"),
-                    ("Antarctica/South_Pole", "Antarctica/South_Pole"),
-                    ("Antarctica/Syowa", "Antarctica/Syowa"),
-                    ("Antarctica/Troll", "Antarctica/Troll"),
-                    ("Antarctica/Vostok", "Antarctica/Vostok"),
-                    ("Arctic/Longyearbyen", "Arctic/Longyearbyen"),
-                    ("Asia/Aden", "Asia/Aden"),
-                    ("Asia/Almaty", "Asia/Almaty"),
-                    ("Asia/Amman", "Asia/Amman"),
-                    ("Asia/Anadyr", "Asia/Anadyr"),
-                    ("Asia/Aqtau", "Asia/Aqtau"),
-                    ("Asia/Aqtobe", "Asia/Aqtobe"),
-                    ("Asia/Ashgabat", "Asia/Ashgabat"),
-                    ("Asia/Ashkhabad", "Asia/Ashkhabad"),
-                    ("Asia/Atyrau", "Asia/Atyrau"),
-                    ("Asia/Baghdad", "Asia/Baghdad"),
-                    ("Asia/Bahrain", "Asia/Bahrain"),
-                    ("Asia/Baku", "Asia/Baku"),
-                    ("Asia/Bangkok", "Asia/Bangkok"),
-                    ("Asia/Barnaul", "Asia/Barnaul"),
-                    ("Asia/Beirut", "Asia/Beirut"),
-                    ("Asia/Bishkek", "Asia/Bishkek"),
-                    ("Asia/Brunei", "Asia/Brunei"),
-                    ("Asia/Calcutta", "Asia/Calcutta"),
-                    ("Asia/Chita", "Asia/Chita"),
-                    ("Asia/Choibalsan", "Asia/Choibalsan"),
-                    ("Asia/Chongqing", "Asia/Chongqing"),
-                    ("Asia/Chungking", "Asia/Chungking"),
-                    ("Asia/Colombo", "Asia/Colombo"),
-                    ("Asia/Dacca", "Asia/Dacca"),
-                    ("Asia/Damascus", "Asia/Damascus"),
-                    ("Asia/Dhaka", "Asia/Dhaka"),
-                    ("Asia/Dili", "Asia/Dili"),
-                    ("Asia/Dubai", "Asia/Dubai"),
-                    ("Asia/Dushanbe", "Asia/Dushanbe"),
-                    ("Asia/Famagusta", "Asia/Famagusta"),
-                    ("Asia/Gaza", "Asia/Gaza"),
-                    ("Asia/Harbin", "Asia/Harbin"),
-                    ("Asia/Hebron", "Asia/Hebron"),
-                    ("Asia/Ho_Chi_Minh", "Asia/Ho_Chi_Minh"),
-                    ("Asia/Hong_Kong", "Asia/Hong_Kong"),
-                    ("Asia/Hovd", "Asia/Hovd"),
-                    ("Asia/Irkutsk", "Asia/Irkutsk"),
-                    ("Asia/Istanbul", "Asia/Istanbul"),
-                    ("Asia/Jakarta", "Asia/Jakarta"),
-                    ("Asia/Jayapura", "Asia/Jayapura"),
-                    ("Asia/Jerusalem", "Asia/Jerusalem"),
-                    ("Asia/Kabul", "Asia/Kabul"),
-                    ("Asia/Kamchatka", "Asia/Kamchatka"),
-                    ("Asia/Karachi", "Asia/Karachi"),
-                    ("Asia/Kashgar", "Asia/Kashgar"),
-                    ("Asia/Kathmandu", "Asia/Kathmandu"),
-                    ("Asia/Katmandu", "Asia/Katmandu"),
-                    ("Asia/Khandyga", "Asia/Khandyga"),
-                    ("Asia/Kolkata", "Asia/Kolkata"),
-                    ("Asia/Krasnoyarsk", "Asia/Krasnoyarsk"),
-                    ("Asia/Kuala_Lumpur", "Asia/Kuala_Lumpur"),
-                    ("Asia/Kuching", "Asia/Kuching"),
-                    ("Asia/Kuwait", "Asia/Kuwait"),
-                    ("Asia/Macao", "Asia/Macao"),
-                    ("Asia/Macau", "Asia/Macau"),
-                    ("Asia/Magadan", "Asia/Magadan"),
-                    ("Asia/Makassar", "Asia/Makassar"),
-                    ("Asia/Manila", "Asia/Manila"),
-                    ("Asia/Muscat", "Asia/Muscat"),
-                    ("Asia/Nicosia", "Asia/Nicosia"),
-                    ("Asia/Novokuznetsk", "Asia/Novokuznetsk"),
-                    ("Asia/Novosibirsk", "Asia/Novosibirsk"),
-                    ("Asia/Omsk", "Asia/Omsk"),
-                    ("Asia/Oral", "Asia/Oral"),
-                    ("Asia/Phnom_Penh", "Asia/Phnom_Penh"),
-                    ("Asia/Pontianak", "Asia/Pontianak"),
-                    ("Asia/Pyongyang", "Asia/Pyongyang"),
-                    ("Asia/Qatar", "Asia/Qatar"),
-                    ("Asia/Qostanay", "Asia/Qostanay"),
-                    ("Asia/Qyzylorda", "Asia/Qyzylorda"),
-                    ("Asia/Rangoon", "Asia/Rangoon"),
-                    ("Asia/Riyadh", "Asia/Riyadh"),
-                    ("Asia/Saigon", "Asia/Saigon"),
-                    ("Asia/Sakhalin", "Asia/Sakhalin"),
-                    ("Asia/Samarkand", "Asia/Samarkand"),
-                    ("Asia/Seoul", "Asia/Seoul"),
-                    ("Asia/Shanghai", "Asia/Shanghai"),
-                    ("Asia/Singapore", "Asia/Singapore"),
-                    ("Asia/Srednekolymsk", "Asia/Srednekolymsk"),
-                    ("Asia/Taipei", "Asia/Taipei"),
-                    ("Asia/Tashkent", "Asia/Tashkent"),
-                    ("Asia/Tbilisi", "Asia/Tbilisi"),
-                    ("Asia/Tehran", "Asia/Tehran"),
-                    ("Asia/Tel_Aviv", "Asia/Tel_Aviv"),
-                    ("Asia/Thimbu", "Asia/Thimbu"),
-                    ("Asia/Thimphu", "Asia/Thimphu"),
-                    ("Asia/Tokyo", "Asia/Tokyo"),
-                    ("Asia/Tomsk", "Asia/Tomsk"),
-                    ("Asia/Ujung_Pandang", "Asia/Ujung_Pandang"),
-                    ("Asia/Ulaanbaatar", "Asia/Ulaanbaatar"),
-                    ("Asia/Ulan_Bator", "Asia/Ulan_Bator"),
-                    ("Asia/Urumqi", "Asia/Urumqi"),
-                    ("Asia/Ust-Nera", "Asia/Ust-Nera"),
-                    ("Asia/Vientiane", "Asia/Vientiane"),
-                    ("Asia/Vladivostok", "Asia/Vladivostok"),
-                    ("Asia/Yakutsk", "Asia/Yakutsk"),
-                    ("Asia/Yangon", "Asia/Yangon"),
-                    ("Asia/Yekaterinburg", "Asia/Yekaterinburg"),
-                    ("Asia/Yerevan", "Asia/Yerevan"),
-                    ("Atlantic/Azores", "Atlantic/Azores"),
-                    ("Atlantic/Bermuda", "Atlantic/Bermuda"),
-                    ("Atlantic/Canary", "Atlantic/Canary"),
-                    ("Atlantic/Cape_Verde", "Atlantic/Cape_Verde"),
-                    ("Atlantic/Faeroe", "Atlantic/Faeroe"),
-                    ("Atlantic/Faroe", "Atlantic/Faroe"),
-                    ("Atlantic/Jan_Mayen", "Atlantic/Jan_Mayen"),
-                    ("Atlantic/Madeira", "Atlantic/Madeira"),
-                    ("Atlantic/Reykjavik", "Atlantic/Reykjavik"),
-                    ("Atlantic/South_Georgia", "Atlantic/South_Georgia"),
-                    ("Atlantic/St_Helena", "Atlantic/St_Helena"),
-                    ("Atlantic/Stanley", "Atlantic/Stanley"),
-                    ("Australia/ACT", "Australia/ACT"),
-                    ("Australia/Adelaide", "Australia/Adelaide"),
-                    ("Australia/Brisbane", "Australia/Brisbane"),
-                    ("Australia/Broken_Hill", "Australia/Broken_Hill"),
-                    ("Australia/Canberra", "Australia/Canberra"),
-                    ("Australia/Currie", "Australia/Currie"),
-                    ("Australia/Darwin", "Australia/Darwin"),
-                    ("Australia/Eucla", "Australia/Eucla"),
-                    ("Australia/Hobart", "Australia/Hobart"),
-                    ("Australia/LHI", "Australia/LHI"),
-                    ("Australia/Lindeman", "Australia/Lindeman"),
-                    ("Australia/Lord_Howe", "Australia/Lord_Howe"),
-                    ("Australia/Melbourne", "Australia/Melbourne"),
-                    ("Australia/NSW", "Australia/NSW"),
-                    ("Australia/North", "Australia/North"),
-                    ("Australia/Perth", "Australia/Perth"),
-                    ("Australia/Queensland", "Australia/Queensland"),
-                    ("Australia/South", "Australia/South"),
-                    ("Australia/Sydney", "Australia/Sydney"),
-                    ("Australia/Tasmania", "Australia/Tasmania"),
-                    ("Australia/Victoria", "Australia/Victoria"),
-                    ("Australia/West", "Australia/West"),
-                    ("Australia/Yancowinna", "Australia/Yancowinna"),
-                    ("Brazil/Acre", "Brazil/Acre"),
-                    ("Brazil/DeNoronha", "Brazil/DeNoronha"),
-                    ("Brazil/East", "Brazil/East"),
-                    ("Brazil/West", "Brazil/West"),
-                    ("CET", "CET"),
-                    ("CST6CDT", "CST6CDT"),
-                    ("Canada/Atlantic", "Canada/Atlantic"),
-                    ("Canada/Central", "Canada/Central"),
-                    ("Canada/Eastern", "Canada/Eastern"),
-                    ("Canada/Mountain", "Canada/Mountain"),
-                    ("Canada/Newfoundland", "Canada/Newfoundland"),
-                    ("Canada/Pacific", "Canada/Pacific"),
-                    ("Canada/Saskatchewan", "Canada/Saskatchewan"),
-                    ("Canada/Yukon", "Canada/Yukon"),
-                    ("Chile/Continental", "Chile/Continental"),
-                    ("Chile/EasterIsland", "Chile/EasterIsland"),
-                    ("Cuba", "Cuba"),
-                    ("EET", "EET"),
-                    ("EST", "EST"),
-                    ("EST5EDT", "EST5EDT"),
-                    ("Egypt", "Egypt"),
-                    ("Eire", "Eire"),
-                    ("Etc/GMT", "Etc/GMT"),
-                    ("Etc/GMT+0", "Etc/GMT+0"),
-                    ("Etc/GMT+1", "Etc/GMT+1"),
-                    ("Etc/GMT+10", "Etc/GMT+10"),
-                    ("Etc/GMT+11", "Etc/GMT+11"),
-                    ("Etc/GMT+12", "Etc/GMT+12"),
-                    ("Etc/GMT+2", "Etc/GMT+2"),
-                    ("Etc/GMT+3", "Etc/GMT+3"),
-                    ("Etc/GMT+4", "Etc/GMT+4"),
-                    ("Etc/GMT+5", "Etc/GMT+5"),
-                    ("Etc/GMT+6", "Etc/GMT+6"),
-                    ("Etc/GMT+7", "Etc/GMT+7"),
-                    ("Etc/GMT+8", "Etc/GMT+8"),
-                    ("Etc/GMT+9", "Etc/GMT+9"),
-                    ("Etc/GMT-0", "Etc/GMT-0"),
-                    ("Etc/GMT-1", "Etc/GMT-1"),
-                    ("Etc/GMT-10", "Etc/GMT-10"),
-                    ("Etc/GMT-11", "Etc/GMT-11"),
-                    ("Etc/GMT-12", "Etc/GMT-12"),
-                    ("Etc/GMT-13", "Etc/GMT-13"),
-                    ("Etc/GMT-14", "Etc/GMT-14"),
-                    ("Etc/GMT-2", "Etc/GMT-2"),
-                    ("Etc/GMT-3", "Etc/GMT-3"),
-                    ("Etc/GMT-4", "Etc/GMT-4"),
-                    ("Etc/GMT-5", "Etc/GMT-5"),
-                    ("Etc/GMT-6", "Etc/GMT-6"),
-                    ("Etc/GMT-7", "Etc/GMT-7"),
-                    ("Etc/GMT-8", "Etc/GMT-8"),
-                    ("Etc/GMT-9", "Etc/GMT-9"),
-                    ("Etc/GMT0", "Etc/GMT0"),
-                    ("Etc/Greenwich", "Etc/Greenwich"),
-                    ("Etc/UCT", "Etc/UCT"),
-                    ("Etc/UTC", "Etc/UTC"),
-                    ("Etc/Universal", "Etc/Universal"),
-                    ("Etc/Zulu", "Etc/Zulu"),
-                    ("Europe/Amsterdam", "Europe/Amsterdam"),
-                    ("Europe/Andorra", "Europe/Andorra"),
-                    ("Europe/Astrakhan", "Europe/Astrakhan"),
-                    ("Europe/Athens", "Europe/Athens"),
-                    ("Europe/Belfast", "Europe/Belfast"),
-                    ("Europe/Belgrade", "Europe/Belgrade"),
-                    ("Europe/Berlin", "Europe/Berlin"),
-                    ("Europe/Bratislava", "Europe/Bratislava"),
-                    ("Europe/Brussels", "Europe/Brussels"),
-                    ("Europe/Bucharest", "Europe/Bucharest"),
-                    ("Europe/Budapest", "Europe/Budapest"),
-                    ("Europe/Busingen", "Europe/Busingen"),
-                    ("Europe/Chisinau", "Europe/Chisinau"),
-                    ("Europe/Copenhagen", "Europe/Copenhagen"),
-                    ("Europe/Dublin", "Europe/Dublin"),
-                    ("Europe/Gibraltar", "Europe/Gibraltar"),
-                    ("Europe/Guernsey", "Europe/Guernsey"),
-                    ("Europe/Helsinki", "Europe/Helsinki"),
-                    ("Europe/Isle_of_Man", "Europe/Isle_of_Man"),
-                    ("Europe/Istanbul", "Europe/Istanbul"),
-                    ("Europe/Jersey", "Europe/Jersey"),
-                    ("Europe/Kaliningrad", "Europe/Kaliningrad"),
-                    ("Europe/Kiev", "Europe/Kiev"),
-                    ("Europe/Kirov", "Europe/Kirov"),
-                    ("Europe/Kyiv", "Europe/Kyiv"),
-                    ("Europe/Lisbon", "Europe/Lisbon"),
-                    ("Europe/Ljubljana", "Europe/Ljubljana"),
-                    ("Europe/London", "Europe/London"),
-                    ("Europe/Luxembourg", "Europe/Luxembourg"),
-                    ("Europe/Madrid", "Europe/Madrid"),
-                    ("Europe/Malta", "Europe/Malta"),
-                    ("Europe/Mariehamn", "Europe/Mariehamn"),
-                    ("Europe/Minsk", "Europe/Minsk"),
-                    ("Europe/Monaco", "Europe/Monaco"),
-                    ("Europe/Moscow", "Europe/Moscow"),
-                    ("Europe/Nicosia", "Europe/Nicosia"),
-                    ("Europe/Oslo", "Europe/Oslo"),
-                    ("Europe/Paris", "Europe/Paris"),
-                    ("Europe/Podgorica", "Europe/Podgorica"),
-                    ("Europe/Prague", "Europe/Prague"),
-                    ("Europe/Riga", "Europe/Riga"),
-                    ("Europe/Rome", "Europe/Rome"),
-                    ("Europe/Samara", "Europe/Samara"),
-                    ("Europe/San_Marino", "Europe/San_Marino"),
-                    ("Europe/Sarajevo", "Europe/Sarajevo"),
-                    ("Europe/Saratov", "Europe/Saratov"),
-                    ("Europe/Simferopol", "Europe/Simferopol"),
-                    ("Europe/Skopje", "Europe/Skopje"),
-                    ("Europe/Sofia", "Europe/Sofia"),
-                    ("Europe/Stockholm", "Europe/Stockholm"),
-                    ("Europe/Tallinn", "Europe/Tallinn"),
-                    ("Europe/Tirane", "Europe/Tirane"),
-                    ("Europe/Tiraspol", "Europe/Tiraspol"),
-                    ("Europe/Ulyanovsk", "Europe/Ulyanovsk"),
-                    ("Europe/Uzhgorod", "Europe/Uzhgorod"),
-                    ("Europe/Vaduz", "Europe/Vaduz"),
-                    ("Europe/Vatican", "Europe/Vatican"),
-                    ("Europe/Vienna", "Europe/Vienna"),
-                    ("Europe/Vilnius", "Europe/Vilnius"),
-                    ("Europe/Volgograd", "Europe/Volgograd"),
-                    ("Europe/Warsaw", "Europe/Warsaw"),
-                    ("Europe/Zagreb", "Europe/Zagreb"),
-                    ("Europe/Zaporozhye", "Europe/Zaporozhye"),
-                    ("Europe/Zurich", "Europe/Zurich"),
-                    ("GB", "GB"),
-                    ("GB-Eire", "GB-Eire"),
-                    ("GMT", "GMT"),
-                    ("GMT+0", "GMT+0"),
-                    ("GMT-0", "GMT-0"),
-                    ("GMT0", "GMT0"),
-                    ("Greenwich", "Greenwich"),
-                    ("HST", "HST"),
-                    ("Hongkong", "Hongkong"),
-                    ("Iceland", "Iceland"),
-                    ("Indian/Antananarivo", "Indian/Antananarivo"),
-                    ("Indian/Chagos", "Indian/Chagos"),
-                    ("Indian/Christmas", "Indian/Christmas"),
-                    ("Indian/Cocos", "Indian/Cocos"),
-                    ("Indian/Comoro", "Indian/Comoro"),
-                    ("Indian/Kerguelen", "Indian/Kerguelen"),
-                    ("Indian/Mahe", "Indian/Mahe"),
-                    ("Indian/Maldives", "Indian/Maldives"),
-                    ("Indian/Mauritius", "Indian/Mauritius"),
-                    ("Indian/Mayotte", "Indian/Mayotte"),
-                    ("Indian/Reunion", "Indian/Reunion"),
-                    ("Iran", "Iran"),
-                    ("Israel", "Israel"),
-                    ("Jamaica", "Jamaica"),
-                    ("Japan", "Japan"),
-                    ("Kwajalein", "Kwajalein"),
-                    ("Libya", "Libya"),
-                    ("MET", "MET"),
-                    ("MST", "MST"),
-                    ("MST7MDT", "MST7MDT"),
-                    ("Mexico/BajaNorte", "Mexico/BajaNorte"),
-                    ("Mexico/BajaSur", "Mexico/BajaSur"),
-                    ("Mexico/General", "Mexico/General"),
-                    ("NZ", "NZ"),
-                    ("NZ-CHAT", "NZ-CHAT"),
-                    ("Navajo", "Navajo"),
-                    ("PRC", "PRC"),
-                    ("PST8PDT", "PST8PDT"),
-                    ("Pacific/Apia", "Pacific/Apia"),
-                    ("Pacific/Auckland", "Pacific/Auckland"),
-                    ("Pacific/Bougainville", "Pacific/Bougainville"),
-                    ("Pacific/Chatham", "Pacific/Chatham"),
-                    ("Pacific/Chuuk", "Pacific/Chuuk"),
-                    ("Pacific/Easter", "Pacific/Easter"),
-                    ("Pacific/Efate", "Pacific/Efate"),
-                    ("Pacific/Enderbury", "Pacific/Enderbury"),
-                    ("Pacific/Fakaofo", "Pacific/Fakaofo"),
-                    ("Pacific/Fiji", "Pacific/Fiji"),
-                    ("Pacific/Funafuti", "Pacific/Funafuti"),
-                    ("Pacific/Galapagos", "Pacific/Galapagos"),
-                    ("Pacific/Gambier", "Pacific/Gambier"),
-                    ("Pacific/Guadalcanal", "Pacific/Guadalcanal"),
-                    ("Pacific/Guam", "Pacific/Guam"),
-                    ("Pacific/Honolulu", "Pacific/Honolulu"),
-                    ("Pacific/Johnston", "Pacific/Johnston"),
-                    ("Pacific/Kanton", "Pacific/Kanton"),
-                    ("Pacific/Kiritimati", "Pacific/Kiritimati"),
-                    ("Pacific/Kosrae", "Pacific/Kosrae"),
-                    ("Pacific/Kwajalein", "Pacific/Kwajalein"),
-                    ("Pacific/Majuro", "Pacific/Majuro"),
-                    ("Pacific/Marquesas", "Pacific/Marquesas"),
-                    ("Pacific/Midway", "Pacific/Midway"),
-                    ("Pacific/Nauru", "Pacific/Nauru"),
-                    ("Pacific/Niue", "Pacific/Niue"),
-                    ("Pacific/Norfolk", "Pacific/Norfolk"),
-                    ("Pacific/Noumea", "Pacific/Noumea"),
-                    ("Pacific/Pago_Pago", "Pacific/Pago_Pago"),
-                    ("Pacific/Palau", "Pacific/Palau"),
-                    ("Pacific/Pitcairn", "Pacific/Pitcairn"),
-                    ("Pacific/Pohnpei", "Pacific/Pohnpei"),
-                    ("Pacific/Ponape", "Pacific/Ponape"),
-                    ("Pacific/Port_Moresby", "Pacific/Port_Moresby"),
-                    ("Pacific/Rarotonga", "Pacific/Rarotonga"),
-                    ("Pacific/Saipan", "Pacific/Saipan"),
-                    ("Pacific/Samoa", "Pacific/Samoa"),
-                    ("Pacific/Tahiti", "Pacific/Tahiti"),
-                    ("Pacific/Tarawa", "Pacific/Tarawa"),
-                    ("Pacific/Tongatapu", "Pacific/Tongatapu"),
-                    ("Pacific/Truk", "Pacific/Truk"),
-                    ("Pacific/Wake", "Pacific/Wake"),
-                    ("Pacific/Wallis", "Pacific/Wallis"),
-                    ("Pacific/Yap", "Pacific/Yap"),
-                    ("Poland", "Poland"),
-                    ("Portugal", "Portugal"),
-                    ("ROC", "ROC"),
-                    ("ROK", "ROK"),
-                    ("Singapore", "Singapore"),
-                    ("Turkey", "Turkey"),
-                    ("UCT", "UCT"),
-                    ("US/Alaska", "US/Alaska"),
-                    ("US/Aleutian", "US/Aleutian"),
-                    ("US/Arizona", "US/Arizona"),
-                    ("US/Central", "US/Central"),
-                    ("US/East-Indiana", "US/East-Indiana"),
-                    ("US/Eastern", "US/Eastern"),
-                    ("US/Hawaii", "US/Hawaii"),
-                    ("US/Indiana-Starke", "US/Indiana-Starke"),
-                    ("US/Michigan", "US/Michigan"),
-                    ("US/Mountain", "US/Mountain"),
-                    ("US/Pacific", "US/Pacific"),
-                    ("US/Samoa", "US/Samoa"),
-                    ("UTC", "UTC"),
-                    ("Universal", "Universal"),
-                    ("W-SU", "W-SU"),
-                    ("WET", "WET"),
-                    ("Zulu", "Zulu"),
-                ],
-                max_length=255,
-                null=True,
-            ),
-        ),
-    ]

api/tacticalrmm/agents/permissions.py

@@ -4,7 +4,7 @@ from tacticalrmm.permissions import _has_perm, _has_perm_on_agent
 
 
 class AgentPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         if r.method == "GET":
             if "agent_id" in view.kwargs.keys():
                 return _has_perm(r, "can_list_agents") and _has_perm_on_agent(
@@ -26,76 +26,73 @@ class AgentPerms(permissions.BasePermission):
 
 
 class RecoverAgentPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
-        if "agent_id" not in view.kwargs.keys():
-            return _has_perm(r, "can_recover_agents")
-
+    def has_permission(self, r, view):
         return _has_perm(r, "can_recover_agents") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class MeshPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_use_mesh") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class UpdateAgentPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_update_agents")
 
 
 class PingAgentPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_ping_agents") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class ManageProcPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_manage_procs") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class EvtLogPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_view_eventlogs") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class SendCMDPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_send_cmd") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class RebootAgentPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_reboot_agents") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class InstallAgentPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_install_agents")
 
 
 class RunScriptPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_run_scripts") and _has_perm_on_agent(
             r.user, view.kwargs["agent_id"]
         )
 
 
 class AgentNotesPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
 
         # permissions for GET /agents/notes/ endpoint
         if r.method == "GET":
@@ -112,15 +109,15 @@ class AgentNotesPerms(permissions.BasePermission):
 
 
 class RunBulkPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         return _has_perm(r, "can_run_bulk")
 
 
 class AgentHistoryPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         if "agent_id" in view.kwargs.keys():
             return _has_perm(r, "can_list_agent_history") and _has_perm_on_agent(
                 r.user, view.kwargs["agent_id"]
             )
-
-        return _has_perm(r, "can_list_agent_history")
+        else:
+            return _has_perm(r, "can_list_agent_history")

api/tacticalrmm/agents/serializers.py

@@ -1,10 +1,8 @@
 import pytz
 from rest_framework import serializers
-
-from tacticalrmm.constants import AGENT_STATUS_ONLINE
 from winupdate.serializers import WinUpdatePolicySerializer
 
-from .models import Agent, AgentCustomField, AgentHistory, Note
+from .models import Agent, AgentCustomField, Note, AgentHistory
 
 
 class AgentCustomFieldSerializer(serializers.ModelSerializer):
@@ -42,33 +40,6 @@ class AgentSerializer(serializers.ModelSerializer):
     custom_fields = AgentCustomFieldSerializer(many=True, read_only=True)
     patches_last_installed = serializers.ReadOnlyField()
     last_seen = serializers.ReadOnlyField()
-    applied_policies = serializers.SerializerMethodField()
-    effective_patch_policy = serializers.SerializerMethodField()
-    alert_template = serializers.SerializerMethodField()
-
-    def get_alert_template(self, obj):
-        from alerts.serializers import AlertTemplateSerializer
-
-        return (
-            AlertTemplateSerializer(obj.alert_template).data
-            if obj.alert_template
-            else None
-        )
-
-    def get_effective_patch_policy(self, obj):
-        return WinUpdatePolicySerializer(obj.get_patch_policy()).data
-
-    def get_applied_policies(self, obj):
-        from automation.serializers import PolicySerializer
-
-        policies = obj.get_agent_policies()
-
-        # need to serialize model objects manually
-        for key, policy in policies.items():
-            if policy:
-                policies[key] = PolicySerializer(policy).data
-
-        return policies
 
     def get_all_timezones(self, obj):
         return pytz.all_timezones
@@ -81,43 +52,44 @@ class AgentSerializer(serializers.ModelSerializer):
 class AgentTableSerializer(serializers.ModelSerializer):
     status = serializers.ReadOnlyField()
     checks = serializers.ReadOnlyField()
+    last_seen = serializers.SerializerMethodField()
     client_name = serializers.ReadOnlyField(source="client.name")
     site_name = serializers.ReadOnlyField(source="site.name")
     logged_username = serializers.SerializerMethodField()
     italic = serializers.SerializerMethodField()
     policy = serializers.ReadOnlyField(source="policy.id")
     alert_template = serializers.SerializerMethodField()
-    last_seen = serializers.ReadOnlyField()
-    pending_actions_count = serializers.ReadOnlyField()
-    has_patches_pending = serializers.ReadOnlyField()
-    cpu_model = serializers.ReadOnlyField()
-    graphics = serializers.ReadOnlyField()
-    local_ips = serializers.ReadOnlyField()
-    make_model = serializers.ReadOnlyField()
-    physical_disks = serializers.ReadOnlyField()
 
     def get_alert_template(self, obj):
 
         if not obj.alert_template:
             return None
+        else:
+            return {
+                "name": obj.alert_template.name,
+                "always_email": obj.alert_template.agent_always_email,
+                "always_text": obj.alert_template.agent_always_text,
+                "always_alert": obj.alert_template.agent_always_alert,
+            }
 
-        return {
-            "name": obj.alert_template.name,
-            "always_email": obj.alert_template.agent_always_email,
-            "always_text": obj.alert_template.agent_always_text,
-            "always_alert": obj.alert_template.agent_always_alert,
-        }
+    def get_last_seen(self, obj) -> str:
+        if obj.time_zone is not None:
+            agent_tz = pytz.timezone(obj.time_zone)
+        else:
+            agent_tz = self.context["default_tz"]
+
+        return obj.last_seen.astimezone(agent_tz).strftime("%m %d %Y %H:%M")
 
     def get_logged_username(self, obj) -> str:
-        if obj.logged_in_username == "None" and obj.status == AGENT_STATUS_ONLINE:
+        if obj.logged_in_username == "None" and obj.status == "online":
             return obj.last_logged_in_user
         elif obj.logged_in_username != "None":
             return obj.logged_in_username
-
-        return "-"
+        else:
+            return "-"
 
     def get_italic(self, obj) -> bool:
-        return obj.logged_in_username == "None" and obj.status == AGENT_STATUS_ONLINE
+        return obj.logged_in_username == "None" and obj.status == "online"
 
     class Meta:
         model = Agent
@@ -130,6 +102,7 @@ class AgentTableSerializer(serializers.ModelSerializer):
             "monitoring_type",
             "description",
             "needs_reboot",
+            "has_patches_pending",
             "pending_actions_count",
             "status",
             "overdue_text_alert",
@@ -143,21 +116,16 @@ class AgentTableSerializer(serializers.ModelSerializer):
             "italic",
             "policy",
             "block_policy_inheritance",
-            "plat",
-            "goarch",
-            "has_patches_pending",
-            "version",
-            "operating_system",
-            "public_ip",
-            "cpu_model",
-            "graphics",
-            "local_ips",
-            "make_model",
-            "physical_disks",
         ]
         depth = 2
 
 
+class WinAgentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Agent
+        fields = "__all__"
+
+
 class AgentHostnameSerializer(serializers.ModelSerializer):
     client = serializers.ReadOnlyField(source="client.name")
     site = serializers.ReadOnlyField(source="site.name")
@@ -184,12 +152,17 @@ class AgentNoteSerializer(serializers.ModelSerializer):
 
 
 class AgentHistorySerializer(serializers.ModelSerializer):
+    time = serializers.SerializerMethodField(read_only=True)
     script_name = serializers.ReadOnlyField(source="script.name")
 
     class Meta:
         model = AgentHistory
         fields = "__all__"
 
+    def get_time(self, history):
+        tz = self.context["default_tz"]
+        return history.time.astimezone(tz).strftime("%m %d %Y %H:%M:%S")
+
 
 class AgentAuditSerializer(serializers.ModelSerializer):
     class Meta:

api/tacticalrmm/agents/tasks.py

@@ -1,52 +1,120 @@
+import asyncio
 import datetime as dt
 import random
 from time import sleep
-from typing import TYPE_CHECKING, Optional
+from typing import Union
 
-from django.core.management import call_command
+from core.models import CoreSettings
+from django.conf import settings
 from django.utils import timezone as djangotime
-
-from agents.models import Agent
-from core.utils import get_core_settings
-from logs.models import DebugLog
+from logs.models import DebugLog, PendingAction
+from packaging import version as pyver
 from scripts.models import Script
 from tacticalrmm.celery import app
-from tacticalrmm.constants import (
-    AGENT_DEFER,
-    AGENT_STATUS_OVERDUE,
-    CheckStatus,
-    DebugLogType,
-)
 
-if TYPE_CHECKING:
-    from django.db.models.query import QuerySet
+from agents.models import Agent
+from agents.utils import get_winagent_url
+
+
+def agent_update(agent_id: str, force: bool = False) -> str:
+
+    agent = Agent.objects.get(agent_id=agent_id)
+
+    if pyver.parse(agent.version) <= pyver.parse("1.3.0"):
+        return "not supported"
+
+    # skip if we can't determine the arch
+    if agent.arch is None:
+        DebugLog.warning(
+            agent=agent,
+            log_type="agent_issues",
+            message=f"Unable to determine arch on {agent.hostname}({agent.agent_id}). Skipping agent update.",
+        )
+        return "noarch"
+
+    version = settings.LATEST_AGENT_VER
+    inno = agent.win_inno_exe
+    url = get_winagent_url(agent.arch)
+
+    if not force:
+        if agent.pendingactions.filter(
+            action_type="agentupdate", status="pending"
+        ).exists():
+            agent.pendingactions.filter(
+                action_type="agentupdate", status="pending"
+            ).delete()
+
+        PendingAction.objects.create(
+            agent=agent,
+            action_type="agentupdate",
+            details={
+                "url": url,
+                "version": version,
+                "inno": inno,
+            },
+        )
+
+    nats_data = {
+        "func": "agentupdate",
+        "payload": {
+            "url": url,
+            "version": version,
+            "inno": inno,
+        },
+    }
+    asyncio.run(agent.nats_cmd(nats_data, wait=False))
+    return "created"
 
 
 @app.task
-def send_agent_update_task(*, agent_ids: list[str], token: str, force: bool) -> None:
-    agents: "QuerySet[Agent]" = Agent.objects.defer(*AGENT_DEFER).filter(
-        agent_id__in=agent_ids
-    )
-    for agent in agents:
-        agent.do_update(token=token, force=force)
+def force_code_sign(agent_ids: list[str]) -> None:
+    chunks = (agent_ids[i : i + 50] for i in range(0, len(agent_ids), 50))
+    for chunk in chunks:
+        for agent_id in chunk:
+            agent_update(agent_id=agent_id, force=True)
+            sleep(0.05)
+        sleep(4)
+
+
+@app.task
+def send_agent_update_task(agent_ids: list[str]) -> None:
+    chunks = (agent_ids[i : i + 50] for i in range(0, len(agent_ids), 50))
+    for chunk in chunks:
+        for agent_id in chunk:
+            agent_update(agent_id)
+            sleep(0.05)
+        sleep(4)
 
 
 @app.task
 def auto_self_agent_update_task() -> None:
-    call_command("update_agents")
+    core = CoreSettings.objects.first()
+    if not core.agent_auto_update:  # type:ignore
+        return
+
+    q = Agent.objects.only("agent_id", "version")
+    agent_ids: list[str] = [
+        i.agent_id
+        for i in q
+        if pyver.parse(i.version) < pyver.parse(settings.LATEST_AGENT_VER)
+    ]
+
+    chunks = (agent_ids[i : i + 30] for i in range(0, len(agent_ids), 30))
+    for chunk in chunks:
+        for agent_id in chunk:
+            agent_update(agent_id)
+            sleep(0.05)
+        sleep(4)
 
 
 @app.task
-def agent_outage_email_task(pk: int, alert_interval: Optional[float] = None) -> str:
+def agent_outage_email_task(pk: int, alert_interval: Union[float, None] = None) -> str:
     from alerts.models import Alert
 
-    try:
-        alert = Alert.objects.get(pk=pk)
-    except Alert.DoesNotExist:
-        return "alert not found"
+    alert = Alert.objects.get(pk=pk)
 
     if not alert.email_sent:
-        sleep(random.randint(1, 5))
+        sleep(random.randint(1, 15))
         alert.agent.send_outage_email()
         alert.email_sent = djangotime.now()
         alert.save(update_fields=["email_sent"])
@@ -55,7 +123,7 @@ def agent_outage_email_task(pk: int, alert_interval: Optional[float] = None) ->
             # send an email only if the last email sent is older than alert interval
             delta = djangotime.now() - dt.timedelta(days=alert_interval)
             if alert.email_sent < delta:
-                sleep(random.randint(1, 5))
+                sleep(random.randint(1, 10))
                 alert.agent.send_outage_email()
                 alert.email_sent = djangotime.now()
                 alert.save(update_fields=["email_sent"])
@@ -67,13 +135,8 @@ def agent_outage_email_task(pk: int, alert_interval: Optional[float] = None) ->
 def agent_recovery_email_task(pk: int) -> str:
     from alerts.models import Alert
 
-    sleep(random.randint(1, 5))
-
-    try:
-        alert = Alert.objects.get(pk=pk)
-    except Alert.DoesNotExist:
-        return "alert not found"
-
+    sleep(random.randint(1, 15))
+    alert = Alert.objects.get(pk=pk)
     alert.agent.send_recovery_email()
     alert.resolved_email_sent = djangotime.now()
     alert.save(update_fields=["resolved_email_sent"])
@@ -82,16 +145,13 @@ def agent_recovery_email_task(pk: int) -> str:
 
 
 @app.task
-def agent_outage_sms_task(pk: int, alert_interval: Optional[float] = None) -> str:
+def agent_outage_sms_task(pk: int, alert_interval: Union[float, None] = None) -> str:
     from alerts.models import Alert
 
-    try:
-        alert = Alert.objects.get(pk=pk)
-    except Alert.DoesNotExist:
-        return "alert not found"
+    alert = Alert.objects.get(pk=pk)
 
     if not alert.sms_sent:
-        sleep(random.randint(1, 3))
+        sleep(random.randint(1, 15))
         alert.agent.send_outage_sms()
         alert.sms_sent = djangotime.now()
         alert.save(update_fields=["sms_sent"])
@@ -100,7 +160,7 @@ def agent_outage_sms_task(pk: int, alert_interval: Optional[float] = None) -> st
             # send an sms only if the last sms sent is older than alert interval
             delta = djangotime.now() - dt.timedelta(days=alert_interval)
             if alert.sms_sent < delta:
-                sleep(random.randint(1, 3))
+                sleep(random.randint(1, 10))
                 alert.agent.send_outage_sms()
                 alert.sms_sent = djangotime.now()
                 alert.save(update_fields=["sms_sent"])
@@ -113,11 +173,7 @@ def agent_recovery_sms_task(pk: int) -> str:
     from alerts.models import Alert
 
     sleep(random.randint(1, 3))
-    try:
-        alert = Alert.objects.get(pk=pk)
-    except Alert.DoesNotExist:
-        return "alert not found"
-
+    alert = Alert.objects.get(pk=pk)
     alert.agent.send_recovery_sms()
     alert.resolved_sms_sent = djangotime.now()
     alert.save(update_fields=["resolved_sms_sent"])
@@ -141,7 +197,7 @@ def agent_outages_task() -> None:
     )
 
     for agent in agents:
-        if agent.status == AGENT_STATUS_OVERDUE:
+        if agent.status == "overdue":
             Alert.handle_alert_failure(agent)
 
 
@@ -153,7 +209,6 @@ def run_script_email_results_task(
     emails: list[str],
     args: list[str] = [],
     history_pk: int = 0,
-    run_as_user: bool = False,
 ):
     agent = Agent.objects.get(pk=agentpk)
     script = Script.objects.get(pk=scriptpk)
@@ -164,17 +219,16 @@ def run_script_email_results_task(
         timeout=nats_timeout,
         wait=True,
         history_pk=history_pk,
-        run_as_user=run_as_user,
     )
     if r == "timeout":
         DebugLog.error(
             agent=agent,
-            log_type=DebugLogType.SCRIPTING,
+            log_type="scripting",
             message=f"{agent.hostname}({agent.pk}) timed out running script.",
         )
         return
 
-    CORE = get_core_settings()
+    CORE = CoreSettings.objects.first()
     subject = f"{agent.hostname} {script.name} Results"
     exec_time = "{:.4f}".format(r["execution_time"])
     body = (
@@ -187,21 +241,25 @@ def run_script_email_results_task(
 
     msg = EmailMessage()
     msg["Subject"] = subject
-    msg["From"] = CORE.smtp_from_email
+    msg["From"] = CORE.smtp_from_email  # type:ignore
 
     if emails:
         msg["To"] = ", ".join(emails)
     else:
-        msg["To"] = ", ".join(CORE.email_alert_recipients)
+        msg["To"] = ", ".join(CORE.email_alert_recipients)  # type:ignore
 
     msg.set_content(body)
 
     try:
-        with smtplib.SMTP(CORE.smtp_host, CORE.smtp_port, timeout=20) as server:
-            if CORE.smtp_requires_auth:
+        with smtplib.SMTP(
+            CORE.smtp_host, CORE.smtp_port, timeout=20  # type:ignore
+        ) as server:  # type:ignore
+            if CORE.smtp_requires_auth:  # type:ignore
                 server.ehlo()
                 server.starttls()
-                server.login(CORE.smtp_host_user, CORE.smtp_host_password)
+                server.login(
+                    CORE.smtp_host_user, CORE.smtp_host_password  # type:ignore
+                )  # type:ignore
                 server.send_message(msg)
                 server.quit()
             else:
@@ -213,22 +271,18 @@ def run_script_email_results_task(
 
 @app.task
 def clear_faults_task(older_than_days: int) -> None:
-    from alerts.models import Alert
-
-    # https://github.com/amidaware/tacticalrmm/issues/484
+    # https://github.com/wh1te909/tacticalrmm/issues/484
     agents = Agent.objects.exclude(last_seen__isnull=True).filter(
         last_seen__lt=djangotime.now() - djangotime.timedelta(days=older_than_days)
     )
     for agent in agents:
-        for check in agent.get_checks_with_policies():
-            # reset check status
-            if check.check_result:
-                check.check_result.status = CheckStatus.PASSING
-                check.check_result.save(update_fields=["status"])
-            if check.alert.filter(agent=agent, resolved=False).exists():
-                alert = Alert.create_or_return_check_alert(check, agent=agent)
-                if alert:
-                    alert.resolve()
+        if agent.agentchecks.exists():
+            for check in agent.agentchecks.all():
+                # reset check status
+                check.status = "passing"
+                check.save(update_fields=["status"])
+                if check.alert.filter(resolved=False).exists():
+                    check.alert.get(resolved=False).resolve()
 
         # reset overdue alerts
         agent.overdue_email_alert = False
@@ -252,8 +306,3 @@ def prune_agent_history(older_than_days: int) -> str:
     ).delete()
 
     return "ok"
-
-
-@app.task
-def bulk_recover_agents_task() -> None:
-    call_command("bulk_restart_agents")

api/tacticalrmm/agents/tests/test_agent_installs.py

@@ -1,106 +0,0 @@
-from unittest.mock import patch
-
-from rest_framework.response import Response
-
-from tacticalrmm.test import TacticalTestCase
-
-
-class TestAgentInstalls(TacticalTestCase):
-    def setUp(self) -> None:
-        self.authenticate()
-        self.setup_coresettings()
-        self.setup_base_instance()
-
-    @patch("agents.utils.generate_linux_install")
-    @patch("knox.models.AuthToken.objects.create")
-    @patch("tacticalrmm.utils.generate_winagent_exe")
-    @patch("core.utils.token_is_valid")
-    @patch("agents.utils.get_agent_url")
-    def test_install_agent(
-        self,
-        mock_agent_url,
-        mock_token_valid,
-        mock_gen_win_exe,
-        mock_auth,
-        mock_linux_install,
-    ):
-        mock_agent_url.return_value = "https://example.com"
-        mock_token_valid.return_value = "", False
-        mock_gen_win_exe.return_value = Response("ok")
-        mock_auth.return_value = "", "token"
-        mock_linux_install.return_value = Response("ok")
-
-        url = "/agents/installer/"
-
-        # test windows dynamic exe
-        data = {
-            "installMethod": "exe",
-            "client": self.site2.client.pk,
-            "site": self.site2.pk,
-            "expires": 24,
-            "agenttype": "server",
-            "power": 0,
-            "rdp": 1,
-            "ping": 0,
-            "goarch": "amd64",
-            "api": "https://api.example.com",
-            "fileName": "rmm-client-site-server.exe",
-            "plat": "windows",
-        }
-
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 200)
-
-        mock_gen_win_exe.assert_called_with(
-            client=self.site2.client.pk,
-            site=self.site2.pk,
-            agent_type="server",
-            rdp=1,
-            ping=0,
-            power=0,
-            goarch="amd64",
-            token="token",
-            api="https://api.example.com",
-            file_name="rmm-client-site-server.exe",
-        )
-
-        # test linux no code sign
-        data["plat"] = "linux"
-        data["installMethod"] = "bash"
-        data["rdp"] = 0
-        data["agenttype"] = "workstation"
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 400)
-
-        # test linux
-        mock_token_valid.return_value = "token123", True
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 200)
-        mock_linux_install.assert_called_with(
-            client=str(self.site2.client.pk),
-            site=str(self.site2.pk),
-            agent_type="workstation",
-            arch="amd64",
-            token="token",
-            api="https://api.example.com",
-            download_url="https://example.com",
-        )
-
-        # test manual
-        data["rdp"] = 1
-        data["installMethod"] = "manual"
-        r = self.client.post(url, data, format="json")
-        self.assertIn("rdp", r.json()["cmd"])
-        self.assertNotIn("power", r.json()["cmd"])
-
-        data.update({"ping": 1, "power": 1})
-        r = self.client.post(url, data, format="json")
-        self.assertIn("power", r.json()["cmd"])
-        self.assertIn("ping", r.json()["cmd"])
-
-        # test powershell
-        data["installMethod"] = "powershell"
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 200)
-
-        self.check_not_authenticated("post", url)

api/tacticalrmm/agents/tests/test_agent_update.py

@@ -1,313 +0,0 @@
-from unittest.mock import patch
-
-from django.conf import settings
-from django.core.management import call_command
-from model_bakery import baker
-from packaging import version as pyver
-
-from agents.models import Agent
-from agents.tasks import auto_self_agent_update_task, send_agent_update_task
-from logs.models import PendingAction
-from tacticalrmm.constants import (
-    AGENT_DEFER,
-    AgentMonType,
-    AgentPlat,
-    GoArch,
-    PAAction,
-    PAStatus,
-)
-from tacticalrmm.test import TacticalTestCase
-
-
-class TestAgentUpdate(TacticalTestCase):
-    def setUp(self) -> None:
-        self.authenticate()
-        self.setup_coresettings()
-        self.setup_base_instance()
-
-    @patch("agents.management.commands.update_agents.send_agent_update_task.delay")
-    @patch("agents.management.commands.update_agents.token_is_valid")
-    @patch("agents.management.commands.update_agents.get_core_settings")
-    def test_update_agents_mgmt_command(self, mock_core, mock_token, mock_update):
-        mock_token.return_value = ("token123", True)
-
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site1,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version="2.0.3",
-            _quantity=6,
-        )
-
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site3,
-            monitoring_type=AgentMonType.WORKSTATION,
-            plat=AgentPlat.LINUX,
-            version="2.0.3",
-            _quantity=5,
-        )
-
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site2,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version=settings.LATEST_AGENT_VER,
-            _quantity=8,
-        )
-
-        mock_core.return_value.agent_auto_update = False
-        call_command("update_agents")
-        mock_update.assert_not_called()
-
-        mock_core.return_value.agent_auto_update = True
-        call_command("update_agents")
-
-        ids = list(
-            Agent.objects.defer(*AGENT_DEFER)
-            .exclude(version=settings.LATEST_AGENT_VER)
-            .values_list("agent_id", flat=True)
-        )
-
-        mock_update.assert_called_with(agent_ids=ids, token="token123", force=False)
-
-    @patch("agents.models.Agent.nats_cmd")
-    @patch("agents.models.get_agent_url")
-    def test_do_update(self, mock_agent_url, mock_nats_cmd):
-        mock_agent_url.return_value = "https://example.com/123"
-
-        # test noarch
-        agent_noarch = baker.make_recipe(
-            "agents.online_agent",
-            site=self.site1,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version="2.1.1",
-        )
-        r = agent_noarch.do_update(token="", force=True)
-        self.assertEqual(r, "noarch")
-
-        # test too old
-        agent_old = baker.make_recipe(
-            "agents.online_agent",
-            site=self.site2,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version="1.3.0",
-            goarch=GoArch.AMD64,
-        )
-        r = agent_old.do_update(token="", force=True)
-        self.assertEqual(r, "not supported")
-
-        win = baker.make_recipe(
-            "agents.online_agent",
-            site=self.site1,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version="2.1.1",
-            goarch=GoArch.AMD64,
-        )
-
-        lin = baker.make_recipe(
-            "agents.online_agent",
-            site=self.site3,
-            monitoring_type=AgentMonType.WORKSTATION,
-            plat=AgentPlat.LINUX,
-            version="2.1.1",
-            goarch=GoArch.ARM32,
-        )
-
-        # test windows agent update
-        r = win.do_update(token="", force=False)
-        self.assertEqual(r, "created")
-        mock_nats_cmd.assert_called_with(
-            {
-                "func": "agentupdate",
-                "payload": {
-                    "url": "https://example.com/123",
-                    "version": settings.LATEST_AGENT_VER,
-                    "inno": f"tacticalagent-v{settings.LATEST_AGENT_VER}-windows-amd64.exe",
-                },
-            },
-            wait=False,
-        )
-        action1 = PendingAction.objects.get(agent__agent_id=win.agent_id)
-        self.assertEqual(action1.action_type, PAAction.AGENT_UPDATE)
-        self.assertEqual(action1.status, PAStatus.PENDING)
-        self.assertEqual(action1.details["url"], "https://example.com/123")
-        self.assertEqual(
-            action1.details["inno"],
-            f"tacticalagent-v{settings.LATEST_AGENT_VER}-windows-amd64.exe",
-        )
-        self.assertEqual(action1.details["version"], settings.LATEST_AGENT_VER)
-
-        mock_nats_cmd.reset_mock()
-
-        # test linux agent update
-        r = lin.do_update(token="", force=False)
-        mock_nats_cmd.assert_called_with(
-            {
-                "func": "agentupdate",
-                "payload": {
-                    "url": "https://example.com/123",
-                    "version": settings.LATEST_AGENT_VER,
-                    "inno": f"tacticalagent-v{settings.LATEST_AGENT_VER}-linux-arm.exe",
-                },
-            },
-            wait=False,
-        )
-        action2 = PendingAction.objects.get(agent__agent_id=lin.agent_id)
-        self.assertEqual(action2.action_type, PAAction.AGENT_UPDATE)
-        self.assertEqual(action2.status, PAStatus.PENDING)
-        self.assertEqual(action2.details["url"], "https://example.com/123")
-        self.assertEqual(
-            action2.details["inno"],
-            f"tacticalagent-v{settings.LATEST_AGENT_VER}-linux-arm.exe",
-        )
-        self.assertEqual(action2.details["version"], settings.LATEST_AGENT_VER)
-
-        # check if old agent update pending actions are being deleted
-        # should only be 1 pending action at all times
-        pa_count = win.pendingactions.filter(
-            action_type=PAAction.AGENT_UPDATE, status=PAStatus.PENDING
-        ).count()
-        self.assertEqual(pa_count, 1)
-
-        for _ in range(4):
-            win.do_update(token="", force=False)
-
-        pa_count = win.pendingactions.filter(
-            action_type=PAAction.AGENT_UPDATE, status=PAStatus.PENDING
-        ).count()
-        self.assertEqual(pa_count, 1)
-
-    def test_auto_self_agent_update_task(self):
-        auto_self_agent_update_task()
-
-    @patch("agents.models.Agent.do_update")
-    def test_send_agent_update_task(self, mock_update):
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site2,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version="2.1.1",
-            goarch=GoArch.AMD64,
-            _quantity=6,
-        )
-        ids = list(
-            Agent.objects.defer(*AGENT_DEFER)
-            .exclude(version=settings.LATEST_AGENT_VER)
-            .values_list("agent_id", flat=True)
-        )
-        send_agent_update_task(agent_ids=ids, token="", force=False)
-        self.assertEqual(mock_update.call_count, 6)
-
-    @patch("agents.views.token_is_valid")
-    @patch("agents.tasks.send_agent_update_task.delay")
-    def test_update_agents(self, mock_update, mock_token):
-        mock_token.return_value = ("", False)
-        url = "/agents/update/"
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site2,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version="2.1.1",
-            goarch=GoArch.AMD64,
-            _quantity=7,
-        )
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site2,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-            version=settings.LATEST_AGENT_VER,
-            goarch=GoArch.AMD64,
-            _quantity=3,
-        )
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site2,
-            monitoring_type=AgentMonType.WORKSTATION,
-            plat=AgentPlat.LINUX,
-            version="2.0.1",
-            goarch=GoArch.ARM32,
-            _quantity=9,
-        )
-
-        agent_ids: list[str] = list(
-            Agent.objects.only("agent_id").values_list("agent_id", flat=True)
-        )
-
-        data = {"agent_ids": agent_ids}
-        expected: list[str] = [
-            i.agent_id
-            for i in Agent.objects.only("agent_id", "version")
-            if pyver.parse(i.version) < pyver.parse(settings.LATEST_AGENT_VER)
-        ]
-
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 200)
-
-        mock_update.assert_called_with(agent_ids=expected, token="", force=False)
-
-        self.check_not_authenticated("post", url)
-
-    @patch("agents.views.token_is_valid")
-    @patch("agents.tasks.send_agent_update_task.delay")
-    def test_agent_update_permissions(self, update_task, mock_token):
-        mock_token.return_value = ("", False)
-
-        agents = baker.make_recipe("agents.agent", _quantity=5)
-        other_agents = baker.make_recipe("agents.agent", _quantity=7)
-
-        url = f"/agents/update/"
-
-        data = {
-            "agent_ids": [agent.agent_id for agent in agents]
-            + [agent.agent_id for agent in other_agents]
-        }
-
-        # test superuser access
-        self.check_authorized_superuser("post", url, data)
-        update_task.assert_called_with(
-            agent_ids=data["agent_ids"], token="", force=False
-        )
-        update_task.reset_mock()
-
-        user = self.create_user_with_roles([])
-        self.client.force_authenticate(user=user)
-
-        self.check_not_authorized("post", url, data)
-        update_task.assert_not_called()
-
-        user.role.can_update_agents = True
-        user.role.save()
-
-        self.check_authorized("post", url, data)
-        update_task.assert_called_with(
-            agent_ids=data["agent_ids"], token="", force=False
-        )
-        update_task.reset_mock()
-
-        # limit to client
-        # user.role.can_view_clients.set([agents[0].client])
-        # self.check_authorized("post", url, data)
-        # update_task.assert_called_with(agent_ids=[agent.agent_id for agent in agents])
-        # update_task.reset_mock()
-
-        # add site
-        # user.role.can_view_sites.set([other_agents[0].site])
-        # self.check_authorized("post", url, data)
-        # update_task.assert_called_with(agent_ids=data["agent_ids"])
-        # update_task.reset_mock()
-
-        # remove client permissions
-        # user.role.can_view_clients.clear()
-        # self.check_authorized("post", url, data)
-        # update_task.assert_called_with(
-        #     agent_ids=[agent.agent_id for agent in other_agents]
-        # )

api/tacticalrmm/agents/tests/test_agent_utils.py

@@ -1,60 +0,0 @@
-from unittest.mock import patch, AsyncMock
-
-from django.conf import settings
-from rest_framework.response import Response
-
-from agents.utils import generate_linux_install, get_agent_url
-from tacticalrmm.test import TacticalTestCase
-
-
-class TestAgentUtils(TacticalTestCase):
-    def setUp(self) -> None:
-        self.authenticate()
-        self.setup_coresettings()
-        self.setup_base_instance()
-
-    def test_get_agent_url(self):
-        ver = settings.LATEST_AGENT_VER
-
-        # test without token
-        r = get_agent_url(goarch="amd64", plat="windows", token="")
-        expected = f"https://github.com/amidaware/rmmagent/releases/download/v{ver}/tacticalagent-v{ver}-windows-amd64.exe"
-        self.assertEqual(r, expected)
-
-        # test with token
-        r = get_agent_url(goarch="386", plat="linux", token="token123")
-        expected = f"https://{settings.AGENTS_URL}version={ver}&arch=386&token=token123&plat=linux&api=api.example.com"
-
-    @patch("agents.utils.get_mesh_device_id")
-    @patch("agents.utils.asyncio.run")
-    @patch("agents.utils.get_mesh_ws_url")
-    @patch("agents.utils.get_core_settings")
-    def test_generate_linux_install(
-        self, mock_core, mock_mesh, mock_async_run, mock_mesh_device_id
-    ):
-        mock_mesh_device_id.return_value = "meshdeviceid"
-        mock_core.return_value.mesh_site = "meshsite"
-        mock_async_run.return_value = "meshid"
-        mock_mesh.return_value = "meshws"
-        r = generate_linux_install(
-            client="1",
-            site="1",
-            agent_type="server",
-            arch="amd64",
-            token="token123",
-            api="api.example.com",
-            download_url="asdasd3423",
-        )
-
-        ret = r.getvalue().decode("utf-8")
-
-        self.assertIn(r"agentDL='asdasd3423'", ret)
-        self.assertIn(
-            r"meshDL='meshsite/meshagents?id=meshid&installflags=2&meshinstall=6'", ret
-        )
-        self.assertIn(r"apiURL='api.example.com'", ret)
-        self.assertIn(r"agentDL='asdasd3423'", ret)
-        self.assertIn(r"token='token123'", ret)
-        self.assertIn(r"clientID='1'", ret)
-        self.assertIn(r"siteID='1'", ret)
-        self.assertIn(r"agentType='server'", ret)

api/tacticalrmm/agents/tests/test_mgmt_commands.py

@@ -1,46 +0,0 @@
-from unittest.mock import call, patch
-
-from django.core.management import call_command
-from model_bakery import baker
-
-from tacticalrmm.constants import AgentMonType, AgentPlat
-from tacticalrmm.test import TacticalTestCase
-
-
-class TestBulkRestartAgents(TacticalTestCase):
-    def setUp(self) -> None:
-        self.authenticate()
-        self.setup_coresettings()
-        self.setup_base_instance()
-
-    @patch("core.management.commands.bulk_restart_agents.sleep")
-    @patch("agents.models.Agent.recover")
-    @patch("core.management.commands.bulk_restart_agents.get_mesh_ws_url")
-    def test_bulk_restart_agents_mgmt_cmd(
-        self, get_mesh_ws_url, recover, mock_sleep
-    ) -> None:
-        get_mesh_ws_url.return_value = "https://mesh.example.com/test"
-
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site1,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-        )
-
-        baker.make_recipe(
-            "agents.online_agent",
-            site=self.site3,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.LINUX,
-        )
-
-        calls = [
-            call("tacagent", "https://mesh.example.com/test", wait=False),
-            call("mesh", "", wait=False),
-        ]
-
-        call_command("bulk_restart_agents")
-
-        recover.assert_has_calls(calls)
-        mock_sleep.assert_called_with(10)

api/tacticalrmm/agents/tests/test_recovery.py

@@ -1,63 +0,0 @@
-from typing import TYPE_CHECKING
-from unittest.mock import patch
-
-from model_bakery import baker
-
-from tacticalrmm.constants import AgentMonType, AgentPlat
-from tacticalrmm.test import TacticalTestCase
-
-if TYPE_CHECKING:
-    from clients.models import Client, Site
-
-
-class TestRecovery(TacticalTestCase):
-    def setUp(self) -> None:
-        self.authenticate()
-        self.setup_coresettings()
-        self.client1: "Client" = baker.make("clients.Client")
-        self.site1: "Site" = baker.make("clients.Site", client=self.client1)
-
-    @patch("agents.models.Agent.recover")
-    @patch("agents.views.get_mesh_ws_url")
-    def test_recover(self, get_mesh_ws_url, recover) -> None:
-        get_mesh_ws_url.return_value = "https://mesh.example.com"
-
-        agent = baker.make_recipe(
-            "agents.online_agent",
-            site=self.site1,
-            monitoring_type=AgentMonType.SERVER,
-            plat=AgentPlat.WINDOWS,
-        )
-
-        url = f"/agents/{agent.agent_id}/recover/"
-
-        # test successfull tacticalagent recovery
-        data = {"mode": "tacagent"}
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 200)
-        recover.assert_called_with("tacagent", "https://mesh.example.com", wait=False)
-        get_mesh_ws_url.assert_called_once()
-
-        # reset mocks
-        recover.reset_mock()
-        get_mesh_ws_url.reset_mock()
-
-        # test successfull mesh agent recovery
-        data = {"mode": "mesh"}
-        recover.return_value = ("ok", False)
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 200)
-        get_mesh_ws_url.assert_not_called()
-        recover.assert_called_with("mesh", "")
-
-        # reset mocks
-        recover.reset_mock()
-        get_mesh_ws_url.reset_mock()
-
-        # test failed mesh agent recovery
-        data = {"mode": "mesh"}
-        recover.return_value = ("Unable to contact the agent", True)
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 400)
-
-        self.check_not_authenticated("post", url)

api/tacticalrmm/agents/urls.py

@@ -1,10 +1,9 @@
 from django.urls import path
 
-from autotasks.views import GetAddAutoTasks
-from checks.views import GetAddChecks
-from logs.views import PendingActions
-
 from . import views
+from checks.views import GetAddChecks
+from autotasks.views import GetAddAutoTasks
+from logs.views import PendingActions
 
 urlpatterns = [
     # agent views
@@ -41,5 +40,5 @@ urlpatterns = [
     path("versions/", views.get_agent_versions),
     path("update/", views.update_agents),
     path("installer/", views.install_agent),
-    path("bulkrecovery/", views.bulk_agent_recovery),
+    path("<str:arch>/getmeshexe/", views.get_mesh_exe),
 ]

api/tacticalrmm/agents/utils.py

@@ -1,80 +1,40 @@
-import asyncio
-import tempfile
+import random
 import urllib.parse
-from pathlib import Path
+import requests
 
 from django.conf import settings
-from django.http import FileResponse
-
-from core.utils import get_core_settings, get_mesh_device_id, get_mesh_ws_url
-from tacticalrmm.constants import MeshAgentIdent
+from core.models import CodeSignToken
 
 
-def get_agent_url(*, goarch: str, plat: str, token: str = "") -> str:
-    ver = settings.LATEST_AGENT_VER
-    if token:
-        params = {
-            "version": ver,
-            "arch": goarch,
-            "token": token,
-            "plat": plat,
-            "api": settings.ALLOWED_HOSTS[0],
-        }
-        return settings.AGENTS_URL + urllib.parse.urlencode(params)
+def get_exegen_url() -> str:
+    urls: list[str] = settings.EXE_GEN_URLS
+    for url in urls:
+        try:
+            r = requests.get(url, timeout=10)
+        except:
+            continue
 
-    return f"https://github.com/amidaware/rmmagent/releases/download/v{ver}/tacticalagent-v{ver}-{plat}-{goarch}.exe"
+        if r.status_code == 200:
+            return url
+
+    return random.choice(urls)
 
 
-def generate_linux_install(
-    client: str,
-    site: str,
-    agent_type: str,
-    arch: str,
-    token: str,
-    api: str,
-    download_url: str,
-) -> FileResponse:
+def get_winagent_url(arch: str) -> str:
 
-    match arch:
-        case "amd64":
-            arch_id = MeshAgentIdent.LINUX64
-        case "386":
-            arch_id = MeshAgentIdent.LINUX32
-        case "arm64":
-            arch_id = MeshAgentIdent.LINUX_ARM_64
-        case "arm":
-            arch_id = MeshAgentIdent.LINUX_ARM_HF
-        case _:
-            arch_id = "not_found"
+    dl_url = settings.DL_32 if arch == "32" else settings.DL_64
 
-    core = get_core_settings()
+    try:
+        t: CodeSignToken = CodeSignToken.objects.first()  # type: ignore
+        if t.is_valid:
+            base_url = get_exegen_url() + "/api/v1/winagents/?"
+            params = {
+                "version": settings.LATEST_AGENT_VER,
+                "arch": arch,
+                "token": t.token,
+            }
+            dl_url = base_url + urllib.parse.urlencode(params)
+    except:
+        pass
 
-    uri = get_mesh_ws_url()
-    mesh_id = asyncio.run(get_mesh_device_id(uri, core.mesh_device_group))
-    mesh_dl = (
-        f"{core.mesh_site}/meshagents?id={mesh_id}&installflags=2&meshinstall={arch_id}"
-    )
-
-    text = Path(settings.LINUX_AGENT_SCRIPT).read_text()
-
-    replace = {
-        "agentDLChange": download_url,
-        "meshDLChange": mesh_dl,
-        "clientIDChange": client,
-        "siteIDChange": site,
-        "agentTypeChange": agent_type,
-        "tokenChange": token,
-        "apiURLChange": api,
-    }
-
-    for i, j in replace.items():
-        text = text.replace(i, j)
-
-    with tempfile.NamedTemporaryFile() as fp:
-        with open(fp.name, "w") as f:
-            f.write(text)
-            f.write("\n")
-
-        return FileResponse(
-            open(fp.name, "rb"), as_attachment=True, filename="linux_agent_install.sh"
-        )
+    return dl_url

api/tacticalrmm/agents/views.py

@@ -4,108 +4,74 @@ import os
 import random
 import string
 import time
-from pathlib import Path
 
 from django.conf import settings
-from django.db.models import Count, Exists, OuterRef, Prefetch, Q
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
-from django.utils import timezone as djangotime
-from meshctrl.utils import get_login_token
+from django.db.models import Q
 from packaging import version as pyver
-from rest_framework import serializers
 from rest_framework.decorators import api_view, permission_classes
-from rest_framework.exceptions import PermissionDenied
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.views import APIView
+from rest_framework.exceptions import PermissionDenied
 
-from core.utils import (
-    get_core_settings,
-    get_mesh_ws_url,
-    remove_mesh_agent,
-    token_is_valid,
-)
+from core.models import CoreSettings
 from logs.models import AuditLog, DebugLog, PendingAction
 from scripts.models import Script
 from scripts.tasks import handle_bulk_command_task, handle_bulk_script_task
-from tacticalrmm.constants import (
+from tacticalrmm.utils import (
+    get_default_timezone,
+    notify_error,
+    reload_nats,
     AGENT_DEFER,
-    AGENT_STATUS_OFFLINE,
-    AGENT_STATUS_ONLINE,
-    AGENT_TABLE_DEFER,
-    AgentHistoryType,
-    AgentMonType,
-    AgentPlat,
-    CustomFieldModel,
-    DebugLogType,
-    EvtLogNames,
-    PAAction,
-    PAStatus,
 )
-from tacticalrmm.helpers import date_is_in_past, notify_error
+from winupdate.serializers import WinUpdatePolicySerializer
+from winupdate.tasks import bulk_check_for_updates_task, bulk_install_updates_task
 from tacticalrmm.permissions import (
     _has_perm_on_agent,
     _has_perm_on_client,
     _has_perm_on_site,
 )
-from tacticalrmm.utils import get_default_timezone, reload_nats
-from winupdate.models import WinUpdate
-from winupdate.serializers import WinUpdatePolicySerializer
-from winupdate.tasks import bulk_check_for_updates_task, bulk_install_updates_task
 
-from .models import Agent, AgentCustomField, AgentHistory, Note
+from .models import Agent, AgentCustomField, Note, RecoveryAction, AgentHistory
 from .permissions import (
     AgentHistoryPerms,
-    AgentNotesPerms,
     AgentPerms,
     EvtLogPerms,
     InstallAgentPerms,
+    RecoverAgentPerms,
+    AgentNotesPerms,
     ManageProcPerms,
     MeshPerms,
-    PingAgentPerms,
     RebootAgentPerms,
-    RecoverAgentPerms,
     RunBulkPerms,
     RunScriptPerms,
     SendCMDPerms,
+    PingAgentPerms,
     UpdateAgentPerms,
 )
 from .serializers import (
     AgentCustomFieldSerializer,
     AgentHistorySerializer,
     AgentHostnameSerializer,
-    AgentNoteSerializer,
     AgentSerializer,
     AgentTableSerializer,
+    AgentNoteSerializer,
 )
-from .tasks import (
-    bulk_recover_agents_task,
-    run_script_email_results_task,
-    send_agent_update_task,
-)
+from .tasks import run_script_email_results_task, send_agent_update_task
 
 
 class GetAgents(APIView):
     permission_classes = [IsAuthenticated, AgentPerms]
 
     def get(self, request):
-        from checks.models import Check, CheckResult
-
-        monitoring_type_filter = Q()
-        client_site_filter = Q()
-
-        monitoring_type = request.query_params.get("monitoring_type", None)
-        if monitoring_type:
-            if monitoring_type in AgentMonType.values:
-                monitoring_type_filter = Q(monitoring_type=monitoring_type)
-            else:
-                return notify_error("monitoring type does not exist")
-
         if "site" in request.query_params.keys():
-            client_site_filter = Q(site_id=request.query_params["site"])
+            filter = Q(site_id=request.query_params["site"])
         elif "client" in request.query_params.keys():
-            client_site_filter = Q(site__client_id=request.query_params["client"])
+            filter = Q(site__client_id=request.query_params["client"])
+        else:
+            filter = Q()
 
         # by default detail=true
         if (
@@ -113,53 +79,24 @@ class GetAgents(APIView):
             or "detail" in request.query_params.keys()
             and request.query_params["detail"] == "true"
         ):
+
             agents = (
                 Agent.objects.filter_by_role(request.user)  # type: ignore
-                .filter(monitoring_type_filter)
-                .filter(client_site_filter)
-                .defer(*AGENT_TABLE_DEFER)
-                .select_related(
-                    "site__server_policy",
-                    "site__workstation_policy",
-                    "site__client__server_policy",
-                    "site__client__workstation_policy",
-                    "policy",
-                    "alert_template",
-                )
-                .prefetch_related(
-                    Prefetch(
-                        "agentchecks",
-                        queryset=Check.objects.select_related("script"),
-                    ),
-                    Prefetch(
-                        "checkresults",
-                        queryset=CheckResult.objects.select_related("assigned_check"),
-                    ),
-                )
-                .annotate(
-                    pending_actions_count=Count(
-                        "pendingactions",
-                        filter=Q(pendingactions__status=PAStatus.PENDING),
-                    )
-                )
-                .annotate(
-                    has_patches_pending=Exists(
-                        WinUpdate.objects.filter(
-                            agent_id=OuterRef("pk"), action="approve", installed=False
-                        )
-                    )
-                )
+                .select_related("site", "policy", "alert_template")
+                .prefetch_related("agentchecks")
+                .filter(filter)
+                .defer(*AGENT_DEFER)
             )
-            serializer = AgentTableSerializer(agents, many=True)
+            ctx = {"default_tz": get_default_timezone()}
+            serializer = AgentTableSerializer(agents, many=True, context=ctx)
 
         # if detail=false
         else:
             agents = (
                 Agent.objects.filter_by_role(request.user)  # type: ignore
-                .defer(*AGENT_DEFER)
-                .select_related("site__client")
-                .filter(monitoring_type_filter)
-                .filter(client_site_filter)
+                .select_related("site")
+                .filter(filter)
+                .only("agent_id", "hostname", "site")
             )
             serializer = AgentHostnameSerializer(agents, many=True)
 
@@ -169,25 +106,6 @@ class GetAgents(APIView):
 class GetUpdateDeleteAgent(APIView):
     permission_classes = [IsAuthenticated, AgentPerms]
 
-    class InputSerializer(serializers.ModelSerializer):
-        class Meta:
-            model = Agent
-            fields = [
-                "maintenance_mode",  # TODO separate this
-                "policy",  # TODO separate this
-                "block_policy_inheritance",  # TODO separate this
-                "monitoring_type",
-                "description",
-                "overdue_email_alert",
-                "overdue_text_alert",
-                "overdue_dashboard_alert",
-                "offline_time",
-                "overdue_time",
-                "check_interval",
-                "time_zone",
-                "site",
-            ]
-
     # get agent details
     def get(self, request, agent_id):
         agent = get_object_or_404(Agent, agent_id=agent_id)
@@ -197,9 +115,9 @@ class GetUpdateDeleteAgent(APIView):
     def put(self, request, agent_id):
         agent = get_object_or_404(Agent, agent_id=agent_id)
 
-        s = self.InputSerializer(instance=agent, data=request.data, partial=True)
-        s.is_valid(raise_exception=True)
-        s.save()
+        a_serializer = AgentSerializer(instance=agent, data=request.data, partial=True)
+        a_serializer.is_valid(raise_exception=True)
+        a_serializer.save()
 
         if "winupdatepolicy" in request.data.keys():
             policy = agent.winupdatepolicy.get()  # type: ignore
@@ -214,13 +132,13 @@ class GetUpdateDeleteAgent(APIView):
             for field in request.data["custom_fields"]:
 
                 custom_field = field
-                custom_field["agent"] = agent.pk
+                custom_field["agent"] = agent.id  # type: ignore
 
                 if AgentCustomField.objects.filter(
-                    field=field["field"], agent=agent.pk
+                    field=field["field"], agent=agent.id  # type: ignore
                 ):
                     value = AgentCustomField.objects.get(
-                        field=field["field"], agent=agent.pk
+                        field=field["field"], agent=agent.id  # type: ignore
                     )
                     serializer = AgentCustomFieldSerializer(
                         instance=value, data=custom_field
@@ -237,26 +155,10 @@ class GetUpdateDeleteAgent(APIView):
     # uninstall agent
     def delete(self, request, agent_id):
         agent = get_object_or_404(Agent, agent_id=agent_id)
-
-        code = "foo"  # stub for windows
-        if agent.plat == AgentPlat.LINUX:
-            code = Path(settings.LINUX_AGENT_SCRIPT).read_text()
-        elif agent.plat == AgentPlat.DARWIN:
-            code = Path(settings.MAC_UNINSTALL).read_text()
-
-        asyncio.run(agent.nats_cmd({"func": "uninstall", "code": code}, wait=False))
+        asyncio.run(agent.nats_cmd({"func": "uninstall"}, wait=False))
         name = agent.hostname
-        mesh_id = agent.mesh_node_id
         agent.delete()
         reload_nats()
-        try:
-            uri = get_mesh_ws_url()
-            asyncio.run(remove_mesh_agent(uri, mesh_id))
-        except Exception as e:
-            DebugLog.error(
-                message=f"Unable to remove agent {name} from meshcentral database: {e}",
-                log_type=DebugLogType.AGENT_ISSUES,
-            )
         return Response(f"{name} will now be uninstalled.")
 
 
@@ -272,7 +174,7 @@ class AgentProcesses(APIView):
 
         agent = get_object_or_404(Agent, agent_id=agent_id)
         r = asyncio.run(agent.nats_cmd(data={"func": "procs"}, timeout=5))
-        if r in ("timeout", "natsdown"):
+        if r == "timeout" or r == "natsdown":
             return notify_error("Unable to contact the agent")
         return Response(r)
 
@@ -283,7 +185,7 @@ class AgentProcesses(APIView):
             agent.nats_cmd({"func": "killproc", "procpid": int(pid)}, timeout=15)
         )
 
-        if r in ("timeout", "natsdown"):
+        if r == "timeout" or r == "natsdown":
             return notify_error("Unable to contact the agent")
         elif r != "ok":
             return notify_error(r)
@@ -297,19 +199,19 @@ class AgentMeshCentral(APIView):
     # get mesh urls
     def get(self, request, agent_id):
         agent = get_object_or_404(Agent, agent_id=agent_id)
-        core = get_core_settings()
+        core = CoreSettings.objects.first()
 
-        if not core.mesh_disable_auto_login:
-            token = get_login_token(
-                key=core.mesh_token, user=f"user//{core.mesh_username}"
-            )
-            token_param = f"login={token}&"
-        else:
-            token_param = ""
+        token = agent.get_login_token(
+            key=core.mesh_token,
+            user=f"user//{core.mesh_username.lower()}",  # type:ignore
+        )
 
-        control = f"{core.mesh_site}/?{token_param}gotonode={agent.mesh_node_id}&viewmode=11&hide=31"
-        terminal = f"{core.mesh_site}/?{token_param}gotonode={agent.mesh_node_id}&viewmode=12&hide=31"
-        file = f"{core.mesh_site}/?{token_param}gotonode={agent.mesh_node_id}&viewmode=13&hide=31"
+        if token == "err":
+            return notify_error("Invalid mesh token")
+
+        control = f"{core.mesh_site}/?login={token}&gotonode={agent.mesh_node_id}&viewmode=11&hide=31"  # type:ignore
+        terminal = f"{core.mesh_site}/?login={token}&gotonode={agent.mesh_node_id}&viewmode=12&hide=31"  # type:ignore
+        file = f"{core.mesh_site}/?login={token}&gotonode={agent.mesh_node_id}&viewmode=13&hide=31"  # type:ignore
 
         AuditLog.audit_mesh_session(
             username=request.user.username,
@@ -343,9 +245,9 @@ class AgentMeshCentral(APIView):
 @permission_classes([IsAuthenticated, AgentPerms])
 def get_agent_versions(request):
     agents = (
-        Agent.objects.defer(*AGENT_DEFER)
-        .filter_by_role(request.user)  # type: ignore
-        .select_related("site__client")
+        Agent.objects.filter_by_role(request.user)
+        .prefetch_related("site")
+        .only("pk", "hostname")
     )
     return Response(
         {
@@ -359,7 +261,7 @@ def get_agent_versions(request):
 @permission_classes([IsAuthenticated, UpdateAgentPerms])
 def update_agents(request):
     q = (
-        Agent.objects.filter_by_role(request.user)  # type: ignore
+        Agent.objects.filter_by_role(request.user)
         .filter(agent_id__in=request.data["agent_ids"])
         .only("agent_id", "version")
     )
@@ -368,9 +270,7 @@ def update_agents(request):
         for i in q
         if pyver.parse(i.version) < pyver.parse(settings.LATEST_AGENT_VER)
     ]
-
-    token, _ = token_is_valid()
-    send_agent_update_task.delay(agent_ids=agent_ids, token=token, force=False)
+    send_agent_update_task.delay(agent_ids=agent_ids)
     return Response("ok")
 
 
@@ -378,18 +278,18 @@ def update_agents(request):
 @permission_classes([IsAuthenticated, PingAgentPerms])
 def ping(request, agent_id):
     agent = get_object_or_404(Agent, agent_id=agent_id)
-    status = AGENT_STATUS_OFFLINE
+    status = "offline"
     attempts = 0
     while 1:
         r = asyncio.run(agent.nats_cmd({"func": "ping"}, timeout=2))
         if r == "pong":
-            status = AGENT_STATUS_ONLINE
+            status = "online"
             break
         else:
             attempts += 1
-            time.sleep(0.5)
+            time.sleep(1)
 
-        if attempts >= 3:
+        if attempts >= 5:
             break
 
     return Response({"name": agent.hostname, "status": status})
@@ -404,7 +304,7 @@ def get_event_log(request, agent_id, logtype, days):
         return demo_get_eventlog()
 
     agent = get_object_or_404(Agent, agent_id=agent_id)
-    timeout = 180 if logtype == EvtLogNames.SECURITY else 30
+    timeout = 180 if logtype == "Security" else 30
 
     data = {
         "func": "eventlog",
@@ -415,7 +315,7 @@ def get_event_log(request, agent_id, logtype, days):
         },
     }
     r = asyncio.run(agent.nats_cmd(data, timeout=timeout + 2))
-    if r in ("timeout", "natsdown"):
+    if r == "timeout" or r == "natsdown":
         return notify_error("Unable to contact the agent")
 
     return Response(r)
@@ -426,24 +326,18 @@ def get_event_log(request, agent_id, logtype, days):
 def send_raw_cmd(request, agent_id):
     agent = get_object_or_404(Agent, agent_id=agent_id)
     timeout = int(request.data["timeout"])
-    if request.data["shell"] == "custom" and request.data["custom_shell"]:
-        shell = request.data["custom_shell"]
-    else:
-        shell = request.data["shell"]
-
     data = {
         "func": "rawcmd",
         "timeout": timeout,
         "payload": {
             "command": request.data["cmd"],
-            "shell": shell,
+            "shell": request.data["shell"],
         },
-        "run_as_user": request.data["run_as_user"],
     }
 
     hist = AgentHistory.objects.create(
         agent=agent,
-        type=AgentHistoryType.CMD_RUN,
+        type="cmd_run",
         command=request.data["cmd"],
         username=request.user.username[:50],
     )
@@ -458,7 +352,7 @@ def send_raw_cmd(request, agent_id):
         username=request.user.username,
         agent=agent,
         cmd=request.data["cmd"],
-        shell=shell,
+        shell=request.data["shell"],
         debug_info={"ip": request._client_ip},
     )
 
@@ -479,43 +373,28 @@ class Reboot(APIView):
     # reboot later
     def patch(self, request, agent_id):
         agent = get_object_or_404(Agent, agent_id=agent_id)
-        if agent.is_posix:
-            return notify_error(f"Not currently implemented for {agent.plat}")
 
         try:
-            obj = dt.datetime.strptime(request.data["datetime"], "%Y-%m-%dT%H:%M")
+            obj = dt.datetime.strptime(request.data["datetime"], "%Y-%m-%d %H:%M")
         except Exception:
             return notify_error("Invalid date")
 
-        if date_is_in_past(datetime_obj=obj, agent_tz=agent.timezone):
-            return notify_error("Date cannot be set in the past")
-
         task_name = "TacticalRMM_SchedReboot_" + "".join(
             random.choice(string.ascii_letters) for _ in range(10)
         )
 
-        expire_date = obj + djangotime.timedelta(minutes=5)
-
         nats_data = {
             "func": "schedtask",
             "schedtaskpayload": {
                 "type": "schedreboot",
-                "enabled": True,
-                "delete_expired_task_after": True,
-                "start_when_available": False,
-                "multiple_instances": 2,
-                "trigger": "runonce",
+                "deleteafter": True,
+                "trigger": "once",
                 "name": task_name,
-                "start_year": int(dt.datetime.strftime(obj, "%Y")),
-                "start_month": int(dt.datetime.strftime(obj, "%-m")),
-                "start_day": int(dt.datetime.strftime(obj, "%-d")),
-                "start_hour": int(dt.datetime.strftime(obj, "%-H")),
-                "start_min": int(dt.datetime.strftime(obj, "%-M")),
-                "expire_year": int(expire_date.strftime("%Y")),
-                "expire_month": int(expire_date.strftime("%-m")),
-                "expire_day": int(expire_date.strftime("%-d")),
-                "expire_hour": int(expire_date.strftime("%-H")),
-                "expire_min": int(expire_date.strftime("%-M")),
+                "year": int(dt.datetime.strftime(obj, "%Y")),
+                "month": dt.datetime.strftime(obj, "%B"),
+                "day": int(dt.datetime.strftime(obj, "%d")),
+                "hour": int(dt.datetime.strftime(obj, "%H")),
+                "min": int(dt.datetime.strftime(obj, "%M")),
             },
         }
 
@@ -525,7 +404,7 @@ class Reboot(APIView):
 
         details = {"taskname": task_name, "time": str(obj)}
         PendingAction.objects.create(
-            agent=agent, action_type=PAAction.SCHED_REBOOT, details=details
+            agent=agent, action_type="schedreboot", details=details
         )
         nice_time = dt.datetime.strftime(obj, "%B %d, %Y at %I:%M %p")
         return Response(
@@ -537,32 +416,38 @@ class Reboot(APIView):
 @permission_classes([IsAuthenticated, InstallAgentPerms])
 def install_agent(request):
     from knox.models import AuthToken
-
     from accounts.models import User
-    from agents.utils import get_agent_url
-    from core.utils import token_is_valid
+
+    from agents.utils import get_winagent_url
 
     client_id = request.data["client"]
     site_id = request.data["site"]
     version = settings.LATEST_AGENT_VER
-    goarch = request.data["goarch"]
-    plat = request.data["plat"]
+    arch = request.data["arch"]
 
     if not _has_perm_on_site(request.user, site_id):
         raise PermissionDenied()
 
-    codesign_token, is_valid = token_is_valid()
-
-    if request.data["installMethod"] in {"bash", "mac"} and not is_valid:
+    # response type is blob so we have to use
+    # status codes and render error message on the frontend
+    if arch == "64" and not os.path.exists(
+        os.path.join(settings.EXE_DIR, "meshagent.exe")
+    ):
         return notify_error(
-            "Missing code signing token, or token is no longer valid. Please read the docs for more info."
+            "Missing 64 bit meshagent.exe. Upload it from Settings > Global Settings > MeshCentral"
         )
 
-    inno = f"tacticalagent-v{version}-{plat}-{goarch}"
-    if plat == AgentPlat.WINDOWS:
-        inno += ".exe"
+    if arch == "32" and not os.path.exists(
+        os.path.join(settings.EXE_DIR, "meshagent-x86.exe")
+    ):
+        return notify_error(
+            "Missing 32 bit meshagent.exe. Upload it from Settings > Global Settings > MeshCentral"
+        )
 
-    download_url = get_agent_url(goarch=goarch, plat=plat, token=codesign_token)
+    inno = (
+        f"winagent-v{version}.exe" if arch == "64" else f"winagent-v{version}-x86.exe"
+    )
+    download_url = get_winagent_url(arch)
 
     installer_user = User.objects.filter(is_installer_user=True).first()
 
@@ -570,21 +455,6 @@ def install_agent(request):
         user=installer_user, expiry=dt.timedelta(hours=request.data["expires"])
     )
 
-    install_flags = [
-        "-m",
-        "install",
-        "--api",
-        request.data["api"],
-        "--client-id",
-        client_id,
-        "--site-id",
-        site_id,
-        "--agent-type",
-        request.data["agenttype"],
-        "--auth",
-        token,
-    ]
-
     if request.data["installMethod"] == "exe":
         from tacticalrmm.utils import generate_winagent_exe
 
@@ -595,65 +465,58 @@ def install_agent(request):
             rdp=request.data["rdp"],
             ping=request.data["ping"],
             power=request.data["power"],
-            goarch=goarch,
+            arch=arch,
             token=token,
             api=request.data["api"],
             file_name=request.data["fileName"],
         )
 
-    elif request.data["installMethod"] == "bash":
+    elif request.data["installMethod"] == "manual":
+        cmd = [
+            inno,
+            "/VERYSILENT",
+            "/SUPPRESSMSGBOXES",
+            "&&",
+            "ping",
+            "127.0.0.1",
+            "-n",
+            "5",
+            "&&",
+            r'"C:\Program Files\TacticalAgent\tacticalrmm.exe"',
+            "-m",
+            "install",
+            "--api",
+            request.data["api"],
+            "--client-id",
+            client_id,
+            "--site-id",
+            site_id,
+            "--agent-type",
+            request.data["agenttype"],
+            "--auth",
+            token,
+        ]
 
-        from agents.utils import generate_linux_install
+        if int(request.data["rdp"]):
+            cmd.append("--rdp")
+        if int(request.data["ping"]):
+            cmd.append("--ping")
+        if int(request.data["power"]):
+            cmd.append("--power")
 
-        return generate_linux_install(
-            client=str(client_id),
-            site=str(site_id),
-            agent_type=request.data["agenttype"],
-            arch=goarch,
-            token=token,
-            api=request.data["api"],
-            download_url=download_url,
-        )
-
-    elif request.data["installMethod"] in {"manual", "mac"}:
-        resp = {}
-        if request.data["installMethod"] == "manual":
-            cmd = [
-                inno,
-                "/VERYSILENT",
-                "/SUPPRESSMSGBOXES",
-                "&&",
-                "ping",
-                "127.0.0.1",
-                "-n",
-                "5",
-                "&&",
-                r'"C:\Program Files\TacticalAgent\tacticalrmm.exe"',
-            ] + install_flags
-
-            if int(request.data["rdp"]):
-                cmd.append("--rdp")
-            if int(request.data["ping"]):
-                cmd.append("--ping")
-            if int(request.data["power"]):
-                cmd.append("--power")
-
-            resp["cmd"] = " ".join(str(i) for i in cmd)
-        else:
-            install_flags.insert(0, f"sudo ./{inno}")
-            cmd = install_flags.copy()
-            dl = f"curl -L -o {inno} '{download_url}'"
-            resp["cmd"] = (
-                dl + f" && chmod +x {inno} && " + " ".join(str(i) for i in cmd)
-            )
-
-        resp["url"] = download_url
+        resp = {
+            "cmd": " ".join(str(i) for i in cmd),
+            "url": download_url,
+        }
 
         return Response(resp)
 
     elif request.data["installMethod"] == "powershell":
 
-        text = Path(settings.BASE_DIR / "core" / "installer.ps1").read_text()
+        ps = os.path.join(settings.BASE_DIR, "core/installer.ps1")
+
+        with open(ps, "r") as f:
+            text = f.read()
 
         replace_dict = {
             "innosetupchange": inno,
@@ -680,7 +543,8 @@ def install_agent(request):
             except Exception as e:
                 DebugLog.error(message=str(e))
 
-        Path(ps1).write_text(text)
+        with open(ps1, "w") as f:
+            f.write(text)
 
         if settings.DEBUG:
             with open(ps1, "r") as f:
@@ -696,23 +560,40 @@ def install_agent(request):
 
 @api_view(["POST"])
 @permission_classes([IsAuthenticated, RecoverAgentPerms])
-def recover(request, agent_id: str) -> Response:
-    agent: Agent = get_object_or_404(
-        Agent.objects.defer(*AGENT_DEFER), agent_id=agent_id
-    )
+def recover(request, agent_id):
+    agent = get_object_or_404(Agent, agent_id=agent_id)
     mode = request.data["mode"]
 
+    # attempt a realtime recovery, otherwise fall back to old recovery method
+    if mode == "tacagent" or mode == "mesh":
+        data = {"func": "recover", "payload": {"mode": mode}}
+        r = asyncio.run(agent.nats_cmd(data, timeout=10))
+        if r == "ok":
+            return Response("Successfully completed recovery")
+
+    if agent.recoveryactions.filter(last_run=None).exists():  # type: ignore
+        return notify_error(
+            "A recovery action is currently pending. Please wait for the next agent check-in."
+        )
+
+    if mode == "command" and not request.data["cmd"]:
+        return notify_error("Command is required")
+
+    # if we've made it this far and realtime recovery didn't work,
+    # tacagent service is the fallback recovery so we obv can't use that to recover itself if it's down
     if mode == "tacagent":
-        uri = get_mesh_ws_url()
-        agent.recover(mode, uri, wait=False)
-        return Response("Recovery will be attempted shortly")
+        return notify_error(
+            "Requires RPC service to be functional. Please recover that first"
+        )
 
-    elif mode == "mesh":
-        r, err = agent.recover(mode, "")
-        if err:
-            return notify_error(f"Unable to complete recovery: {r}")
+    # we should only get here if all other methods fail
+    RecoveryAction(
+        agent=agent,
+        mode=mode,
+        command=request.data["cmd"] if mode == "command" else None,
+    ).save()
 
-    return Response("Successfully completed recovery")
+    return Response("Recovery will be attempted on the agent's next check-in")
 
 
 @api_view(["POST"])
@@ -722,7 +603,6 @@ def run_script(request, agent_id):
     script = get_object_or_404(Script, pk=request.data["script"])
     output = request.data["output"]
     args = request.data["args"]
-    run_as_user: bool = request.data["run_as_user"]
     req_timeout = int(request.data["timeout"]) + 3
 
     AuditLog.audit_script_run(
@@ -734,7 +614,7 @@ def run_script(request, agent_id):
 
     hist = AgentHistory.objects.create(
         agent=agent,
-        type=AgentHistoryType.SCRIPT_RUN,
+        type="script_run",
         script=script,
         username=request.user.username[:50],
     )
@@ -747,7 +627,6 @@ def run_script(request, agent_id):
             timeout=req_timeout,
             wait=True,
             history_pk=history_pk,
-            run_as_user=run_as_user,
         )
         return Response(r)
 
@@ -761,7 +640,6 @@ def run_script(request, agent_id):
             nats_timeout=req_timeout,
             emails=emails,
             args=args,
-            run_as_user=run_as_user,
         )
     elif output == "collector":
         from core.models import CustomField
@@ -772,16 +650,15 @@ def run_script(request, agent_id):
             timeout=req_timeout,
             wait=True,
             history_pk=history_pk,
-            run_as_user=run_as_user,
         )
 
         custom_field = CustomField.objects.get(pk=request.data["custom_field"])
 
-        if custom_field.model == CustomFieldModel.AGENT:
+        if custom_field.model == "agent":
             field = custom_field.get_or_create_field_value(agent)
-        elif custom_field.model == CustomFieldModel.CLIENT:
+        elif custom_field.model == "client":
             field = custom_field.get_or_create_field_value(agent.client)
-        elif custom_field.model == CustomFieldModel.SITE:
+        elif custom_field.model == "site":
             field = custom_field.get_or_create_field_value(agent.site)
         else:
             return notify_error("Custom Field was invalid")
@@ -801,23 +678,39 @@ def run_script(request, agent_id):
             timeout=req_timeout,
             wait=True,
             history_pk=history_pk,
-            run_as_user=run_as_user,
         )
 
         Note.objects.create(agent=agent, user=request.user, note=r)
         return Response(r)
     else:
         agent.run_script(
-            scriptpk=script.pk,
-            args=args,
-            timeout=req_timeout,
-            history_pk=history_pk,
-            run_as_user=run_as_user,
+            scriptpk=script.pk, args=args, timeout=req_timeout, history_pk=history_pk
         )
 
     return Response(f"{script.name} will now be run on {agent.hostname}")
 
 
+@api_view(["POST"])
+def get_mesh_exe(request, arch):
+    filename = "meshagent.exe" if arch == "64" else "meshagent-x86.exe"
+    mesh_exe = os.path.join(settings.EXE_DIR, filename)
+    if not os.path.exists(mesh_exe):
+        return notify_error(f"File {filename} has not been uploaded.")
+
+    if settings.DEBUG:
+        with open(mesh_exe, "rb") as f:
+            response = HttpResponse(
+                f.read(), content_type="application/vnd.microsoft.portable-executable"
+            )
+            response["Content-Disposition"] = f"inline; filename={filename}"
+            return response
+    else:
+        response = HttpResponse()
+        response["Content-Disposition"] = f"attachment; filename={filename}"
+        response["X-Accel-Redirect"] = f"/private/exe/{filename}"
+        return response
+
+
 class GetAddNotes(APIView):
     permission_classes = [IsAuthenticated, AgentNotesPerms]
 
@@ -826,7 +719,7 @@ class GetAddNotes(APIView):
             agent = get_object_or_404(Agent, agent_id=agent_id)
             notes = Note.objects.filter(agent=agent)
         else:
-            notes = Note.objects.filter_by_role(request.user)  # type: ignore
+            notes = Note.objects.filter_by_role(request.user)
 
         return Response(AgentNoteSerializer(notes, many=True).data)
 
@@ -835,9 +728,6 @@ class GetAddNotes(APIView):
         if not _has_perm_on_agent(request.user, agent.agent_id):
             raise PermissionDenied()
 
-        if "note" not in request.data.keys():
-            return notify_error("Cannot add an empty note")
-
         data = {
             "note": request.data["note"],
             "agent": agent.pk,
@@ -891,39 +781,32 @@ def bulk(request):
     if request.data["target"] == "client":
         if not _has_perm_on_client(request.user, request.data["client"]):
             raise PermissionDenied()
-        q = Agent.objects.filter_by_role(request.user).filter(  # type: ignore
+        q = Agent.objects.filter_by_role(request.user).filter(
             site__client_id=request.data["client"]
         )
 
     elif request.data["target"] == "site":
         if not _has_perm_on_site(request.user, request.data["site"]):
             raise PermissionDenied()
-        q = Agent.objects.filter_by_role(request.user).filter(  # type: ignore
+        q = Agent.objects.filter_by_role(request.user).filter(
             site_id=request.data["site"]
         )
 
     elif request.data["target"] == "agents":
-        q = Agent.objects.filter_by_role(request.user).filter(  # type: ignore
+        q = Agent.objects.filter_by_role(request.user).filter(
             agent_id__in=request.data["agents"]
         )
 
     elif request.data["target"] == "all":
-        q = Agent.objects.filter_by_role(request.user).only("pk", "monitoring_type")  # type: ignore
+        q = Agent.objects.filter_by_role(request.user).only("pk", "monitoring_type")
 
     else:
         return notify_error("Something went wrong")
 
     if request.data["monType"] == "servers":
-        q = q.filter(monitoring_type=AgentMonType.SERVER)
+        q = q.filter(monitoring_type="server")
     elif request.data["monType"] == "workstations":
-        q = q.filter(monitoring_type=AgentMonType.WORKSTATION)
-
-    if request.data["osType"] == AgentPlat.WINDOWS:
-        q = q.filter(plat=AgentPlat.WINDOWS)
-    elif request.data["osType"] == AgentPlat.LINUX:
-        q = q.filter(plat=AgentPlat.LINUX)
-    elif request.data["osType"] == AgentPlat.DARWIN:
-        q = q.filter(plat=AgentPlat.DARWIN)
+        q = q.filter(monitoring_type="workstation")
 
     agents: list[int] = [agent.pk for agent in q]
 
@@ -938,18 +821,13 @@ def bulk(request):
     )
 
     if request.data["mode"] == "command":
-        if request.data["shell"] == "custom" and request.data["custom_shell"]:
-            shell = request.data["custom_shell"]
-        else:
-            shell = request.data["shell"]
-
         handle_bulk_command_task.delay(
             agents,
             request.data["cmd"],
-            shell,
+            request.data["shell"],
             request.data["timeout"],
             request.user.username[:50],
-            request.data["run_as_user"],
+            run_on_offline=request.data["offlineAgents"],
         )
         return Response(f"Command will now be run on {len(agents)} agents")
 
@@ -961,7 +839,6 @@ def bulk(request):
             request.data["args"],
             request.data["timeout"],
             request.user.username[:50],
-            request.data["run_as_user"],
         )
         return Response(f"{script.name} will now be run on {len(agents)} agents")
 
@@ -988,7 +865,7 @@ def agent_maintenance(request):
             raise PermissionDenied()
 
         count = (
-            Agent.objects.filter_by_role(request.user)  # type: ignore
+            Agent.objects.filter_by_role(request.user)
             .filter(site__client_id=request.data["id"])
             .update(maintenance_mode=request.data["action"])
         )
@@ -998,7 +875,7 @@ def agent_maintenance(request):
             raise PermissionDenied()
 
         count = (
-            Agent.objects.filter_by_role(request.user)  # type: ignore
+            Agent.objects.filter_by_role(request.user)
             .filter(site_id=request.data["id"])
             .update(maintenance_mode=request.data["action"])
         )
@@ -1009,17 +886,10 @@ def agent_maintenance(request):
     if count:
         action = "disabled" if not request.data["action"] else "enabled"
         return Response(f"Maintenance mode has been {action} on {count} agents")
-
-    return Response(
-        f"No agents have been put in maintenance mode. You might not have permissions to the resources."
-    )
-
-
-@api_view(["GET"])
-@permission_classes([IsAuthenticated, RecoverAgentPerms])
-def bulk_agent_recovery(request):
-    bulk_recover_agents_task.delay()
-    return Response("Agents will now be recovered")
+    else:
+        return Response(
+            f"No agents have been put in maintenance mode. You might not have permissions to the resources."
+        )
 
 
 class WMI(APIView):
@@ -1041,6 +911,6 @@ class AgentHistoryView(APIView):
             agent = get_object_or_404(Agent, agent_id=agent_id)
             history = AgentHistory.objects.filter(agent=agent)
         else:
-            history = AgentHistory.objects.filter_by_role(request.user)  # type: ignore
+            history = AgentHistory.objects.filter_by_role(request.user)
         ctx = {"default_tz": get_default_timezone()}
         return Response(AgentHistorySerializer(history, many=True, context=ctx).data)

api/tacticalrmm/alerts/migrations/0011_alter_alert_agent.py

@@ -1,24 +0,0 @@
-# Generated by Django 4.0.3 on 2022-04-07 17:28
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-def delete_alerts_without_agent(apps, schema):
-    Alert = apps.get_model("alerts", "Alert")
-
-    Alert.objects.filter(agent=None).delete()
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("agents", "0047_alter_agent_plat_alter_agent_site"),
-        ("alerts", "0010_auto_20210917_1954"),
-    ]
-
-    operations = [
-        migrations.RunPython(
-            delete_alerts_without_agent, reverse_code=migrations.RunPython.noop
-        ),
-    ]

api/tacticalrmm/alerts/migrations/0012_alter_alert_action_retcode_and_more.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.0.5 on 2022-06-29 07:57
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('alerts', '0011_alter_alert_agent'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='alert',
-            name='action_retcode',
-            field=models.BigIntegerField(blank=True, null=True),
-        ),
-        migrations.AlterField(
-            model_name='alert',
-            name='resolved_action_retcode',
-            field=models.BigIntegerField(blank=True, null=True),
-        ),
-    ]

api/tacticalrmm/alerts/models.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Union
 
 from django.contrib.postgres.fields import ArrayField
 from django.db import models
@@ -9,20 +9,26 @@ from django.db.models.fields import BooleanField, PositiveIntegerField
 from django.utils import timezone as djangotime
 
 from logs.models import BaseAuditModel, DebugLog
-from tacticalrmm.constants import (
-    AgentMonType,
-    AlertSeverity,
-    AlertType,
-    CheckType,
-    DebugLogType,
-)
 from tacticalrmm.models import PermissionQuerySet
 
 if TYPE_CHECKING:
     from agents.models import Agent
-    from autotasks.models import AutomatedTask, TaskResult
-    from checks.models import Check, CheckResult
-    from clients.models import Client, Site
+    from autotasks.models import AutomatedTask
+    from checks.models import Check
+
+
+SEVERITY_CHOICES = [
+    ("info", "Informational"),
+    ("warning", "Warning"),
+    ("error", "Error"),
+]
+
+ALERT_TYPE_CHOICES = [
+    ("availability", "Availability"),
+    ("check", "Check"),
+    ("task", "Task"),
+    ("custom", "Custom"),
+]
 
 
 class Alert(models.Model):
@@ -50,7 +56,7 @@ class Alert(models.Model):
         blank=True,
     )
     alert_type = models.CharField(
-        max_length=20, choices=AlertType.choices, default=AlertType.AVAILABILITY
+        max_length=20, choices=ALERT_TYPE_CHOICES, default="availability"
     )
     message = models.TextField(null=True, blank=True)
     alert_time = models.DateTimeField(auto_now_add=True, null=True, blank=True)
@@ -58,9 +64,7 @@ class Alert(models.Model):
     snooze_until = models.DateTimeField(null=True, blank=True)
     resolved = models.BooleanField(default=False)
     resolved_on = models.DateTimeField(null=True, blank=True)
-    severity = models.CharField(
-        max_length=30, choices=AlertSeverity.choices, default=AlertSeverity.INFO
-    )
+    severity = models.CharField(max_length=30, choices=SEVERITY_CHOICES, default="info")
     email_sent = models.DateTimeField(null=True, blank=True)
     resolved_email_sent = models.DateTimeField(null=True, blank=True)
     sms_sent = models.DateTimeField(null=True, blank=True)
@@ -69,208 +73,72 @@ class Alert(models.Model):
     action_run = models.DateTimeField(null=True, blank=True)
     action_stdout = models.TextField(null=True, blank=True)
     action_stderr = models.TextField(null=True, blank=True)
-    action_retcode = models.BigIntegerField(null=True, blank=True)
+    action_retcode = models.IntegerField(null=True, blank=True)
     action_execution_time = models.CharField(max_length=100, null=True, blank=True)
     resolved_action_run = models.DateTimeField(null=True, blank=True)
     resolved_action_stdout = models.TextField(null=True, blank=True)
     resolved_action_stderr = models.TextField(null=True, blank=True)
-    resolved_action_retcode = models.BigIntegerField(null=True, blank=True)
+    resolved_action_retcode = models.IntegerField(null=True, blank=True)
     resolved_action_execution_time = models.CharField(
         max_length=100, null=True, blank=True
     )
 
-    def __str__(self) -> str:
-        return f"{self.alert_type} - {self.message}"
+    def __str__(self):
+        return self.message
 
-    @property
-    def assigned_agent(self) -> "Optional[Agent]":
-        return self.agent
-
-    @property
-    def site(self) -> "Site":
-        return self.agent.site
-
-    @property
-    def client(self) -> "Client":
-        return self.agent.client
-
-    def resolve(self) -> None:
+    def resolve(self):
         self.resolved = True
         self.resolved_on = djangotime.now()
         self.snoozed = False
         self.snooze_until = None
-        self.save(update_fields=["resolved", "resolved_on", "snoozed", "snooze_until"])
+        self.save()
 
     @classmethod
-    def create_or_return_availability_alert(
-        cls, agent: Agent, skip_create: bool = False
-    ) -> Optional[Alert]:
-        if not cls.objects.filter(
-            agent=agent, alert_type=AlertType.AVAILABILITY, resolved=False
-        ).exists():
-            if skip_create:
-                return None
-
-            return cast(
-                Alert,
-                cls.objects.create(
-                    agent=agent,
-                    alert_type=AlertType.AVAILABILITY,
-                    severity=AlertSeverity.ERROR,
-                    message=f"{agent.hostname} in {agent.client.name}\\{agent.site.name} is overdue.",
-                    hidden=True,
-                ),
+    def create_or_return_availability_alert(cls, agent):
+        if not cls.objects.filter(agent=agent, resolved=False).exists():
+            return cls.objects.create(
+                agent=agent,
+                alert_type="availability",
+                severity="error",
+                message=f"{agent.hostname} in {agent.client.name}\\{agent.site.name} is overdue.",
+                hidden=True,
             )
         else:
-            try:
-                return cast(
-                    Alert,
-                    cls.objects.get(
-                        agent=agent, alert_type=AlertType.AVAILABILITY, resolved=False
-                    ),
-                )
-            except cls.MultipleObjectsReturned:
-                alerts = cls.objects.filter(
-                    agent=agent, alert_type=AlertType.AVAILABILITY, resolved=False
-                )
-
-                last_alert = cast(Alert, alerts.last())
-
-                # cycle through other alerts and resolve
-                for alert in alerts:
-                    if alert.id != last_alert.pk:
-                        alert.resolve()
-
-                return last_alert
-            except cls.DoesNotExist:
-                return None
+            return cls.objects.get(agent=agent, resolved=False)
 
     @classmethod
-    def create_or_return_check_alert(
-        cls,
-        check: "Check",
-        agent: "Agent",
-        alert_severity: Optional[str] = None,
-        skip_create: bool = False,
-    ) -> "Optional[Alert]":
+    def create_or_return_check_alert(cls, check):
 
-        # need to pass agent if the check is a policy
-        if not cls.objects.filter(
-            assigned_check=check,
-            agent=agent,
-            resolved=False,
-        ).exists():
-            if skip_create:
-                return None
-
-            return cast(
-                Alert,
-                cls.objects.create(
-                    assigned_check=check,
-                    agent=agent,
-                    alert_type=AlertType.CHECK,
-                    severity=check.alert_severity
-                    if check.check_type
-                    not in [
-                        CheckType.MEMORY,
-                        CheckType.CPU_LOAD,
-                        CheckType.DISK_SPACE,
-                        CheckType.SCRIPT,
-                    ]
-                    else alert_severity,
-                    message=f"{agent.hostname} has a {check.check_type} check: {check.readable_desc} that failed.",
-                    hidden=True,
-                ),
+        if not cls.objects.filter(assigned_check=check, resolved=False).exists():
+            return cls.objects.create(
+                assigned_check=check,
+                alert_type="check",
+                severity=check.alert_severity,
+                message=f"{check.agent.hostname} has a {check.check_type} check: {check.readable_desc} that failed.",
+                hidden=True,
             )
         else:
-            try:
-                return cast(
-                    Alert,
-                    cls.objects.get(
-                        assigned_check=check,
-                        agent=agent,
-                        resolved=False,
-                    ),
-                )
-            except cls.MultipleObjectsReturned:
-                alerts = cls.objects.filter(
-                    assigned_check=check,
-                    agent=agent,
-                    resolved=False,
-                )
-                last_alert = cast(Alert, alerts.last())
-
-                # cycle through other alerts and resolve
-                for alert in alerts:
-                    if alert.id != last_alert.pk:
-                        alert.resolve()
-
-                return last_alert
-            except cls.DoesNotExist:
-                return None
+            return cls.objects.get(assigned_check=check, resolved=False)
 
     @classmethod
-    def create_or_return_task_alert(
-        cls,
-        task: "AutomatedTask",
-        agent: "Agent",
-        skip_create: bool = False,
-    ) -> "Optional[Alert]":
+    def create_or_return_task_alert(cls, task):
 
-        if not cls.objects.filter(
-            assigned_task=task,
-            agent=agent,
-            resolved=False,
-        ).exists():
-            if skip_create:
-                return None
-
-            return cast(
-                Alert,
-                cls.objects.create(
-                    assigned_task=task,
-                    agent=agent,
-                    alert_type=AlertType.TASK,
-                    severity=task.alert_severity,
-                    message=f"{agent.hostname} has task: {task.name} that failed.",
-                    hidden=True,
-                ),
+        if not cls.objects.filter(assigned_task=task, resolved=False).exists():
+            return cls.objects.create(
+                assigned_task=task,
+                alert_type="task",
+                severity=task.alert_severity,
+                message=f"{task.agent.hostname} has task: {task.name} that failed.",
+                hidden=True,
             )
-
         else:
-            try:
-                return cast(
-                    Alert,
-                    cls.objects.get(
-                        assigned_task=task,
-                        agent=agent,
-                        resolved=False,
-                    ),
-                )
-            except cls.MultipleObjectsReturned:
-                alerts = cls.objects.filter(
-                    assigned_task=task,
-                    agent=agent,
-                    resolved=False,
-                )
-                last_alert = cast(Alert, alerts.last())
-
-                # cycle through other alerts and resolve
-                for alert in alerts:
-                    if alert.id != last_alert.pk:
-                        alert.resolve()
-
-                return last_alert
-            except cls.DoesNotExist:
-                return None
+            return cls.objects.get(assigned_task=task, resolved=False)
 
     @classmethod
-    def handle_alert_failure(
-        cls, instance: Union[Agent, TaskResult, CheckResult]
-    ) -> None:
+    def handle_alert_failure(cls, instance: Union[Agent, AutomatedTask, Check]) -> None:
         from agents.models import Agent
-        from autotasks.models import TaskResult
-        from checks.models import CheckResult
+        from autotasks.models import AutomatedTask
+        from checks.models import Check
 
         # set variables
         dashboard_severities = None
@@ -282,7 +150,6 @@ class Alert(models.Model):
         alert_interval = None
         email_task = None
         text_task = None
-        run_script_action = None
 
         # check what the instance passed is
         if isinstance(instance, Agent):
@@ -296,21 +163,30 @@ class Alert(models.Model):
             dashboard_alert = instance.overdue_dashboard_alert
             alert_template = instance.alert_template
             maintenance_mode = instance.maintenance_mode
-            alert_severity = AlertSeverity.ERROR
+            alert_severity = "error"
             agent = instance
-            dashboard_severities = [AlertSeverity.ERROR]
-            email_severities = [AlertSeverity.ERROR]
-            text_severities = [AlertSeverity.ERROR]
 
             # set alert_template settings
             if alert_template:
+                dashboard_severities = ["error"]
+                email_severities = ["error"]
+                text_severities = ["error"]
                 always_dashboard = alert_template.agent_always_alert
                 always_email = alert_template.agent_always_email
                 always_text = alert_template.agent_always_text
                 alert_interval = alert_template.agent_periodic_alert_days
                 run_script_action = alert_template.agent_script_actions
 
-        elif isinstance(instance, CheckResult):
+            if instance.should_create_alert(alert_template):
+                alert = cls.create_or_return_availability_alert(instance)
+            else:
+                # check if there is an alert that exists
+                if cls.objects.filter(agent=instance, resolved=False).exists():
+                    alert = cls.objects.get(agent=instance, resolved=False)
+                else:
+                    alert = None
+
+        elif isinstance(instance, Check):
             from checks.tasks import (
                 handle_check_email_alert_task,
                 handle_check_sms_alert_task,
@@ -319,98 +195,75 @@ class Alert(models.Model):
             email_task = handle_check_email_alert_task
             text_task = handle_check_sms_alert_task
 
-            email_alert = instance.assigned_check.email_alert
-            text_alert = instance.assigned_check.text_alert
-            dashboard_alert = instance.assigned_check.dashboard_alert
+            email_alert = instance.email_alert
+            text_alert = instance.text_alert
+            dashboard_alert = instance.dashboard_alert
             alert_template = instance.agent.alert_template
             maintenance_mode = instance.agent.maintenance_mode
-            alert_severity = (
-                instance.assigned_check.alert_severity
-                if instance.assigned_check.check_type
-                not in [
-                    CheckType.MEMORY,
-                    CheckType.CPU_LOAD,
-                    CheckType.DISK_SPACE,
-                    CheckType.SCRIPT,
-                ]
-                else instance.alert_severity
-            )
+            alert_severity = instance.alert_severity
             agent = instance.agent
 
             # set alert_template settings
             if alert_template:
-                dashboard_severities = (
-                    alert_template.check_dashboard_alert_severity
-                    if alert_template.check_dashboard_alert_severity
-                    else [
-                        AlertSeverity.ERROR,
-                        AlertSeverity.WARNING,
-                        AlertSeverity.INFO,
-                    ]
-                )
-                email_severities = (
-                    alert_template.check_email_alert_severity
-                    if alert_template.check_email_alert_severity
-                    else [AlertSeverity.ERROR, AlertSeverity.WARNING]
-                )
-                text_severities = (
-                    alert_template.check_text_alert_severity
-                    if alert_template.check_text_alert_severity
-                    else [AlertSeverity.ERROR, AlertSeverity.WARNING]
-                )
+                dashboard_severities = alert_template.check_dashboard_alert_severity
+                email_severities = alert_template.check_email_alert_severity
+                text_severities = alert_template.check_text_alert_severity
                 always_dashboard = alert_template.check_always_alert
                 always_email = alert_template.check_always_email
                 always_text = alert_template.check_always_text
                 alert_interval = alert_template.check_periodic_alert_days
                 run_script_action = alert_template.check_script_actions
 
-        elif isinstance(instance, TaskResult):
+            if instance.should_create_alert(alert_template):
+                alert = cls.create_or_return_check_alert(instance)
+            else:
+                # check if there is an alert that exists
+                if cls.objects.filter(assigned_check=instance, resolved=False).exists():
+                    alert = cls.objects.get(assigned_check=instance, resolved=False)
+                else:
+                    alert = None
+
+        elif isinstance(instance, AutomatedTask):
             from autotasks.tasks import handle_task_email_alert, handle_task_sms_alert
 
             email_task = handle_task_email_alert
             text_task = handle_task_sms_alert
 
-            email_alert = instance.task.email_alert
-            text_alert = instance.task.text_alert
-            dashboard_alert = instance.task.dashboard_alert
+            email_alert = instance.email_alert
+            text_alert = instance.text_alert
+            dashboard_alert = instance.dashboard_alert
             alert_template = instance.agent.alert_template
             maintenance_mode = instance.agent.maintenance_mode
-            alert_severity = instance.task.alert_severity
+            alert_severity = instance.alert_severity
             agent = instance.agent
 
             # set alert_template settings
             if alert_template:
-                dashboard_severities = (
-                    alert_template.task_dashboard_alert_severity
-                    if alert_template.task_dashboard_alert_severity
-                    else [AlertSeverity.ERROR, AlertSeverity.WARNING]
-                )
-                email_severities = (
-                    alert_template.task_email_alert_severity
-                    if alert_template.task_email_alert_severity
-                    else [AlertSeverity.ERROR, AlertSeverity.WARNING]
-                )
-                text_severities = (
-                    alert_template.task_text_alert_severity
-                    if alert_template.task_text_alert_severity
-                    else [AlertSeverity.ERROR, AlertSeverity.WARNING]
-                )
+                dashboard_severities = alert_template.task_dashboard_alert_severity
+                email_severities = alert_template.task_email_alert_severity
+                text_severities = alert_template.task_text_alert_severity
                 always_dashboard = alert_template.task_always_alert
                 always_email = alert_template.task_always_email
                 always_text = alert_template.task_always_text
                 alert_interval = alert_template.task_periodic_alert_days
                 run_script_action = alert_template.task_script_actions
 
+            if instance.should_create_alert(alert_template):
+                alert = cls.create_or_return_task_alert(instance)
+            else:
+                # check if there is an alert that exists
+                if cls.objects.filter(assigned_task=instance, resolved=False).exists():
+                    alert = cls.objects.get(assigned_task=instance, resolved=False)
+                else:
+                    alert = None
         else:
             return
 
-        alert = instance.get_or_create_alert_if_needed(alert_template)
-
         # return if agent is in maintenance mode
-        if not alert or maintenance_mode:
+        if maintenance_mode or not alert:
             return
 
-        # check if alert severity changed and update the alert
+        # check if alert severity changed on check and update the alert
         if alert_severity != alert.severity:
             alert.severity = alert_severity
             alert.save(update_fields=["severity"])
@@ -419,25 +272,19 @@ class Alert(models.Model):
         if dashboard_alert or always_dashboard:
 
             # check if alert template is set and specific severities are configured
-            if (
-                not alert_template
-                or alert_template
-                and dashboard_severities
-                and alert.severity in dashboard_severities
-            ):
+            if alert_template and alert.severity not in dashboard_severities:  # type: ignore
+                pass
+            else:
                 alert.hidden = False
-                alert.save(update_fields=["hidden"])
+                alert.save()
 
         # send email if enabled
         if email_alert or always_email:
 
             # check if alert template is set and specific severities are configured
-            if (
-                not alert_template
-                or alert_template
-                and email_severities
-                and alert.severity in email_severities
-            ):
+            if alert_template and alert.severity not in email_severities:  # type: ignore
+                pass
+            else:
                 email_task.delay(
                     pk=alert.pk,
                     alert_interval=alert_interval,
@@ -447,21 +294,13 @@ class Alert(models.Model):
         if text_alert or always_text:
 
             # check if alert template is set and specific severities are configured
-            if (
-                not alert_template
-                or alert_template
-                and text_severities
-                and alert.severity in text_severities
-            ):
+            if alert_template and alert.severity not in text_severities:  # type: ignore
+                pass
+            else:
                 text_task.delay(pk=alert.pk, alert_interval=alert_interval)
 
         # check if any scripts should be run
-        if (
-            alert_template
-            and alert_template.action
-            and run_script_action
-            and not alert.action_run
-        ):
+        if alert_template and alert_template.action and run_script_action and not alert.action_run:  # type: ignore
             r = agent.run_script(
                 scriptpk=alert_template.action.pk,
                 args=alert.parse_script_args(alert_template.action_args),
@@ -469,11 +308,10 @@ class Alert(models.Model):
                 wait=True,
                 full=True,
                 run_on_any=True,
-                run_as_user=False,
             )
 
             # command was successful
-            if isinstance(r, dict):
+            if type(r) == dict:
                 alert.action_retcode = r["retcode"]
                 alert.action_stdout = r["stdout"]
                 alert.action_stderr = r["stderr"]
@@ -483,24 +321,21 @@ class Alert(models.Model):
             else:
                 DebugLog.error(
                     agent=agent,
-                    log_type=DebugLogType.SCRIPTING,
+                    log_type="scripting",
                     message=f"Failure action: {alert_template.action.name} failed to run on any agent for {agent.hostname}({agent.pk}) failure alert",
                 )
 
     @classmethod
-    def handle_alert_resolve(
-        cls, instance: Union[Agent, TaskResult, CheckResult]
-    ) -> None:
+    def handle_alert_resolve(cls, instance: Union[Agent, AutomatedTask, Check]) -> None:
         from agents.models import Agent
-        from autotasks.models import TaskResult
-        from checks.models import CheckResult
+        from autotasks.models import AutomatedTask
+        from checks.models import Check
 
         # set variables
         email_on_resolved = False
         text_on_resolved = False
         resolved_email_task = None
         resolved_text_task = None
-        run_script_action = None
 
         # check what the instance passed is
         if isinstance(instance, Agent):
@@ -510,6 +345,7 @@ class Alert(models.Model):
             resolved_text_task = agent_recovery_sms_task
 
             alert_template = instance.alert_template
+            alert = cls.objects.get(agent=instance, resolved=False)
             maintenance_mode = instance.maintenance_mode
             agent = instance
 
@@ -518,12 +354,7 @@ class Alert(models.Model):
                 text_on_resolved = alert_template.agent_text_on_resolved
                 run_script_action = alert_template.agent_script_actions
 
-            if agent.overdue_email_alert:
-                email_on_resolved = True
-            if agent.overdue_text_alert:
-                text_on_resolved = True
-
-        elif isinstance(instance, CheckResult):
+        elif isinstance(instance, Check):
             from checks.tasks import (
                 handle_resolved_check_email_alert_task,
                 handle_resolved_check_sms_alert_task,
@@ -533,6 +364,7 @@ class Alert(models.Model):
             resolved_text_task = handle_resolved_check_sms_alert_task
 
             alert_template = instance.agent.alert_template
+            alert = cls.objects.get(assigned_check=instance, resolved=False)
             maintenance_mode = instance.agent.maintenance_mode
             agent = instance.agent
 
@@ -541,7 +373,7 @@ class Alert(models.Model):
                 text_on_resolved = alert_template.check_text_on_resolved
                 run_script_action = alert_template.check_script_actions
 
-        elif isinstance(instance, TaskResult):
+        elif isinstance(instance, AutomatedTask):
             from autotasks.tasks import (
                 handle_resolved_task_email_alert,
                 handle_resolved_task_sms_alert,
@@ -551,6 +383,7 @@ class Alert(models.Model):
             resolved_text_task = handle_resolved_task_sms_alert
 
             alert_template = instance.agent.alert_template
+            alert = cls.objects.get(assigned_task=instance, resolved=False)
             maintenance_mode = instance.agent.maintenance_mode
             agent = instance.agent
 
@@ -562,10 +395,8 @@ class Alert(models.Model):
         else:
             return
 
-        alert = instance.get_or_create_alert_if_needed(alert_template)
-
         # return if agent is in maintenance mode
-        if not alert or maintenance_mode:
+        if maintenance_mode:
             return
 
         alert.resolve()
@@ -582,7 +413,7 @@ class Alert(models.Model):
         if (
             alert_template
             and alert_template.resolved_action
-            and run_script_action
+            and run_script_action  # type: ignore
             and not alert.resolved_action_run
         ):
             r = agent.run_script(
@@ -592,11 +423,10 @@ class Alert(models.Model):
                 wait=True,
                 full=True,
                 run_on_any=True,
-                run_as_user=False,
             )
 
             # command was successful
-            if isinstance(r, dict):
+            if type(r) == dict:
                 alert.resolved_action_retcode = r["retcode"]
                 alert.resolved_action_stdout = r["stdout"]
                 alert.resolved_action_stderr = r["stderr"]
@@ -608,16 +438,16 @@ class Alert(models.Model):
             else:
                 DebugLog.error(
                     agent=agent,
-                    log_type=DebugLogType.SCRIPTING,
+                    log_type="scripting",
                     message=f"Resolved action: {alert_template.action.name} failed to run on any agent for {agent.hostname}({agent.pk}) resolved alert",
                 )
 
-    def parse_script_args(self, args: List[str]) -> List[str]:
+    def parse_script_args(self, args: list[str]):
 
         if not args:
             return []
 
-        temp_args = []
+        temp_args = list()
         # pattern to match for injection
         pattern = re.compile(".*\\{\\{alert\\.(.*)\\}\\}.*")
 
@@ -633,9 +463,9 @@ class Alert(models.Model):
                     continue
 
                 try:
-                    temp_args.append(re.sub("\\{\\{.*\\}\\}", value, arg))
+                    temp_args.append(re.sub("\\{\\{.*\\}\\}", value, arg))  # type: ignore
                 except Exception as e:
-                    DebugLog.error(log_type=DebugLogType.SCRIPTING, message=str(e))
+                    DebugLog.error(log_type="scripting", message=str(e))
                     continue
 
             else:
@@ -705,17 +535,17 @@ class AlertTemplate(BaseAuditModel):
 
     # check alert settings
     check_email_alert_severity = ArrayField(
-        models.CharField(max_length=25, blank=True, choices=AlertSeverity.choices),
+        models.CharField(max_length=25, blank=True, choices=SEVERITY_CHOICES),
         blank=True,
         default=list,
     )
     check_text_alert_severity = ArrayField(
-        models.CharField(max_length=25, blank=True, choices=AlertSeverity.choices),
+        models.CharField(max_length=25, blank=True, choices=SEVERITY_CHOICES),
         blank=True,
         default=list,
     )
     check_dashboard_alert_severity = ArrayField(
-        models.CharField(max_length=25, blank=True, choices=AlertSeverity.choices),
+        models.CharField(max_length=25, blank=True, choices=SEVERITY_CHOICES),
         blank=True,
         default=list,
     )
@@ -729,17 +559,17 @@ class AlertTemplate(BaseAuditModel):
 
     # task alert settings
     task_email_alert_severity = ArrayField(
-        models.CharField(max_length=25, blank=True, choices=AlertSeverity.choices),
+        models.CharField(max_length=25, blank=True, choices=SEVERITY_CHOICES),
         blank=True,
         default=list,
     )
     task_text_alert_severity = ArrayField(
-        models.CharField(max_length=25, blank=True, choices=AlertSeverity.choices),
+        models.CharField(max_length=25, blank=True, choices=SEVERITY_CHOICES),
         blank=True,
         default=list,
     )
     task_dashboard_alert_severity = ArrayField(
-        models.CharField(max_length=25, blank=True, choices=AlertSeverity.choices),
+        models.CharField(max_length=25, blank=True, choices=SEVERITY_CHOICES),
         blank=True,
         default=list,
     )
@@ -765,22 +595,11 @@ class AlertTemplate(BaseAuditModel):
         "agents.Agent", related_name="alert_exclusions", blank=True
     )
 
-    def __str__(self) -> str:
+    def __str__(self):
         return self.name
 
-    def is_agent_excluded(self, agent: "Agent") -> bool:
-        return (
-            agent in self.excluded_agents.all()
-            or agent.site in self.excluded_sites.all()
-            or agent.client in self.excluded_clients.all()
-            or agent.monitoring_type == AgentMonType.WORKSTATION
-            and self.exclude_workstations
-            or agent.monitoring_type == AgentMonType.SERVER
-            and self.exclude_servers
-        )
-
     @staticmethod
-    def serialize(alert_template: AlertTemplate) -> Dict[str, Any]:
+    def serialize(alert_template):
         # serializes the agent and returns json
         from .serializers import AlertTemplateAuditSerializer
 

api/tacticalrmm/alerts/permissions.py

@@ -1,15 +1,10 @@
-from typing import TYPE_CHECKING
-
 from django.shortcuts import get_object_or_404
 from rest_framework import permissions
 
 from tacticalrmm.permissions import _has_perm, _has_perm_on_agent
 
-if TYPE_CHECKING:
-    from accounts.models import User
 
-
-def _has_perm_on_alert(user: "User", id: int) -> bool:
+def _has_perm_on_alert(user, id: int):
     from alerts.models import Alert
 
     role = user.role
@@ -24,6 +19,10 @@ def _has_perm_on_alert(user: "User", id: int) -> bool:
 
     if alert.agent:
         agent_id = alert.agent.agent_id
+    elif alert.assigned_check:
+        agent_id = alert.assigned_check.agent.agent_id
+    elif alert.assigned_task:
+        agent_id = alert.assigned_task.agent.agent_id
     else:
         return True
 
@@ -31,8 +30,8 @@ def _has_perm_on_alert(user: "User", id: int) -> bool:
 
 
 class AlertPerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
-        if r.method in ("GET", "PATCH"):
+    def has_permission(self, r, view):
+        if r.method == "GET" or r.method == "PATCH":
             if "pk" in view.kwargs.keys():
                 return _has_perm(r, "can_list_alerts") and _has_perm_on_alert(
                     r.user, view.kwargs["pk"]
@@ -49,8 +48,8 @@ class AlertPerms(permissions.BasePermission):
 
 
 class AlertTemplatePerms(permissions.BasePermission):
-    def has_permission(self, r, view) -> bool:
+    def has_permission(self, r, view):
         if r.method == "GET":
             return _has_perm(r, "can_list_alerttemplates")
-
-        return _has_perm(r, "can_manage_alerttemplates")
+        else:
+            return _has_perm(r, "can_manage_alerttemplates")

api/tacticalrmm/alerts/serializers.py

@@ -3,17 +3,103 @@ from rest_framework.serializers import ModelSerializer, ReadOnlyField
 
 from automation.serializers import PolicySerializer
 from clients.serializers import ClientMinimumSerializer, SiteMinimumSerializer
+from tacticalrmm.utils import get_default_timezone
 
 from .models import Alert, AlertTemplate
 
 
 class AlertSerializer(ModelSerializer):
 
-    hostname = ReadOnlyField(source="assigned_agent.hostname")
-    agent_id = ReadOnlyField(source="assigned_agent.agent_id")
-    client = ReadOnlyField(source="client.name")
-    site = ReadOnlyField(source="site.name")
-    alert_time = ReadOnlyField()
+    hostname = SerializerMethodField()
+    agent_id = SerializerMethodField()
+    client = SerializerMethodField()
+    site = SerializerMethodField()
+    alert_time = SerializerMethodField()
+    resolve_on = SerializerMethodField()
+    snoozed_until = SerializerMethodField()
+
+    def get_agent_id(self, instance):
+        if instance.alert_type == "availability":
+            return instance.agent.agent_id if instance.agent else ""
+        elif instance.alert_type == "check":
+            return (
+                instance.assigned_check.agent.agent_id
+                if instance.assigned_check
+                else ""
+            )
+        elif instance.alert_type == "task":
+            return (
+                instance.assigned_task.agent.agent_id if instance.assigned_task else ""
+            )
+        else:
+            return ""
+
+    def get_hostname(self, instance):
+        if instance.alert_type == "availability":
+            return instance.agent.hostname if instance.agent else ""
+        elif instance.alert_type == "check":
+            return (
+                instance.assigned_check.agent.hostname
+                if instance.assigned_check
+                else ""
+            )
+        elif instance.alert_type == "task":
+            return (
+                instance.assigned_task.agent.hostname if instance.assigned_task else ""
+            )
+        else:
+            return ""
+
+    def get_client(self, instance):
+        if instance.alert_type == "availability":
+            return instance.agent.client.name if instance.agent else ""
+        elif instance.alert_type == "check":
+            return (
+                instance.assigned_check.agent.client.name
+                if instance.assigned_check
+                else ""
+            )
+        elif instance.alert_type == "task":
+            return (
+                instance.assigned_task.agent.client.name
+                if instance.assigned_task
+                else ""
+            )
+        else:
+            return ""
+
+    def get_site(self, instance):
+        if instance.alert_type == "availability":
+            return instance.agent.site.name if instance.agent else ""
+        elif instance.alert_type == "check":
+            return (
+                instance.assigned_check.agent.site.name
+                if instance.assigned_check
+                else ""
+            )
+        elif instance.alert_type == "task":
+            return (
+                instance.assigned_task.agent.site.name if instance.assigned_task else ""
+            )
+        else:
+            return ""
+
+    def get_alert_time(self, instance):
+        if instance.alert_time:
+            return instance.alert_time.astimezone(get_default_timezone()).timestamp()
+        else:
+            return None
+
+    def get_resolve_on(self, instance):
+        if instance.resolved_on:
+            return instance.resolved_on.astimezone(get_default_timezone()).timestamp()
+        else:
+            return None
+
+    def get_snoozed_until(self, instance):
+        if instance.snooze_until:
+            return instance.snooze_until.astimezone(get_default_timezone()).timestamp()
+        return None
 
     class Meta:
         model = Alert
@@ -35,11 +121,11 @@ class AlertTemplateSerializer(ModelSerializer):
         fields = "__all__"
 
     def get_applied_count(self, instance):
-        return (
-            instance.policies.count()
-            + instance.clients.count()
-            + instance.sites.count()
-        )
+        count = 0
+        count += instance.policies.count()
+        count += instance.clients.count()
+        count += instance.sites.count()
+        return count
 
 
 class AlertTemplateRelationSerializer(ModelSerializer):

api/tacticalrmm/alerts/tasks.py

@@ -1,13 +1,11 @@
 from django.utils import timezone as djangotime
-
-from agents.models import Agent
 from tacticalrmm.celery import app
 
-from .models import Alert
-
 
 @app.task
 def unsnooze_alerts() -> str:
+    from .models import Alert
+
     Alert.objects.filter(snoozed=True, snooze_until__lte=djangotime.now()).update(
         snoozed=False, snooze_until=None
     )
@@ -16,10 +14,10 @@ def unsnooze_alerts() -> str:
 
 
 @app.task
-def cache_agents_alert_template() -> str:
-    for agent in Agent.objects.only(
-        "pk", "site", "policy", "alert_template"
-    ).select_related("site", "policy", "alert_template"):
+def cache_agents_alert_template():
+    from agents.models import Agent
+
+    for agent in Agent.objects.only("pk"):
         agent.set_alert_template()
 
     return "ok"
@@ -27,6 +25,8 @@ def cache_agents_alert_template() -> str:
 
 @app.task
 def prune_resolved_alerts(older_than_days: int) -> str:
+    from .models import Alert
+
     Alert.objects.filter(resolved=True).filter(
         alert_time__lt=djangotime.now() - djangotime.timedelta(days=older_than_days)
     ).delete()

api/tacticalrmm/alerts/views.py

@@ -7,7 +7,7 @@ from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
-from tacticalrmm.helpers import notify_error
+from tacticalrmm.utils import notify_error
 
 from .models import Alert, AlertTemplate
 from .permissions import AlertPerms, AlertTemplatePerms
@@ -41,13 +41,13 @@ class GetAddAlerts(APIView):
 
         elif any(
             key
-            in (
+            in [
                 "timeFilter",
                 "clientFilter",
                 "severityFilter",
                 "resolvedFilter",
                 "snoozedFilter",
-            )
+            ]
             for key in request.data.keys()
         ):
             clientFilter = Q()
@@ -92,7 +92,7 @@ class GetAddAlerts(APIView):
                 )
 
             alerts = (
-                Alert.objects.filter_by_role(request.user)  # type: ignore
+                Alert.objects.filter_by_role(request.user)
                 .filter(clientFilter)
                 .filter(severityFilter)
                 .filter(resolvedFilter)
@@ -102,7 +102,7 @@ class GetAddAlerts(APIView):
             return Response(AlertSerializer(alerts, many=True).data)
 
         else:
-            alerts = Alert.objects.filter_by_role(request.user)  # type: ignore
+            alerts = Alert.objects.filter_by_role(request.user)
             return Response(AlertSerializer(alerts, many=True).data)
 
     def post(self, request):

api/tacticalrmm/apiv3/tests.py

@@ -1,8 +1,12 @@
+import json
+import os
+from unittest.mock import patch
+
+from django.conf import settings
 from django.utils import timezone as djangotime
 from model_bakery import baker
 
-from autotasks.models import TaskResult
-from tacticalrmm.constants import CustomFieldModel, CustomFieldType, TaskStatus
+from autotasks.models import AutomatedTask
 from tacticalrmm.test import TacticalTestCase
 
 
@@ -13,53 +17,46 @@ class TestAPIv3(TacticalTestCase):
         self.agent = baker.make_recipe("agents.agent")
 
     def test_get_checks(self):
-        agent = baker.make_recipe("agents.agent")
-        url = f"/api/v3/{agent.agent_id}/checkrunner/"
+        url = f"/api/v3/{self.agent.agent_id}/checkrunner/"
 
         # add a check
-        check1 = baker.make_recipe("checks.ping_check", agent=agent)
-        check_result1 = baker.make(
-            "checks.CheckResult", agent=agent, assigned_check=check1
-        )
+        check1 = baker.make_recipe("checks.ping_check", agent=self.agent)
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(r.data["check_interval"], self.agent.check_interval)
-        self.assertEqual(len(r.data["checks"]), 1)
+        self.assertEqual(r.data["check_interval"], self.agent.check_interval)  # type: ignore
+        self.assertEqual(len(r.data["checks"]), 1)  # type: ignore
 
         # override check run interval
         check2 = baker.make_recipe(
-            "checks.diskspace_check", agent=agent, run_interval=20
-        )
-        check_result2 = baker.make(
-            "checks.CheckResult", agent=agent, assigned_check=check2
+            "checks.ping_check", agent=self.agent, run_interval=20
         )
 
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(len(r.data["checks"]), 2)
-        self.assertEqual(r.data["check_interval"], 20)
+        self.assertEqual(r.data["check_interval"], 20)  # type: ignore
+        self.assertEqual(len(r.data["checks"]), 2)  # type: ignore
 
         # Set last_run on both checks and should return an empty list
-        check_result1.last_run = djangotime.now()
-        check_result1.save()
-        check_result2.last_run = djangotime.now()
-        check_result2.save()
+        check1.last_run = djangotime.now()
+        check1.save()
+        check2.last_run = djangotime.now()
+        check2.save()
 
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(r.data["check_interval"], 20)
-        self.assertFalse(r.data["checks"])
+        self.assertEqual(r.data["check_interval"], 20)  # type: ignore
+        self.assertFalse(r.data["checks"])  # type: ignore
 
         # set last_run greater than interval
-        check_result1.last_run = djangotime.now() - djangotime.timedelta(seconds=200)
-        check_result1.save()
-        check_result2.last_run = djangotime.now() - djangotime.timedelta(seconds=200)
-        check_result2.save()
+        check1.last_run = djangotime.now() - djangotime.timedelta(seconds=200)
+        check1.save()
+        check2.last_run = djangotime.now() - djangotime.timedelta(seconds=200)
+        check2.save()
 
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(r.data["check_interval"], 20)
-        self.assertEqual(len(r.data["checks"]), 2)
+        self.assertEqual(r.data["check_interval"], 20)  # type: ignore
+        self.assertEquals(len(r.data["checks"]), 2)  # type: ignore
 
         url = "/api/v3/Maj34ACb324j234asdj2n34kASDjh34-DESKTOPTEST123/checkrunner/"
         r = self.client.get(url)
@@ -67,6 +64,24 @@ class TestAPIv3(TacticalTestCase):
 
         self.check_not_authenticated("get", url)
 
+    def test_sysinfo(self):
+        # TODO replace this with golang wmi sample data
+
+        url = "/api/v3/sysinfo/"
+        with open(
+            os.path.join(
+                settings.BASE_DIR, "tacticalrmm/test_data/wmi_python_agent.json"
+            )
+        ) as f:
+            wmi_py = json.load(f)
+
+        payload = {"agent_id": self.agent.agent_id, "sysinfo": wmi_py}
+
+        r = self.client.patch(url, payload, format="json")
+        self.assertEqual(r.status_code, 200)
+
+        self.check_not_authenticated("patch", url)
+
     def test_checkrunner_interval(self):
         url = f"/api/v3/{self.agent.agent_id}/checkinterval/"
         r = self.client.get(url, format="json")
@@ -115,31 +130,61 @@ class TestAPIv3(TacticalTestCase):
         self.assertIsInstance(r.json()["check_interval"], int)
         self.assertEqual(len(r.json()["checks"]), 15)
 
-    def test_task_runner_get(self):
-        r = self.client.get("/api/v3/500/asdf9df9dfdf/taskrunner/")
+    @patch("apiv3.views.reload_nats")
+    def test_agent_recovery(self, reload_nats):
+        reload_nats.return_value = "ok"
+        r = self.client.get("/api/v3/34jahsdkjasncASDjhg2b3j4r/recover/")
         self.assertEqual(r.status_code, 404)
 
-        script = baker.make("scripts.script")
-
-        # setup data
-        task_actions = [
-            {"type": "cmd", "command": "whoami", "timeout": 10, "shell": "cmd"},
-            {
-                "type": "script",
-                "script": script.id,
-                "script_args": ["test"],
-                "timeout": 30,
-            },
-            {"type": "script", "script": 3, "script_args": [], "timeout": 30},
-        ]
-
-        agent = baker.make_recipe("agents.agent")
-        task = baker.make("autotasks.AutomatedTask", agent=agent, actions=task_actions)
-
-        url = f"/api/v3/{task.pk}/{agent.agent_id}/taskrunner/"
+        agent = baker.make_recipe("agents.online_agent")
+        url = f"/api/v3/{agent.agent_id}/recovery/"
 
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), {"mode": "pass", "shellcmd": ""})
+        reload_nats.assert_not_called()
+
+        baker.make("agents.RecoveryAction", agent=agent, mode="mesh")
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), {"mode": "mesh", "shellcmd": ""})
+        reload_nats.assert_not_called()
+
+        baker.make(
+            "agents.RecoveryAction",
+            agent=agent,
+            mode="command",
+            command="shutdown /r /t 5 /f",
+        )
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(
+            r.json(), {"mode": "command", "shellcmd": "shutdown /r /t 5 /f"}
+        )
+        reload_nats.assert_not_called()
+
+        baker.make("agents.RecoveryAction", agent=agent, mode="rpc")
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), {"mode": "rpc", "shellcmd": ""})
+        reload_nats.assert_called_once()
+
+    def test_task_runner_get(self):
+        from autotasks.serializers import TaskGOGetSerializer
+
+        r = self.client.get("/api/v3/500/asdf9df9dfdf/taskrunner/")
+        self.assertEqual(r.status_code, 404)
+
+        # setup data
+        agent = baker.make_recipe("agents.agent")
+        script = baker.make_recipe("scripts.script")
+        task = baker.make("autotasks.AutomatedTask", agent=agent, script=script)
+
+        url = f"/api/v3/{task.pk}/{agent.agent_id}/taskrunner/"  # type: ignore
+
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(TaskGOGetSerializer(task).data, r.data)  # type: ignore
 
     def test_task_runner_results(self):
         from agents.models import AgentCustomField
@@ -150,9 +195,8 @@ class TestAPIv3(TacticalTestCase):
         # setup data
         agent = baker.make_recipe("agents.agent")
         task = baker.make("autotasks.AutomatedTask", agent=agent)
-        task_result = baker.make("autotasks.TaskResult", agent=agent, task=task)
 
-        url = f"/api/v3/{task.pk}/{agent.agent_id}/taskrunner/"
+        url = f"/api/v3/{task.pk}/{agent.agent_id}/taskrunner/"  # type: ignore
 
         # test passing task
         data = {
@@ -164,9 +208,7 @@ class TestAPIv3(TacticalTestCase):
 
         r = self.client.patch(url, data)
         self.assertEqual(r.status_code, 200)
-        self.assertTrue(
-            TaskResult.objects.get(pk=task_result.pk).status == TaskStatus.PASSING
-        )
+        self.assertTrue(AutomatedTask.objects.get(pk=task.pk).status == "passing")  # type: ignore
 
         # test failing task
         data = {
@@ -178,33 +220,20 @@ class TestAPIv3(TacticalTestCase):
 
         r = self.client.patch(url, data)
         self.assertEqual(r.status_code, 200)
-        self.assertTrue(
-            TaskResult.objects.get(pk=task_result.pk).status == TaskStatus.FAILING
-        )
+        self.assertTrue(AutomatedTask.objects.get(pk=task.pk).status == "failing")  # type: ignore
 
         # test collector task
-        text = baker.make(
-            "core.CustomField",
-            model=CustomFieldModel.AGENT,
-            type=CustomFieldType.TEXT,
-            name="Test",
-        )
+        text = baker.make("core.CustomField", model="agent", type="text", name="Test")
         boolean = baker.make(
-            "core.CustomField",
-            model=CustomFieldModel.AGENT,
-            type=CustomFieldType.CHECKBOX,
-            name="Test1",
+            "core.CustomField", model="agent", type="checkbox", name="Test1"
         )
         multiple = baker.make(
-            "core.CustomField",
-            model=CustomFieldModel.AGENT,
-            type=CustomFieldType.MULTIPLE,
-            name="Test2",
+            "core.CustomField", model="agent", type="multiple", name="Test2"
         )
 
         # test text fields
-        task.custom_field = text
-        task.save()
+        task.custom_field = text  # type: ignore
+        task.save()  # type: ignore
 
         # test failing failing with stderr
         data = {
@@ -216,9 +245,7 @@ class TestAPIv3(TacticalTestCase):
 
         r = self.client.patch(url, data)
         self.assertEqual(r.status_code, 200)
-        self.assertTrue(
-            TaskResult.objects.get(pk=task_result.pk).status == TaskStatus.FAILING
-        )
+        self.assertTrue(AutomatedTask.objects.get(pk=task.pk).status == "failing")  # type: ignore
 
         # test saving to text field
         data = {
@@ -230,17 +257,12 @@ class TestAPIv3(TacticalTestCase):
 
         r = self.client.patch(url, data)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(
-            TaskResult.objects.get(pk=task_result.pk).status, TaskStatus.PASSING
-        )
-        self.assertEqual(
-            AgentCustomField.objects.get(field=text, agent=task.agent).value,
-            "the last line",
-        )
+        self.assertEqual(AutomatedTask.objects.get(pk=task.pk).status, "passing")  # type: ignore
+        self.assertEqual(AgentCustomField.objects.get(field=text, agent=task.agent).value, "the last line")  # type: ignore
 
         # test saving to checkbox field
-        task.custom_field = boolean
-        task.save()
+        task.custom_field = boolean  # type: ignore
+        task.save()  # type: ignore
 
         data = {
             "stdout": "1",
@@ -251,16 +273,12 @@ class TestAPIv3(TacticalTestCase):
 
         r = self.client.patch(url, data)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(
-            TaskResult.objects.get(pk=task_result.pk).status, TaskStatus.PASSING
-        )
-        self.assertTrue(
-            AgentCustomField.objects.get(field=boolean, agent=task.agent).value
-        )
+        self.assertEqual(AutomatedTask.objects.get(pk=task.pk).status, "passing")  # type: ignore
+        self.assertTrue(AgentCustomField.objects.get(field=boolean, agent=task.agent).value)  # type: ignore
 
         # test saving to multiple field with commas
-        task.custom_field = multiple
-        task.save()
+        task.custom_field = multiple  # type: ignore
+        task.save()  # type: ignore
 
         data = {
             "stdout": "this,is,an,array",
@@ -271,13 +289,8 @@ class TestAPIv3(TacticalTestCase):
 
         r = self.client.patch(url, data)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(
-            TaskResult.objects.get(pk=task_result.pk).status, TaskStatus.PASSING
-        )
-        self.assertEqual(
-            AgentCustomField.objects.get(field=multiple, agent=task.agent).value,
-            ["this", "is", "an", "array"],
-        )
+        self.assertEqual(AutomatedTask.objects.get(pk=task.pk).status, "passing")  # type: ignore
+        self.assertEqual(AgentCustomField.objects.get(field=multiple, agent=task.agent).value, ["this", "is", "an", "array"])  # type: ignore
 
         # test mutiple with a single value
         data = {
@@ -289,10 +302,5 @@ class TestAPIv3(TacticalTestCase):
 
         r = self.client.patch(url, data)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(
-            TaskResult.objects.get(pk=task_result.pk).status, TaskStatus.PASSING
-        )
-        self.assertEqual(
-            AgentCustomField.objects.get(field=multiple, agent=task.agent).value,
-            ["this"],
-        )
+        self.assertEqual(AutomatedTask.objects.get(pk=task.pk).status, "passing")  # type: ignore
+        self.assertEqual(AgentCustomField.objects.get(field=multiple, agent=task.agent).value, ["this"])  # type: ignore

api/tacticalrmm/apiv3/urls.py

@@ -9,6 +9,7 @@ urlpatterns = [
     path("<str:agentid>/checkinterval/", views.CheckRunnerInterval.as_view()),
     path("<int:pk>/<str:agentid>/taskrunner/", views.TaskRunner.as_view()),
     path("meshexe/", views.MeshExe.as_view()),
+    path("sysinfo/", views.SysInfo.as_view()),
     path("newagent/", views.NewAgent.as_view()),
     path("software/", views.Software.as_view()),
     path("installer/", views.Installer.as_view()),
@@ -18,5 +19,6 @@ urlpatterns = [
     path("winupdates/", views.WinUpdates.as_view()),
     path("superseded/", views.SupersededWinUpdate.as_view()),
     path("<int:pk>/chocoresult/", views.ChocoResult.as_view()),
+    path("<str:agentid>/recovery/", views.AgentRecovery.as_view()),
     path("<int:pk>/<str:agentid>/histresult/", views.AgentHistoryResult.as_view()),
 ]

api/tacticalrmm/apiv3/views.py

@@ -1,7 +1,9 @@
 import asyncio
+import os
+import time
 
 from django.conf import settings
-from django.db.models import Prefetch
+from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
 from django.utils import timezone as djangotime
 from packaging import version as pyver
@@ -14,34 +16,13 @@ from rest_framework.views import APIView
 from accounts.models import User
 from agents.models import Agent, AgentHistory
 from agents.serializers import AgentHistorySerializer
-from autotasks.models import AutomatedTask, TaskResult
-from autotasks.serializers import TaskGOGetSerializer, TaskResultSerializer
-from checks.constants import CHECK_DEFER, CHECK_RESULT_DEFER
-from checks.models import Check, CheckResult
+from autotasks.models import AutomatedTask
+from autotasks.serializers import TaskGOGetSerializer, TaskRunnerPatchSerializer
+from checks.models import Check
 from checks.serializers import CheckRunnerGetSerializer
-from core.utils import (
-    download_mesh_agent,
-    get_core_settings,
-    get_mesh_device_id,
-    get_mesh_ws_url,
-    get_meshagent_url,
-)
-from logs.models import DebugLog, PendingAction
+from logs.models import PendingAction, DebugLog
 from software.models import InstalledSoftware
-from tacticalrmm.constants import (
-    AGENT_DEFER,
-    AgentMonType,
-    AgentPlat,
-    AuditActionType,
-    AuditObjType,
-    CheckStatus,
-    DebugLogType,
-    GoArch,
-    MeshAgentIdent,
-    PAStatus,
-)
-from tacticalrmm.helpers import notify_error
-from tacticalrmm.utils import reload_nats
+from tacticalrmm.utils import notify_error, reload_nats
 from winupdate.models import WinUpdate, WinUpdatePolicy
 
 
@@ -52,12 +33,11 @@ class CheckIn(APIView):
 
     # called once during tacticalagent windows service startup
     def post(self, request):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
         if not agent.choco_installed:
             asyncio.run(agent.nats_cmd({"func": "installchoco"}, wait=False))
 
+        time.sleep(0.5)
         asyncio.run(agent.nats_cmd({"func": "getwinupdates"}, wait=False))
         return Response("ok")
 
@@ -67,9 +47,7 @@ class SyncMeshNodeID(APIView):
     permission_classes = [IsAuthenticated]
 
     def post(self, request):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
         if agent.mesh_node_id != request.data["nodeid"]:
             agent.mesh_node_id = request.data["nodeid"]
             agent.save(update_fields=["mesh_node_id"])
@@ -82,9 +60,7 @@ class Choco(APIView):
     permission_classes = [IsAuthenticated]
 
     def post(self, request):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
         agent.choco_installed = request.data["installed"]
         agent.save(update_fields=["choco_installed"])
         return Response("ok")
@@ -95,9 +71,7 @@ class WinUpdates(APIView):
     permission_classes = [IsAuthenticated]
 
     def put(self, request):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
 
         needs_reboot: bool = request.data["needs_reboot"]
         agent.needs_reboot = needs_reboot
@@ -115,7 +89,7 @@ class WinUpdates(APIView):
             asyncio.run(agent.nats_cmd({"func": "rebootnow"}, wait=False))
             DebugLog.info(
                 agent=agent,
-                log_type=DebugLogType.WIN_UPDATES,
+                log_type="windows_updates",
                 message=f"{agent.hostname} is rebooting after updates were installed.",
             )
 
@@ -123,13 +97,8 @@ class WinUpdates(APIView):
         return Response("ok")
 
     def patch(self, request):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
         u = agent.winupdates.filter(guid=request.data["guid"]).last()  # type: ignore
-        if not u:
-            raise WinUpdate.DoesNotExist
-
         success: bool = request.data["success"]
         if success:
             u.result = "success"
@@ -152,14 +121,8 @@ class WinUpdates(APIView):
         return Response("ok")
 
     def post(self, request):
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
         updates = request.data["wua_updates"]
-        if not updates:
-            return notify_error("Empty payload")
-
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
-
         for update in updates:
             if agent.winupdates.filter(guid=update["guid"]).exists():  # type: ignore
                 u = agent.winupdates.filter(guid=update["guid"]).last()  # type: ignore
@@ -198,9 +161,7 @@ class SupersededWinUpdate(APIView):
     permission_classes = [IsAuthenticated]
 
     def post(self, request):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
         updates = agent.winupdates.filter(guid=request.data["guid"])  # type: ignore
         for u in updates:
             u.delete()
@@ -213,19 +174,12 @@ class RunChecks(APIView):
     permission_classes = [IsAuthenticated]
 
     def get(self, request, agentid):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER).prefetch_related(
-                Prefetch("agentchecks", queryset=Check.objects.select_related("script"))
-            ),
-            agent_id=agentid,
-        )
-        checks = agent.get_checks_with_policies(exclude_overridden=True)
+        agent = get_object_or_404(Agent, agent_id=agentid)
+        checks = Check.objects.filter(agent__pk=agent.pk, overriden_by_policy=False)
         ret = {
             "agent": agent.pk,
             "check_interval": agent.check_interval,
-            "checks": CheckRunnerGetSerializer(
-                checks, context={"agent": agent}, many=True
-            ).data,
+            "checks": CheckRunnerGetSerializer(checks, many=True).data,
         }
         return Response(ret)
 
@@ -235,72 +189,45 @@ class CheckRunner(APIView):
     permission_classes = [IsAuthenticated]
 
     def get(self, request, agentid):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER).prefetch_related(
-                Prefetch("agentchecks", queryset=Check.objects.select_related("script"))
-            ),
-            agent_id=agentid,
-        )
-        checks = agent.get_checks_with_policies(exclude_overridden=True)
+        agent = get_object_or_404(Agent, agent_id=agentid)
+        checks = agent.agentchecks.filter(overriden_by_policy=False)  # type: ignore
 
         run_list = [
             check
             for check in checks
             # always run if check hasn't run yet
-            if not isinstance(check.check_result, CheckResult)
-            or not check.check_result.last_run
-            # see if the correct amount of seconds have passed
+            if not check.last_run
+            # if a check interval is set, see if the correct amount of seconds have passed
             or (
-                check.check_result.last_run
-                < djangotime.now()
-                - djangotime.timedelta(
-                    seconds=check.run_interval
-                    if check.run_interval
-                    else agent.check_interval
+                check.run_interval
+                and (
+                    check.last_run
+                    < djangotime.now()
+                    - djangotime.timedelta(seconds=check.run_interval)
                 )
             )
+            # if check interval isn't set, make sure the agent's check interval has passed before running
+            or (
+                not check.run_interval
+                and check.last_run
+                < djangotime.now() - djangotime.timedelta(seconds=agent.check_interval)
+            )
         ]
-
         ret = {
             "agent": agent.pk,
             "check_interval": agent.check_run_interval(),
-            "checks": CheckRunnerGetSerializer(
-                run_list, context={"agent": agent}, many=True
-            ).data,
+            "checks": CheckRunnerGetSerializer(run_list, many=True).data,
         }
         return Response(ret)
 
     def patch(self, request):
-        if "agent_id" not in request.data.keys():
-            return notify_error("Agent upgrade required")
+        check = get_object_or_404(Check, pk=request.data["id"])
 
-        check = get_object_or_404(
-            Check.objects.defer(*CHECK_DEFER),
-            pk=request.data["id"],
-        )
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER), agent_id=request.data["agent_id"]
-        )
-
-        # get check result or create if doesn't exist
-        check_result, created = CheckResult.objects.defer(
-            *CHECK_RESULT_DEFER
-        ).get_or_create(
-            assigned_check=check,
-            agent=agent,
-        )
-
-        if created:
-            check_result.save()
-
-        status = check_result.handle_check(request.data, check, agent)
-        if status == CheckStatus.FAILING and check.assignedtasks.exists():
-            for task in check.assignedtasks.all():
-                if task.enabled:
-                    if task.policy:
-                        task.run_win_task(agent)
-                    else:
-                        task.run_win_task()
+        check.last_run = djangotime.now()
+        check.save(update_fields=["last_run"])
+        status = check.handle_check(request.data)
+        if status == "failing" and check.assignedtask.exists():  # type: ignore
+            check.handle_assigned_task()
 
         return Response("ok")
 
@@ -310,10 +237,7 @@ class CheckRunnerInterval(APIView):
     permission_classes = [IsAuthenticated]
 
     def get(self, request, agentid):
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER).prefetch_related("agentchecks"),
-            agent_id=agentid,
-        )
+        agent = get_object_or_404(Agent, agent_id=agentid)
 
         return Response(
             {"agent": agent.pk, "check_interval": agent.check_run_interval()}
@@ -325,71 +249,65 @@ class TaskRunner(APIView):
     permission_classes = [IsAuthenticated]
 
     def get(self, request, pk, agentid):
-        agent = get_object_or_404(Agent.objects.defer(*AGENT_DEFER), agent_id=agentid)
+        _ = get_object_or_404(Agent, agent_id=agentid)
         task = get_object_or_404(AutomatedTask, pk=pk)
-        return Response(TaskGOGetSerializer(task, context={"agent": agent}).data)
+        return Response(TaskGOGetSerializer(task).data)
 
     def patch(self, request, pk, agentid):
         from alerts.models import Alert
 
-        agent = get_object_or_404(
-            Agent.objects.defer(*AGENT_DEFER),
-            agent_id=agentid,
-        )
-        task = get_object_or_404(
-            AutomatedTask.objects.select_related("custom_field"), pk=pk
-        )
-
-        # get task result or create if doesn't exist
-        try:
-            task_result = (
-                TaskResult.objects.select_related("agent")
-                .defer("agent__services", "agent__wmi_detail")
-                .get(task=task, agent=agent)
-            )
-            serializer = TaskResultSerializer(
-                data=request.data, instance=task_result, partial=True
-            )
-        except TaskResult.DoesNotExist:
-            serializer = TaskResultSerializer(data=request.data, partial=True)
+        agent = get_object_or_404(Agent, agent_id=agentid)
+        task = get_object_or_404(AutomatedTask, pk=pk)
 
+        serializer = TaskRunnerPatchSerializer(
+            instance=task, data=request.data, partial=True
+        )
         serializer.is_valid(raise_exception=True)
-        task_result = serializer.save(last_run=djangotime.now())
+        new_task = serializer.save(last_run=djangotime.now())
 
         AgentHistory.objects.create(
             agent=agent,
-            type=AuditActionType.TASK_RUN,
-            command=task.name,
+            type="task_run",
+            script=task.script,
             script_results=request.data,
         )
 
         # check if task is a collector and update the custom field
         if task.custom_field:
-            if not task_result.stderr:
+            if not task.stderr:
 
-                task_result.save_collector_results()
+                task.save_collector_results()
 
-                status = CheckStatus.PASSING
+                status = "passing"
             else:
-                status = CheckStatus.FAILING
+                status = "failing"
         else:
-            status = (
-                CheckStatus.FAILING if task_result.retcode != 0 else CheckStatus.PASSING
-            )
+            status = "failing" if task.retcode != 0 else "passing"
 
-        if task_result:
-            task_result.status = status
-            task_result.save(update_fields=["status"])
+        new_task.status = status
+        new_task.save()
+
+        if status == "passing":
+            if Alert.objects.filter(assigned_task=new_task, resolved=False).exists():
+                Alert.handle_alert_resolve(new_task)
         else:
-            task_result.status = status
-            task.save(update_fields=["status"])
+            Alert.handle_alert_failure(new_task)
 
-        if status == CheckStatus.PASSING:
-            if Alert.create_or_return_task_alert(task, agent=agent, skip_create=True):
-                Alert.handle_alert_resolve(task_result)
-        else:
-            Alert.handle_alert_failure(task_result)
+        return Response("ok")
 
+
+class SysInfo(APIView):
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [IsAuthenticated]
+
+    def patch(self, request):
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
+
+        if not isinstance(request.data["sysinfo"], dict):
+            return notify_error("err")
+
+        agent.wmi_detail = request.data["sysinfo"]
+        agent.save(update_fields=["wmi_detail"])
         return Response("ok")
 
 
@@ -397,40 +315,25 @@ class MeshExe(APIView):
     """Sends the mesh exe to the installer"""
 
     def post(self, request):
-        match request.data:
-            case {"goarch": GoArch.AMD64, "plat": AgentPlat.WINDOWS}:
-                ident = MeshAgentIdent.WIN64
-            case {"goarch": GoArch.i386, "plat": AgentPlat.WINDOWS}:
-                ident = MeshAgentIdent.WIN32
-            case {"goarch": GoArch.AMD64, "plat": AgentPlat.DARWIN} | {
-                "goarch": GoArch.ARM64,
-                "plat": AgentPlat.DARWIN,
-            }:
-                ident = MeshAgentIdent.DARWIN_UNIVERSAL
-            case _:
-                return notify_error("Arch not supported")
+        exe = "meshagent.exe" if request.data["arch"] == "64" else "meshagent-x86.exe"
+        mesh_exe = os.path.join(settings.EXE_DIR, exe)
 
-        core = get_core_settings()
+        if not os.path.exists(mesh_exe):
+            return notify_error("Mesh Agent executable not found")
 
-        try:
-            uri = get_mesh_ws_url()
-            mesh_device_id: str = asyncio.run(
-                get_mesh_device_id(uri, core.mesh_device_group)
-            )
-        except:
-            return notify_error("Unable to connect to mesh to get group id information")
-
-        dl_url = get_meshagent_url(
-            ident=ident,
-            plat=request.data["plat"],
-            mesh_site=core.mesh_site,
-            mesh_device_id=mesh_device_id,
-        )
-
-        try:
-            return download_mesh_agent(dl_url)
-        except:
-            return notify_error("Unable to download mesh agent exe")
+        if settings.DEBUG:
+            with open(mesh_exe, "rb") as f:
+                response = HttpResponse(
+                    f.read(),
+                    content_type="application/vnd.microsoft.portable-executable",
+                )
+                response["Content-Disposition"] = f"inline; filename={exe}"
+                return response
+        else:
+            response = HttpResponse()
+            response["Content-Disposition"] = f"attachment; filename={exe}"
+            response["X-Accel-Redirect"] = f"/private/exe/{exe}"
+            return response
 
 
 class NewAgent(APIView):
@@ -451,11 +354,11 @@ class NewAgent(APIView):
             monitoring_type=request.data["monitoring_type"],
             description=request.data["description"],
             mesh_node_id=request.data["mesh_node_id"],
-            goarch=request.data["goarch"],
-            plat=request.data["plat"],
             last_seen=djangotime.now(),
         )
         agent.save()
+        agent.salt_id = f"{agent.hostname}-{agent.pk}"
+        agent.save(update_fields=["salt_id"])
 
         user = User.objects.create_user(  # type: ignore
             username=request.data["agent_id"],
@@ -465,7 +368,7 @@ class NewAgent(APIView):
 
         token = Token.objects.create(user=user)
 
-        if agent.monitoring_type == AgentMonType.WORKSTATION:
+        if agent.monitoring_type == "workstation":
             WinUpdatePolicy(agent=agent, run_time_days=[5, 6]).save()
         else:
             WinUpdatePolicy(agent=agent).save()
@@ -476,15 +379,20 @@ class NewAgent(APIView):
         AuditLog.objects.create(
             username=request.user,
             agent=agent.hostname,
-            object_type=AuditObjType.AGENT,
-            action=AuditActionType.AGENT_INSTALL,
+            object_type="agent",
+            action="agent_install",
             message=f"{request.user} installed new agent {agent.hostname}",
             after_value=Agent.serialize(agent),
             debug_info={"ip": request._client_ip},
         )
 
-        ret = {"pk": agent.pk, "token": token.key}
-        return Response(ret)
+        return Response(
+            {
+                "pk": agent.pk,
+                "saltid": f"{agent.hostname}-{agent.pk}",
+                "token": token.key,
+            }
+        )
 
 
 class Software(APIView):
@@ -514,10 +422,7 @@ class Installer(APIView):
             return notify_error("Invalid data")
 
         ver = request.data["version"]
-        if (
-            pyver.parse(ver) < pyver.parse(settings.LATEST_AGENT_VER)
-            and not "-dev" in settings.LATEST_AGENT_VER
-        ):
+        if pyver.parse(ver) < pyver.parse(settings.LATEST_AGENT_VER):
             return notify_error(
                 f"Old installer detected (version {ver} ). Latest version is {settings.LATEST_AGENT_VER} Please generate a new installer from the RMM"
             )
@@ -552,19 +457,53 @@ class ChocoResult(APIView):
 
         action.details["output"] = results
         action.details["installed"] = installed
-        action.status = PAStatus.COMPLETED
+        action.status = "completed"
         action.save(update_fields=["details", "status"])
         return Response("ok")
 
 
+class AgentRecovery(APIView):
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request, agentid):
+        agent = get_object_or_404(
+            Agent.objects.prefetch_related("recoveryactions").only(
+                "pk", "agent_id", "last_seen"
+            ),
+            agent_id=agentid,
+        )
+
+        # TODO remove these 2 lines after agent v1.7.0 has been out for a while
+        # this is handled now by nats-api service
+        agent.last_seen = djangotime.now()
+        agent.save(update_fields=["last_seen"])
+
+        recovery = agent.recoveryactions.filter(last_run=None).last()  # type: ignore
+        ret = {"mode": "pass", "shellcmd": ""}
+        if recovery is None:
+            return Response(ret)
+
+        recovery.last_run = djangotime.now()
+        recovery.save(update_fields=["last_run"])
+
+        ret["mode"] = recovery.mode
+
+        if recovery.mode == "command":
+            ret["shellcmd"] = recovery.command
+        elif recovery.mode == "rpc":
+            reload_nats()
+
+        return Response(ret)
+
+
 class AgentHistoryResult(APIView):
     authentication_classes = [TokenAuthentication]
     permission_classes = [IsAuthenticated]
 
     def patch(self, request, agentid, pk):
-        hist = get_object_or_404(
-            AgentHistory.objects.filter(agent__agent_id=agentid), pk=pk
-        )
+        _ = get_object_or_404(Agent, agent_id=agentid)
+        hist = get_object_or_404(AgentHistory, pk=pk)
         s = AgentHistorySerializer(instance=hist, data=request.data, partial=True)
         s.is_valid(raise_exception=True)
         s.save()