fmt: more clippy that got missed

Reviewed-on: Skynet/discord-bot#24

.forgejo/workflows/push.yaml

@@ -0,0 +1,55 @@
+name: On_Push
+
+on:
+  push:
+    branches:
+      - 'main'
+    paths:
+      - flake.*
+      - src/**/*
+      - Cargo.*
+      - .forgejo/**/*
+      - rust-toolchain.toml
+
+jobs:
+  # rust code must be formatted for standardisation
+  lint_fmt:
+    # build it using teh base nixos system, helps with caching
+    runs-on: nix
+    steps:
+      # get the repo first
+      - uses: https://code.forgejo.org/actions/checkout@v4
+      - run: nix build .#fmt --verbose
+
+  # clippy is incredibly useful for making yer code better
+  lint_clippy:
+    # build it using teh base nixos system, helps with caching
+    runs-on: nix
+    permissions:
+      checks: write
+    steps:
+      # get the repo first
+      - uses: https://code.forgejo.org/actions/checkout@v4
+      - run: nix build .#clippy --verbose
+  
+  build:
+    # build it using teh base nixos system, helps with caching
+    runs-on: nix
+    needs: [ lint_fmt, lint_clippy ]
+    steps:
+      # get the repo first
+      - uses: https://code.forgejo.org/actions/checkout@v4
+      - name: "Build it locally"
+        run: nix build --verbose
+
+  # deploy it upstream
+  deploy:
+    # runs on teh default docker container
+    runs-on: docker
+    needs: [ build ]
+    steps:
+      - name: "Deploy to Skynet"
+        uses: https://forgejo.skynet.ie/Skynet/actions-deploy-to-skynet@v2
+        with:
+          input: 'skynet_discord_bot'
+          token: ${{ secrets.API_TOKEN_FORGEJO }}

.gitignore

@@ -2,11 +2,13 @@
 /.idea
 
 .env
+*.env
 
 result
 /result
 
 *.db
+*.db.*
 
 tmp/
 tmp.*

.gitlab-ci.yml

@@ -1,86 +0,0 @@
-# copied a good chunk from my bfom config
-image: rust:latest
-
-stages:
-  - lint
-  - build
-  - deploy
-
-cache:
-  key: "$CI_JOB_NAME"
-  paths:
-    - target/
-
-# Set any required environment variables here
-variables:
-  RUST_BACKTRACE: FULL
-
-
-# clippy and fmt are magic
-# runs on all commits/branches
-lint-clippy:
-  stage: lint
-  script:
-    - rustup component add clippy
-    - rustc --version
-    - cargo version
-    - cargo clippy
-  rules:
-    - if: $CI_COMMIT_TAG
-      when: never
-    - changes:
-        - src/**/*
-        - cargo.*
-      when: always
-
-lint-fmt:
-  stage: lint
-  script:
-    - rustup component add rustfmt
-    - rustc --version
-    - cargo version
-    - cargo fmt -- --check
-  rules:
-    - if: $CI_COMMIT_TAG
-      when: never
-    - changes:
-        - src/**/*
-        - cargo.*
-      when: always
-
-
-# has to actually compile
-build:
-  stage: build
-  script:
-    - rustc --version
-    - cargo version
-    - cargo build --verbose
-    - RUST_BACKTRACE=1 cargo test --verbose
-  rules:
-    - if: $CI_COMMIT_TAG
-      when: never
-    - changes:
-        - src/**/*
-        - cargo.*
-      when: on_success
-
-
-# from https://docs.gitlab.com/ee/ci/pipelines/multi_project_pipelines.html
-# so simple to deploy now
-nixos:
-  stage: deploy
-  variables:
-    PACKAGE_NAME: "skynet_discord_bot"
-    UPDATE_FLAKE: "yes"
-  trigger: compsoc1/skynet/nixos
-  rules:
-    - if: $CI_COMMIT_TAG
-      when: never
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-      when: on_success
-
-
-
-
-

Cargo.toml

@@ -11,7 +11,11 @@ name = "update_data"
 [[bin]]
 name = "update_users"
 
+[[bin]]
+name = "update_minecraft"
+
 [dependencies]
+# discord library
 serenity = { version = "0.11.6", default-features = false, features = ["client", "gateway", "rustls_backend", "model", "cache"] }
 tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
 
@@ -21,7 +25,7 @@ surf = "2.3.2"
 dotenvy = "0.15.7"
 
 # For sqlite
-sqlx = { version = "0.7.1", features = [ "runtime-tokio", "sqlite" ] }
+sqlx = { version = "0.7.1", features = [ "runtime-tokio", "sqlite", "migrate" ] }
 
 # create random strings
 rand = "0.8.5"

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Skynet
+
+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.

README.md

@@ -0,0 +1,70 @@
+# Skynet Discord Bot
+This bots core purpose is to give members roles based on their status on <ulwolves.ie>.  
+It uses an api key provided by wolves to get member lists.  
+
+Users are able to link their wolves account to the bot and that works across discord servers.  
+For example is a user links on the CompSoc Discord then they will also get their roles (automagically) on Games Dev if they are a member there.
+
+## Commands - Admin
+
+You need admin access to run any of the commands in this section.  
+Either the server owner or a suer with the ``Administrator`` permission 
+
+### Getting the Skynet Discord bot
+1. Email ``keith@assurememberships.com`` from committee email and say ye want an api key for ``193.1.99.74``
+2. Create a role for current members (maybe call it ``current-member`` ?)
+3. (Optional) create a role for all past and current members (ye can use the existing ``member`` role for this, )
+4. Invite the bot https://discord.com/api/oauth2/authorize?client_id=1145761669256069270&permissions=139855185984&scope=bot
+5. Make sure the bot role ``@skynet`` is above these two roles (so it can manage them)
+6. Make sure that you have a role that gives ye administrator powers
+7. Use the command ``/add`` and insert the api key, role current and role all (desktop recommended)
+
+The reason for both roles is ye have one for active members while the second is for all current and past members.
+
+### Minecraft
+The bot is able to manage the whitelist of a Minecraft server managed by the Computer Society.  
+Talk to us to get a server.
+
+#### Add
+This links a minecraft server with your club/society.
+
+``/minecraft_add SERVER_ID``
+
+
+#### List
+List the servers linked to your club/society.  
+It is possible to have more than one minecraft server
+
+``/minecraft_list``
+
+#### Delete
+This unlinks a minecraft server from your club/society.
+
+``/minecraft_delete SERVER_ID``
+
+## Commands - User
+
+### Setup
+* Start the process using ``/link_wolves WOLVES_EMAIL`` 
+  * The email that is in the Contact Email here: <https://ulwolves.ie/memberships/profile>
+* An email will be sent to them that they need to verify using ``/verify CODE``
+* This will only have to be done once.
+
+* If the user is an active member on wolves
+  * If they are in any servers with teh Skynet Bot
+    * They will get relevant roles.
+  * If they Join a server with teh bot enabled.
+    * They will be granted the roles automatically
+* If the user is **not** an active member on wolves.
+  * If they have no Roles
+    * No change
+  * If they have Past Member Role
+    * No change
+  * If they have both Roles
+    * The current-member role will be removed from them
+    * Past Member role will remain unchanged
+
+### Minecraft
+Users can link their Minecraft username to grant them access to any servers where teh whitelist is managed by teh bot.
+
+``/link_minecraft MINECRAFT_USERNAME``

db/migrations/1_setup.sql

@@ -0,0 +1,38 @@
+-- setup initial tables 
+
+-- this handles the users "floating" account
+CREATE TABLE IF NOT EXISTS wolves (
+    id_wolves integer PRIMARY KEY,
+    email     text    not null,
+    discord   integer,
+    minecraft text
+);
+CREATE INDEX IF NOT EXISTS index_discord ON wolves (discord);
+
+-- used to verify the users email address
+CREATE TABLE IF NOT EXISTS wolves_verify (
+    discord     integer PRIMARY KEY,
+    email       text    not null,
+    auth_code   text    not null,
+    date_expiry text    not null
+);
+CREATE INDEX IF NOT EXISTS index_date_expiry ON wolves_verify (date_expiry);
+
+-- information on teh server the bot is registered on
+CREATE TABLE IF NOT EXISTS servers (
+    server          integer PRIMARY KEY,
+    wolves_api      text    not null,
+    role_past       integer,
+    role_current    integer,
+    member_past     integer DEFAULT 0,
+    member_current  integer DEFAULT 0
+);
+
+-- keep track of the members on the server
+CREATE TABLE IF NOT EXISTS server_members (
+    server    integer not null,
+    id_wolves integer not null,
+    expiry    text    not null,
+    PRIMARY KEY(server,id_wolves),
+    FOREIGN KEY (id_wolves) REFERENCES wolves (id_wolves)
+);

db/migrations/2_minecraft-server.sql

@@ -0,0 +1,3 @@
+-- add teh option to associate each discord server with a minecraft one managed by skynet
+ALTER TABLE servers
+ADD server_minecraft text; 

db/migrations/3_minecraft-server-migrate.sql

@@ -0,0 +1,18 @@
+-- Create the new table
+CREATE TABLE IF NOT EXISTS minecraft
+(
+    server_discord   integer not null,
+    server_minecraft text    not null,
+    PRIMARY KEY (server_discord, server_minecraft),
+    FOREIGN KEY (server_discord) REFERENCES servers (server)
+);
+
+-- Import in the data
+INSERT INTO minecraft (server_discord, server_minecraft)
+SELECT server, server_minecraft
+FROM servers
+where server_minecraft is not null;
+
+-- delete the col in teh server table
+ALTER TABLE servers
+    DROP COLUMN server_minecraft; 

db/migrations/4_committee-mk-i.sql

@@ -0,0 +1,7 @@
+-- temp table to allow folks to verify by committee email.
+CREATE TABLE IF NOT EXISTS committee (
+    discord     integer PRIMARY KEY,
+    email       text    not null,
+    auth_code   text    not null,
+    committee   integer DEFAULT 0
+);

db/migrations/5_welcome-message.sql

@@ -0,0 +1,5 @@
+-- temp table to allow folks to verify by committee email.
+-- delete the col in teh server table
+ALTER TABLE servers ADD COLUMN bot_channel_id integer DEFAULT 0;
+ALTER TABLE servers ADD COLUMN server_name text NOT NULL DEFAULT "";
+ALTER TABLE servers ADD COLUMN wolves_link text NOT NULL DEFAULT "";

db/migrations/6_role-adder.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS roles_adder (
+    server  integer not null,
+    role_a  integer not null,
+    role_b  integer not null,
+    role_c  integer not null,
+    PRIMARY KEY(server,role_a,role_b,role_c)
+);
+CREATE INDEX IF NOT EXISTS index_roles_adder_server ON roles_adder (server);
+CREATE INDEX IF NOT EXISTS index_roles_adder_from ON roles_adder (role_a,role_b);
+CREATE INDEX IF NOT EXISTS index_roles_adder_to ON roles_adder (role_c);
+CREATE INDEX IF NOT EXISTS index_roles_adder_search ON roles_adder (server,role_a,role_b);

example.env

@@ -0,0 +1,8 @@
+HOME="."
+DATABASE="database.db"
+DISCORD_TOKEN=""
+DISCORD_TOKEN_MINECRAFT=""
+EMAIL_SMTP=""
+EMAIL_USER=""
+EMAIL_PASS=""
+WOLVES_URL=""

flake.lock

@@ -5,11 +5,11 @@
         "nixpkgs": "nixpkgs"
       },
       "locked": {
-        "lastModified": 1692351612,
+        "lastModified": 1721727458,
-        "narHash": "sha256-KTGonidcdaLadRnv9KFgwSMh1ZbXoR/OBmPjeNMhFwU=",
+        "narHash": "sha256-r/xppY958gmZ4oTfLiHN0ZGuQ+RSTijDblVgVLFi1mw=",
         "owner": "nix-community",
         "repo": "naersk",
-        "rev": "78789c30d64dea2396c9da516bbcc8db3a475207",
+        "rev": "3fb418eaf352498f6b6c30592e3beb63df42ef11",
         "type": "github"
       },
       "original": {
@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1693060755,
+        "lastModified": 1723151389,
-        "narHash": "sha256-KNsbfqewEziFJEpPR0qvVz4rx0x6QXxw1CcunRhlFdk=",
+        "narHash": "sha256-9AVY0ReCmSGXHrlx78+1RrqcDgVSRhHUKDVV1LLBy28=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "c66ccfa00c643751da2fd9290e096ceaa30493fc",
+        "rev": "13fe00cb6c75461901f072ae62b5805baef9f8b2",
         "type": "github"
       },
       "original": {
@@ -34,16 +34,16 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1693087214,
+        "lastModified": 1722995383,
-        "narHash": "sha256-Kn1SSqRfPpqcI1MDy82JXrPT1WI8c03TA2F0xu6kS+4=",
+        "narHash": "sha256-UzuXo7ZM8ZK0SkWFhHocKkLSGQPHS4JxaE1jvVR4fUo=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f155f0cf4ea43c4e3c8918d2d327d44777b6cad4",
+        "rev": "957d95fc8b9bf1eb60d43f8d2eba352b71bbf2be",
         "type": "github"
       },
       "original": {
         "id": "nixpkgs",
-        "ref": "nixos-23.05",
+        "ref": "nixos-unstable",
         "type": "indirect"
       }
     },
@@ -74,11 +74,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1692799911,
+        "lastModified": 1710146030,
-        "narHash": "sha256-3eihraek4qL744EvQXsK1Ha6C3CR7nnT8X2qWap4RNk=",
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "f9e7cf818399d17d347f847525c5a5a8032e4e44",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
         "type": "github"
       },
       "original": {

flake.nix

@@ -2,203 +2,213 @@
   description = "Skynet Discord Bot";
 
   inputs = {
-    nixpkgs.url = "nixpkgs/nixos-23.05";
+    nixpkgs.url = "nixpkgs/nixos-unstable";
-    naersk.url  = "github:nix-community/naersk";
+    naersk.url = "github:nix-community/naersk";
-    utils.url   = "github:numtide/flake-utils";
+    utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = { self, nixpkgs, utils, naersk }: utils.lib.eachDefaultSystem (system: 
+  nixConfig = {
-    let
+    extra-substituters = "https://nix-cache.skynet.ie/skynet-cache";
-      pkgs            = nixpkgs.legacyPackages."${system}";
+    extra-trusted-public-keys = "skynet-cache:zMFLzcRZPhUpjXUy8SF8Cf7KGAZwo98SKrzeXvdWABo=";
-      naersk-lib      = naersk.lib."${system}";
+  };
-      package_name    = "skynet_discord_bot";
-      desc            = "Skynet Discord Bot";
-    in rec {
 
-      # `nix build`
+  outputs = {
-      packages."${package_name}" = naersk-lib.buildPackage {
+    self,
-        pname = "${package_name}";
+    nixpkgs,
-        root = ./.;
+    utils,
-        
+    naersk,
-        buildInputs = [
+  }:
-          pkgs.openssl
+    utils.lib.eachDefaultSystem (
-          pkgs.pkg-config
+      system: let
+        pkgs = (import nixpkgs) {inherit system;};
+        naersk' = pkgs.callPackage naersk {};
+        package_name = "skynet_discord_bot";
+        desc = "Skynet Discord Bot";
+        buildInputs = with pkgs; [
+          openssl
+          pkg-config
+          rustfmt
         ];
-      };
+      in rec {
-  
+        packages = {
-      defaultPackage = packages."${package_name}";
+          # For `nix build` & `nix run`:
-  
+          default = naersk'.buildPackage {
-      # `nix run`
+            pname = "${package_name}";
-      apps."${package_name}" = utils.lib.mkApp {
+            src = ./.;
-        drv = packages."${package_name}";
+            buildInputs = buildInputs;
-      };
-  
-      defaultApp = apps."${package_name}";
-  
-      # `nix develop`
-      devShell = pkgs.mkShell {
-        nativeBuildInputs = with pkgs; [ rustc cargo pkg-config openssl];
-      };
-      
-      nixosModule = { lib, pkgs, config, ... }: 
-        with lib; 
-        let
-          cfg = config.services."${package_name}";
-          # secret options are in the env file(s) loaded separately
-          environment_config = {
-            LDAP_API      = cfg.ldap;
-            SKYNET_SERVER = cfg.discord.server;
-            HOME          = cfg.home;
-            DATABASE      = "database.db";
           };
-      
+          # Run `nix build .#fmt` to run tests
-          service_name = script: lib.strings.sanitizeDerivationName("${cfg.user}@${script}");
+          fmt = naersk'.buildPackage {
-
+            src = ./.;
-          # oneshot scripts to run
+            mode = "fmt";
-          serviceGenerator = mapAttrs' (script: time: nameValuePair (service_name script) {
+            buildInputs = buildInputs;
-            description = "Service for ${desc} ${script}";
-            wantedBy    = [ ];
-            after       = [ "network-online.target" ];
-            environment = environment_config;
-            
-            serviceConfig = {
-              Type            = "oneshot";
-              User            = "${cfg.user}";
-              Group           = "${cfg.user}";
-              ExecStart       = "${self.defaultPackage."${system}"}/bin/${script}";
-              EnvironmentFile = [
-                "${cfg.env.ldap}"
-                "${cfg.env.discord}"
-                "${cfg.env.mail}"
-                "${cfg.env.wolves}"
-              ];
-            };
-          });
-          
-          # each timer will run the above service
-          timerGenerator = mapAttrs' (script: time: nameValuePair (service_name script) {
-            description = "Timer for ${desc} ${script}";
-            
-            wantedBy    = [ "timers.target" ];
-            partOf      = [ "${service_name script}.service" ];
-            timerConfig = {
-              OnCalendar  = time;
-              Unit        = "${service_name script}.service";
-              Persistent  = true;
-            };
-          });
-          
-          # modify these
-          scripts = {
-            # every 20 min
-            "update_data"   = "*:0,20,40";  
-            # groups are updated every hour, offset from teh ldap
-            "update_users" = "00:05:00";
           };
-          
+          # Run `nix build .#clippy` to lint code
-        in { 
+          clippy = naersk'.buildPackage {
-          options.services."${package_name}" = {
+            src = ./.;
-            enable = mkEnableOption "enable ${package_name}";
+            mode = "clippy";
-            
+            buildInputs = buildInputs;
-            env = {
-              ldap = mkOption rec {
-                type        = types.str;
-                description = "ENV file with LDAP_DISCORD_AUTH";
-              };
-              discord = mkOption rec {
-                type        = types.str;
-                description = "ENV file with DISCORD_TOKEN";
-              };
-              mail = mkOption rec {
-                type        = types.str;
-                description = "ENV file with EMAIL_SMTP, EMAIL_USER, EMAIL_PASS";
-              };
-              wolves = mkOption rec {
-                type        = types.str;
-                description = "Mail details, has WOLVES_URL, WOLVES_KEY";
-              };
-            };
-            
-            discord = {
-              server = mkOption rec {
-                type        = types.str;
-                description = "ID of the server the bot runs on";
-              };
-            };
-            
-            ldap = mkOption rec {
-              type        = types.str;
-              default     = "https://api.account.skynet.ie";
-              description = "Location of the ldap api";
-            };
-            
-            user = mkOption rec {
-              type        = types.str;
-              default     = "${package_name}";
-              description = "The user to run the service";
-            };
-            
-            home = mkOption rec {
-              type        = types.str;
-              default     = "/etc/${cfg.prefix}${package_name}";
-              description = "The home for the user";
-            };
-            
-            prefix = mkOption rec {
-              type = types.str;
-              default = "skynet_";
-              example = default;
-              description = "The prefix used to name service/folders";
-            };
           };
+        };
 
-          config = mkIf cfg.enable {
+        defaultPackage = packages.default;
 
-            users.groups."${cfg.user}" = { };
+        # `nix run`
+        apps."${package_name}" = utils.lib.mkApp {
+          drv = packages."${package_name}";
+        };
 
-            users.users."${cfg.user}" = {
+        defaultApp = apps."${package_name}";
-              createHome    = true;
+
-              isSystemUser  = true;
+        # `nix develop`
-              home          = "${cfg.home}";
+        devShell = pkgs.mkShell {
-              group         = "${cfg.user}";
+          nativeBuildInputs = with pkgs; [rustc cargo pkg-config openssl rustfmt];
+        };
+
+        nixosModule = {
+          lib,
+          pkgs,
+          config,
+          ...
+        }:
+          with lib; let
+            cfg = config.services."${package_name}";
+            # secret options are in the env file(s) loaded separately
+            environment_config = {
+              DATABASE_HOME = cfg.home;
+              DATABASE = "database.db";
             };
 
-            systemd.services = {
+            service_name = script: lib.strings.sanitizeDerivationName "${cfg.user}@${script}";
-              # main service
+
-              "${package_name}" = {
+            # oneshot scripts to run
-                description = desc;
+            serviceGenerator = mapAttrs' (script: time:
-                wantedBy    = [ "multi-user.target" ];
+              nameValuePair (service_name script) {
-                after       = [ "network-online.target" ];
+                description = "Service for ${desc} ${script}";
-                wants       = [ ];
+                wantedBy = [];
+                after = ["network-online.target"];
                 environment = environment_config;
 
                 serviceConfig = {
-                  User            = "${cfg.user}";
+                  Type = "oneshot";
-                  Group           = "${cfg.user}";
+                  User = "${cfg.user}";
-                  Restart         = "always";
+                  Group = "${cfg.user}";
-                  ExecStart       = "${self.defaultPackage."${system}"}/bin/${package_name}";
+                  ExecStart = "${self.defaultPackage."${system}"}/bin/${script}";
-                  # can have multiple env files
                   EnvironmentFile = [
-                    "${cfg.env.ldap}" 
                     "${cfg.env.discord}"
                     "${cfg.env.mail}"
                     "${cfg.env.wolves}"
                   ];
                 };
-                restartTriggers = [
+              });
-                  "${cfg.env.ldap}"
+
-                  "${cfg.env.discord}"
+            # each timer will run the above service
-                  "${cfg.env.mail}"
+            timerGenerator = mapAttrs' (script: time:
-                  "${cfg.env.wolves}"
+              nameValuePair (service_name script) {
-                ];
+                description = "Timer for ${desc} ${script}";
+
+                wantedBy = ["timers.target"];
+                partOf = ["${service_name script}.service"];
+                timerConfig = {
+                  OnCalendar = time;
+                  Unit = "${service_name script}.service";
+                  Persistent = true;
+                };
+              });
+
+            # modify these
+            scripts = {
+              # every 20 min
+              "update_data" = "*:0,20,40";
+              # groups are updated every hour, offset from teh ldap
+              "update_users" = "*:05:00";
+              # minecraft stuff is updated at 5am
+              "update_minecraft" = "5:10:00";
+            };
+          in {
+            options.services."${package_name}" = {
+              enable = mkEnableOption "enable ${package_name}";
+
+              env = {
+                discord = mkOption rec {
+                  type = types.str;
+                  description = "ENV file with DISCORD_TOKEN, DISCORD_TOKEN_MINECRAFT";
+                };
+                mail = mkOption rec {
+                  type = types.str;
+                  description = "ENV file with EMAIL_SMTP, EMAIL_USER, EMAIL_PASS";
+                };
+                wolves = mkOption rec {
+                  type = types.str;
+                  description = "Mail details, has WOLVES_URL";
+                };
               };
-            } // serviceGenerator scripts;
 
-            # timers to run the above services
+              user = mkOption rec {
-            systemd.timers = timerGenerator scripts;
+                type = types.str;
+                default = "${package_name}";
+                description = "The user to run the service";
+              };
 
+              home = mkOption rec {
+                type = types.str;
+                default = "/etc/${cfg.prefix}${package_name}";
+                description = "The home for the user";
+              };
+
+              prefix = mkOption rec {
+                type = types.str;
+                default = "skynet_";
+                example = default;
+                description = "The prefix used to name service/folders";
+              };
+            };
+
+            config = mkIf cfg.enable {
+              users.groups."${cfg.user}" = {};
+
+              users.users."${cfg.user}" = {
+                createHome = true;
+                isSystemUser = true;
+                home = "${cfg.home}";
+                group = "${cfg.user}";
+              };
+
+              systemd.services =
+                {
+                  # main service
+                  "${package_name}" = {
+                    description = desc;
+                    wantedBy = ["multi-user.target"];
+                    after = ["network-online.target"];
+                    wants = [];
+                    environment = environment_config;
+
+                    serviceConfig = {
+                      User = "${cfg.user}";
+                      Group = "${cfg.user}";
+                      Restart = "always";
+                      ExecStart = "${self.defaultPackage."${system}"}/bin/${package_name}";
+                      # can have multiple env files
+                      EnvironmentFile = [
+                        "${cfg.env.discord}"
+                        "${cfg.env.mail}"
+                        "${cfg.env.wolves}"
+                      ];
+                    };
+                    restartTriggers = [
+                      "${cfg.env.discord}"
+                      "${cfg.env.mail}"
+                      "${cfg.env.wolves}"
+                    ];
+                  };
+                }
+                // serviceGenerator scripts;
+
+              # timers to run the above services
+              systemd.timers = timerGenerator scripts;
+            };
           };
-        };
+      }
-    }
+    );
-  );
 }

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "1.80"

src/bin/update_minecraft.rs

@@ -0,0 +1,25 @@
+use skynet_discord_bot::{db_init, get_config, get_minecraft_config, update_server, whitelist_wipe};
+use std::collections::HashSet;
+
+#[tokio::main]
+async fn main() {
+  let config = get_config();
+  let db = match db_init(&config).await {
+    Ok(x) => x,
+    Err(_) => return,
+  };
+
+  let servers = get_minecraft_config(&db).await;
+  let mut wiped = HashSet::new();
+
+  for server in &servers {
+    // wipe whitelist first
+    if !wiped.contains(&server.minecraft) {
+      whitelist_wipe(&server.minecraft, &config.discord_token_minecraft).await;
+      // add it to teh done list so its not done again
+      wiped.insert(&server.minecraft);
+    }
+
+    update_server(&server.minecraft, &db, &server.discord, &config).await;
+  }
+}

src/bin/update_users.rs

@@ -4,7 +4,7 @@ use serenity::{
   model::gateway::{GatewayIntents, Ready},
   Client,
 };
-use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, set_roles::update_server, Config, DataBase};
+use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, set_roles, Config, DataBase};
 use std::{process, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -59,6 +59,6 @@ async fn bulk_check(ctx: Arc<Context>) {
   let db = db_lock.read().await;
 
   for server_config in get_server_config_bulk(&db).await {
-    update_server(&ctx, &server_config, &[], &vec![]).await;
+    set_roles::update_server(&ctx, &server_config, &[], &[]).await;
   }
 }

src/commands/add_server.rs

@@ -7,46 +7,19 @@ use serenity::{
   },
 };
 use skynet_discord_bot::get_data::get_wolves;
-use skynet_discord_bot::{get_server_config, set_roles::update_server, DataBase, Servers};
+use skynet_discord_bot::{get_server_config, is_admin, set_roles::update_server, DataBase, Servers};
 use sqlx::{Error, Pool, Sqlite};
 
 pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
   // check if user has high enough permisssions
-  let mut admin = false;
+  if let Some(msg) = is_admin(command, ctx).await {
-
+    return msg;
-  let g_id = match command.guild_id {
-    None => return "Not in a server".to_string(),
-    Some(x) => x,
-  };
-
-  let roles_server = g_id.roles(&ctx.http).await.unwrap_or_default();
-
-  if let Ok(member) = g_id.member(&ctx.http, command.user.id).await {
-    if let Some(permissions) = member.permissions {
-      if permissions.administrator() {
-        admin = true;
-      }
-    }
-
-    for role_id in member.roles {
-      if admin {
-        break;
-      }
-      if let Some(role) = roles_server.get(&role_id) {
-        if role.permissions.administrator() {
-          admin = true;
-        }
-      }
-    }
-  }
-  if !admin {
-    return "Administrator permission required".to_string();
   }
 
   let api_key = if let CommandDataOptionValue::String(key) = command
     .data
     .options
-    .get(0)
+    .first()
     .expect("Expected user option")
     .resolved
     .as_ref()
@@ -66,18 +39,60 @@ pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> Stri
     .as_ref()
     .expect("Expected role object")
   {
-    Some(role.id.to_owned())
+    role.id.to_owned()
   } else {
     return "Please provide a valid role for ``Role Current``".to_string();
   };
 
   let mut role_past = None;
-  if let Some(x) = command.data.options.get(2) {
+  if let Some(x) = command.data.options.get(5) {
     if let Some(CommandDataOptionValue::Role(role)) = &x.resolved {
       role_past = Some(role.id.to_owned());
     }
   };
 
+  let bot_channel_id = if let CommandDataOptionValue::Channel(channel) = command
+    .data
+    .options
+    .get(2)
+    .expect("Expected channel option")
+    .resolved
+    .as_ref()
+    .expect("Expected channel object")
+  {
+    channel.id.to_owned()
+  } else {
+    return "Please provide a valid channel for ``Bot Channel``".to_string();
+  };
+
+  let server_name = if let CommandDataOptionValue::String(name) = command
+    .data
+    .options
+    .get(3)
+    .expect("Expected Server Name option")
+    .resolved
+    .as_ref()
+    .expect("Expected Server Name object")
+  {
+    name
+  } else {
+    &"UL Computer Society".to_string()
+  };
+
+  let wolves_link = if let CommandDataOptionValue::String(wolves) = command
+    .data
+    .options
+    .get(4)
+    .expect("Expected Wolves Link option")
+    .resolved
+    .as_ref()
+    .expect("Expected Server Name object")
+  {
+    wolves
+  } else {
+    &"https://ulwolves.ie/society/computer".to_string()
+  };
+
   let db_lock = {
     let data_read = ctx.data.read().await;
     data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
@@ -91,6 +106,9 @@ pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> Stri
     role_current,
     member_past: 0,
     member_current: 0,
+    bot_channel_id,
+    server_name: server_name.to_owned(),
+    wolves_link: wolves_link.to_string(),
   };
 
   match add_server(&db, ctx, &server_data).await {
@@ -122,6 +140,27 @@ pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicatio
         .kind(CommandOptionType::Role)
         .required(true)
     })
+    .create_option(|option| {
+      option
+        .name("bot_channel")
+        .description("Safe space for folks to use the bot commands.")
+        .kind(CommandOptionType::Channel)
+        .required(true)
+    })
+    .create_option(|option| {
+      option
+        .name("server_name")
+        .description("Name of the Discord Server.")
+        .kind(CommandOptionType::String)
+        .required(true)
+    })
+    .create_option(|option| {
+      option
+        .name("wolves_link")
+        .description("Link to the Club/Society on UL Wolves.")
+        .kind(CommandOptionType::String)
+        .required(true)
+    })
     .create_option(|option| {
       option
         .name("role_past")
@@ -134,18 +173,20 @@ pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicatio
 async fn add_server(db: &Pool<Sqlite>, ctx: &Context, server: &Servers) -> Result<Option<Servers>, Error> {
   let existing = get_server_config(db, &server.server).await;
   let role_past = server.role_past.map(|x| *x.as_u64() as i64);
-  let role_current = server.role_current.map(|x| *x.as_u64() as i64);
 
   let insert = sqlx::query_as::<_, Servers>(
     "
-      INSERT OR REPLACE INTO servers (server, wolves_api, role_past, role_current)
+      INSERT OR REPLACE INTO servers (server, wolves_api, role_past, role_current, bot_channel_id, server_name, wolves_link)
-      VALUES (?1, ?2, ?3, ?4)
+      VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
     ",
   )
   .bind(*server.server.as_u64() as i64)
   .bind(&server.wolves_api)
   .bind(role_past)
-  .bind(role_current)
+  .bind(*server.role_current.as_u64() as i64)
+  .bind(*server.bot_channel_id.as_u64() as i64)
+  .bind(&server.server_name)
+  .bind(&server.wolves_link)
   .fetch_optional(db)
   .await;
 
@@ -160,7 +201,7 @@ async fn add_server(db: &Pool<Sqlite>, ctx: &Context, server: &Servers) -> Resul
       if x.role_current != server.role_current {
         result.0 = true;
         result.1 = true;
-        result.2 = x.role_current;
+        result.2 = Some(x.role_current);
       }
       if x.role_past != server.role_past {
         result.0 = true;
@@ -183,7 +224,7 @@ async fn add_server(db: &Pool<Sqlite>, ctx: &Context, server: &Servers) -> Resul
     if past_remove {
       roles_remove.push(past_role)
     }
-    update_server(ctx, server, &roles_remove, &vec![]).await;
+    update_server(ctx, server, &roles_remove, &[]).await;
   }
 
   insert

src/commands/committee.rs

@@ -0,0 +1,311 @@
+use lettre::{
+  message::{header, MultiPart, SinglePart},
+  transport::smtp::{self, authentication::Credentials},
+  Message, SmtpTransport, Transport,
+};
+use maud::html;
+use serenity::{
+  builder::CreateApplicationCommand,
+  client::Context,
+  model::{
+    application::interaction::application_command::ApplicationCommandInteraction,
+    id::UserId,
+    prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
+  },
+};
+use skynet_discord_bot::{random_string, Config, DataBase};
+use sqlx::{Pool, Sqlite};
+
+pub mod link {
+  use super::*;
+  use serenity::model::id::GuildId;
+  use skynet_discord_bot::Committee;
+
+  pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+    let committee_server = GuildId(1220150752656363520);
+    match command.guild_id {
+      None => {
+        return "Not in correct discord server.".to_string();
+      }
+      Some(x) => {
+        if x != committee_server {
+          return "Not in correct discord server.".to_string();
+        }
+      }
+    }
+
+    let option = command
+      .data
+      .options
+      .first()
+      .expect("Expected email option")
+      .resolved
+      .as_ref()
+      .expect("Expected email object");
+
+    let email = if let CommandDataOptionValue::String(email) = option {
+      email.trim()
+    } else {
+      return "Please provide a valid committee email.".to_string();
+    };
+
+    // fail early
+    if !email.ends_with("@ulwolves.ie") {
+      return "Please use a @ulwolves.ie address you have access to.".to_string();
+    }
+
+    let db_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
+    };
+    let db = db_lock.read().await;
+
+    let config_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+    };
+    let config = config_lock.read().await;
+
+    if get_server_member_discord(&db, &command.user.id).await.is_some() {
+      return "Already linked".to_string();
+    }
+
+    if get_verify_from_db(&db, &command.user.id).await.is_some() {
+      return "Linking already in process, please check email.".to_string();
+    }
+
+    // generate a auth key
+    let auth = random_string(20);
+    match send_mail(&config, email, &auth, &command.user.name) {
+      Ok(_) => match save_to_db(&db, email, &auth, &command.user.id).await {
+        Ok(_) => {}
+        Err(e) => {
+          return format!("Unable to save to db {}  {e:?}", email);
+        }
+      },
+      Err(e) => {
+        return format!("Unable to send mail to {}  {e:?}", email);
+      }
+    }
+
+    format!("Verification email sent to {}, it may take up to 15 min for it to arrive. If it takes longer check the Junk folder.", email)
+  }
+
+  pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+    command
+      .name("link_committee")
+      .description("Verify you are a committee member")
+      .create_option(|option| {
+        option
+          .name("email")
+          .description("UL Wolves Committee Email")
+          .kind(CommandOptionType::String)
+          .required(true)
+      })
+  }
+
+  pub async fn get_server_member_discord(db: &Pool<Sqlite>, user: &UserId) -> Option<Committee> {
+    sqlx::query_as::<_, Committee>(
+      r#"
+      SELECT * 
+      FROM committee
+      WHERE discord = ?
+      "#,
+    )
+    .bind(*user.as_u64() as i64)
+    .fetch_one(db)
+    .await
+    .ok()
+  }
+
+  fn send_mail(config: &Config, mail: &str, auth: &str, user: &str) -> Result<smtp::response::Response, smtp::Error> {
+    let sender = format!("UL Computer Society <{}>", &config.mail_user);
+
+    // Create the html we want to send.
+    let html = html! {
+        head {
+            title { "Hello from Skynet!" }
+            style type="text/css" {
+                "h2, h4 { font-family: Arial, Helvetica, sans-serif; }"
+            }
+        }
+        div style="display: flex; flex-direction: column; align-items: center;" {
+            h2 { "Hello from Skynet!" }
+            // Substitute in the name of our recipient.
+            p { "Hi " (user) "," }
+            p {
+                "Please use " pre { "/verify_committee code: " (auth)} " to verify your discord account."
+            }
+            p {
+                "Skynet Team"
+                br;
+                "UL Computer Society"
+            }
+        }
+    };
+
+    let body_text = format!(
+      r#"
+        Hi {user}
+        
+        Please use "/verify_committee code: {auth}" to verify your discord account.
+        
+        Skynet Team
+        UL Computer Society
+        "#
+    );
+
+    // Build the message.
+    let email = Message::builder()
+      .from(sender.parse().unwrap())
+      .to(mail.parse().unwrap())
+      .subject("Skynet-Discord: Link Committee.")
+      .multipart(
+        // This is composed of two parts.
+        // also helps not trip spam settings (uneven number of url's
+        MultiPart::alternative()
+          .singlepart(SinglePart::builder().header(header::ContentType::TEXT_PLAIN).body(body_text))
+          .singlepart(SinglePart::builder().header(header::ContentType::TEXT_HTML).body(html.into_string())),
+      )
+      .expect("failed to build email");
+
+    let creds = Credentials::new(config.mail_user.clone(), config.mail_pass.clone());
+
+    // Open a remote connection to gmail using STARTTLS
+    let mailer = SmtpTransport::starttls_relay(&config.mail_smtp)?.credentials(creds).build();
+
+    // Send the email
+    mailer.send(&email)
+  }
+
+  pub async fn get_verify_from_db(db: &Pool<Sqlite>, user: &UserId) -> Option<Committee> {
+    sqlx::query_as::<_, Committee>(
+      r#"
+      SELECT * 
+      FROM committee
+      WHERE discord = ?
+      "#,
+    )
+    .bind(*user.as_u64() as i64)
+    .fetch_one(db)
+    .await
+    .ok()
+  }
+
+  async fn save_to_db(db: &Pool<Sqlite>, email: &str, auth: &str, user: &UserId) -> Result<Option<Committee>, sqlx::Error> {
+    sqlx::query_as::<_, Committee>(
+      "
+        INSERT INTO committee (email, discord, auth_code)
+        VALUES (?1, ?2, ?3)
+        ",
+    )
+    .bind(email.to_owned())
+    .bind(*user.as_u64() as i64)
+    .bind(auth.to_owned())
+    .fetch_optional(db)
+    .await
+  }
+}
+
+pub mod verify {
+  use super::*;
+  use crate::commands::committee::link::get_verify_from_db;
+  use serenity::model::id::{GuildId, RoleId};
+  use serenity::model::user::User;
+  use skynet_discord_bot::Committee;
+  use sqlx::Error;
+
+  pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+    let committee_server = GuildId(1220150752656363520);
+    match command.guild_id {
+      None => {
+        return "Not in correct discord server.".to_string();
+      }
+      Some(x) => {
+        if x != committee_server {
+          return "Not in correct discord server.".to_string();
+        }
+      }
+    }
+
+    let db_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<DataBase>().expect("Expected Database in TypeMap.").clone()
+    };
+    let db = db_lock.read().await;
+
+    // check if user has used /link_committee
+    let details = if let Some(x) = get_verify_from_db(&db, &command.user.id).await {
+      x
+    } else {
+      return "Please use /link_committee first".to_string();
+    };
+
+    let option = command
+      .data
+      .options
+      .first()
+      .expect("Expected code option")
+      .resolved
+      .as_ref()
+      .expect("Expected code object");
+
+    let code = if let CommandDataOptionValue::String(code) = option {
+      code
+    } else {
+      return "Please provide a verification code".to_string();
+    };
+
+    if &details.auth_code != code {
+      return "Invalid verification code".to_string();
+    }
+
+    match set_discord(&db, &command.user.id).await {
+      Ok(_) => {
+        // get teh right roles for the user
+        set_server_roles(&command.user, ctx).await;
+        "Discord username linked to Wolves for committee".to_string()
+      }
+      Err(e) => {
+        println!("{:?}", e);
+        "Failed to save, please try /link_committee again".to_string()
+      }
+    }
+  }
+
+  pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+    command
+      .name("verify_committee")
+      .description("Verify Wolves Committee Email")
+      .create_option(|option| {
+        option
+          .name("code")
+          .description("Code from verification email")
+          .kind(CommandOptionType::String)
+          .required(true)
+      })
+  }
+
+  async fn set_discord(db: &Pool<Sqlite>, discord: &UserId) -> Result<Option<Committee>, Error> {
+    sqlx::query_as::<_, Committee>(
+      "
+      UPDATE committee
+      SET committee = 1
+      WHERE discord = ?
+    ",
+    )
+    .bind(*discord.as_u64() as i64)
+    .fetch_optional(db)
+    .await
+  }
+
+  async fn set_server_roles(discord: &User, ctx: &Context) {
+    let committee_server = GuildId(1220150752656363520);
+    if let Ok(mut member) = committee_server.member(&ctx.http, &discord.id).await {
+      let committee_member = RoleId(1226602779968274573);
+      if let Err(e) = member.add_role(&ctx, committee_member).await {
+        println!("{:?}", e);
+      }
+    }
+  }
+}

src/commands/link_email.rs

@@ -15,7 +15,7 @@ use serenity::{
 };
 use skynet_discord_bot::{get_now_iso, random_string, Config, DataBase, Wolves, WolvesVerify};
 use sqlx::{Pool, Sqlite};
-pub(crate) mod link {
+pub mod link {
   use super::*;
 
   pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
@@ -44,7 +44,7 @@ pub(crate) mod link {
     let option = command
       .data
       .options
-      .get(0)
+      .first()
       .expect("Expected email option")
       .resolved
       .as_ref()
@@ -59,7 +59,7 @@ pub(crate) mod link {
     // check if email exists
     let details = match get_server_member_email(&db, email).await {
       None => {
-        return "Please check it is your preferred contact on https://ulwolves.ie/memberships/profile and that you are fully paid up.".to_string()
+        return "Please check it matches (including case) your preferred contact on https://ulwolves.ie/memberships/profile and that you are fully paid up.".to_string()
       }
       Some(x) => x,
     };
@@ -87,12 +87,12 @@ pub(crate) mod link {
 
   pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
     command
-      .name("link")
+      .name("link_wolves")
       .description("Set Wolves Email")
       .create_option(|option| option.name("email").description("UL Wolves Email").kind(CommandOptionType::String).required(true))
   }
 
-  async fn get_server_member_discord(db: &Pool<Sqlite>, user: &UserId) -> Option<Wolves> {
+  pub async fn get_server_member_discord(db: &Pool<Sqlite>, user: &UserId) -> Option<Wolves> {
     sqlx::query_as::<_, Wolves>(
       r#"
       SELECT * 
@@ -184,7 +184,7 @@ pub(crate) mod link {
     let creds = Credentials::new(config.mail_user.clone(), config.mail_pass.clone());
 
     // Open a remote connection to gmail using STARTTLS
-    let mailer = SmtpTransport::starttls_relay(&config.mail_smtp).unwrap().credentials(creds).build();
+    let mailer = SmtpTransport::starttls_relay(&config.mail_smtp)?.credentials(creds).build();
 
     // Send the email
     mailer.send(&email)
@@ -234,7 +234,7 @@ pub(crate) mod link {
   }
 }
 
-pub(crate) mod verify {
+pub mod verify {
   use super::*;
   use crate::commands::link_email::link::{db_pending_clear_expired, get_verify_from_db};
   use serenity::model::user::User;
@@ -248,17 +248,17 @@ pub(crate) mod verify {
     };
     let db = db_lock.read().await;
 
-    // check if user has used /link
+    // check if user has used /link_wolves
     let details = if let Some(x) = get_verify_from_db(&db, &command.user.id).await {
       x
     } else {
-      return "Please use /link first".to_string();
+      return "Please use /link_wolves first".to_string();
     };
 
     let option = command
       .data
       .options
-      .get(0)
+      .first()
       .expect("Expected code option")
       .resolved
       .as_ref()
@@ -286,7 +286,7 @@ pub(crate) mod verify {
           }
           Err(e) => {
             println!("{:?}", e);
-            "Failed to save, please try /link again".to_string()
+            "Failed to save, please try /link_wolves again".to_string()
           }
         };
       }
@@ -352,10 +352,8 @@ pub(crate) mod verify {
               }
             }
 
-            if let Some(role) = &role_current {
+            if !member.roles.contains(&role_current) {
-              if !member.roles.contains(role) {
+              roles.push(role_current.to_owned());
-                roles.push(role.to_owned());
-              }
             }
 
             if let Err(e) = member.add_roles(&ctx, &roles).await {

src/commands/minecraft.rs

@@ -0,0 +1,334 @@
+use serenity::{
+  builder::CreateApplicationCommand,
+  client::Context,
+  model::{
+    application::interaction::application_command::ApplicationCommandInteraction,
+    prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
+  },
+};
+
+use skynet_discord_bot::DataBase;
+use sqlx::{Pool, Sqlite};
+
+pub(crate) mod user {
+  use super::*;
+  pub(crate) mod add {
+    use super::*;
+    use crate::commands::link_email::link::get_server_member_discord;
+    use serenity::model::id::UserId;
+    use skynet_discord_bot::{whitelist_update, Config, Minecraft, Wolves};
+    use sqlx::Error;
+
+    pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+      command.name("link_minecraft").description("Link your minecraft account").create_option(|option| {
+        option
+          .name("minecraft-username")
+          .description("Your Minecraft username")
+          .kind(CommandOptionType::String)
+          .required(true)
+      })
+    }
+
+    pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+      let db_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
+      };
+      let db = db_lock.read().await;
+
+      let config_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+      };
+      let config = config_lock.read().await;
+
+      // user has to have previously linked with wolves
+      if get_server_member_discord(&db, &command.user.id).await.is_none() {
+        return "Not linked with wolves, please use ``/link_wolves`` with your wolves email.".to_string();
+      }
+
+      let username = if let CommandDataOptionValue::String(username) = command
+        .data
+        .options
+        .first()
+        .expect("Expected username option")
+        .resolved
+        .as_ref()
+        .expect("Expected username object")
+      {
+        username.trim()
+      } else {
+        return "Please provide a valid username".to_string();
+      };
+
+      // insert the username into the database
+      match add_minecraft(&db, &command.user.id, username).await {
+        Ok(_) => {}
+        Err(e) => {
+          dbg!("{:?}", e);
+          return format!("Failure to minecraft username {:?}", username);
+        }
+      }
+
+      // get a list of servers that the user is a member of
+      if let Ok(servers) = get_servers(&db, &command.user.id).await {
+        for server in servers {
+          whitelist_update(&vec![username.to_string()], &server.minecraft, &config.discord_token_minecraft).await;
+        }
+      }
+
+      "Added/Updated minecraft_user info".to_string()
+    }
+
+    async fn add_minecraft(db: &Pool<Sqlite>, user: &UserId, minecraft: &str) -> Result<Option<Wolves>, Error> {
+      sqlx::query_as::<_, Wolves>(
+        "
+      UPDATE wolves
+      SET minecraft = ?2
+      WHERE discord = ?1; 
+    ",
+      )
+      .bind(*user.as_u64() as i64)
+      .bind(minecraft)
+      .fetch_optional(db)
+      .await
+    }
+
+    async fn get_servers(db: &Pool<Sqlite>, discord: &UserId) -> Result<Vec<Minecraft>, Error> {
+      sqlx::query_as::<_, Minecraft>(
+        "
+      SELECT minecraft.*
+      FROM minecraft
+      JOIN (
+              SELECT server
+              FROM server_members
+              JOIN wolves USING (id_wolves)
+              WHERE discord = ?1
+      ) sub on minecraft.server_discord = sub.server
+    ",
+      )
+      .bind(*discord.as_u64() as i64)
+      .fetch_all(db)
+      .await
+    }
+  }
+}
+
+pub(crate) mod server {
+  use super::*;
+
+  pub(crate) mod add {
+    use serenity::model::id::GuildId;
+    use sqlx::Error;
+    // this is to managfe the server side of commands related to minecraft
+    use super::*;
+    use skynet_discord_bot::{is_admin, update_server, Config, Minecraft};
+
+    pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+      command.name("minecraft_add").description("Add a minecraft server").create_option(|option| {
+        option
+          .name("server_id")
+          .description("ID of the Minecraft server hosted by the Computer Society")
+          .kind(CommandOptionType::String)
+          .required(true)
+      })
+    }
+
+    pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+      // check if user has high enough permisssions
+      if let Some(msg) = is_admin(command, ctx).await {
+        return msg;
+      }
+      let g_id = match command.guild_id {
+        None => return "Not in a server".to_string(),
+        Some(x) => x,
+      };
+
+      let server_minecraft = if let CommandDataOptionValue::String(id) = command
+        .data
+        .options
+        .first()
+        .expect("Expected server_id option")
+        .resolved
+        .as_ref()
+        .expect("Expected server_id object")
+      {
+        id.to_owned()
+      } else {
+        return String::from("Expected Server ID");
+      };
+
+      let db_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
+      };
+      let db = db_lock.read().await;
+
+      match add_server(&db, &g_id, &server_minecraft).await {
+        Ok(_) => {}
+        Err(e) => {
+          println!("{:?}", e);
+          return format!("Failure to insert into Minecraft {} {}", &g_id, &server_minecraft);
+        }
+      }
+
+      let config_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+      };
+      let config = config_lock.read().await;
+
+      update_server(&server_minecraft, &db, &g_id, &config).await;
+
+      "Added/Updated minecraft_server info".to_string()
+    }
+
+    async fn add_server(db: &Pool<Sqlite>, discord: &GuildId, minecraft: &str) -> Result<Option<Minecraft>, Error> {
+      sqlx::query_as::<_, Minecraft>(
+        "
+      INSERT OR REPLACE INTO minecraft (server_discord, server_minecraft)
+      VALUES (?1, ?2)
+    ",
+      )
+      .bind(*discord.as_u64() as i64)
+      .bind(minecraft)
+      .fetch_optional(db)
+      .await
+    }
+  }
+
+  pub(crate) mod list {
+    use serenity::builder::CreateApplicationCommand;
+    use serenity::client::Context;
+    use serenity::model::prelude::application_command::ApplicationCommandInteraction;
+    use skynet_discord_bot::{get_minecraft_config_server, is_admin, server_information, Config, DataBase};
+
+    pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+      command.name("minecraft_list").description("List your minecraft servers")
+    }
+
+    pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+      if let Some(msg) = is_admin(command, ctx).await {
+        return msg;
+      }
+      let g_id = match command.guild_id {
+        None => return "Not in a server".to_string(),
+        Some(x) => x,
+      };
+
+      let db_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
+      };
+      let db = db_lock.read().await;
+
+      let servers = get_minecraft_config_server(&db, g_id).await;
+
+      if servers.is_empty() {
+        return "No minecraft servers, use /minecraft_add to add one".to_string();
+      }
+
+      let config_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+      };
+      let config = config_lock.read().await;
+
+      let mut result = "Server Information:\n".to_string();
+      for server in get_minecraft_config_server(&db, g_id).await {
+        if let Some(x) = server_information(&server.minecraft, &config.discord_token_minecraft).await {
+          result.push_str(&format!(
+            r#"
+            Name:   {name}
+            ID:     {id}
+            Online: {online}
+            Info:   {description} 
+            Link:   <http://panel.games.skynet.ie/server/{id}>
+            "#,
+            name = &x.attributes.name,
+            online = !x.attributes.is_suspended,
+            description = &x.attributes.description,
+            id = &x.attributes.identifier
+          ));
+        }
+      }
+      result.to_string()
+    }
+  }
+
+  pub(crate) mod delete {
+    use serenity::builder::CreateApplicationCommand;
+    use serenity::client::Context;
+    use serenity::model::application::command::CommandOptionType;
+    use serenity::model::id::GuildId;
+    use serenity::model::prelude::application_command::{ApplicationCommandInteraction, CommandDataOptionValue};
+    use skynet_discord_bot::{is_admin, DataBase, Minecraft};
+    use sqlx::{Error, Pool, Sqlite};
+
+    pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+      command.name("minecraft_delete").description("Delete a minecraft server").create_option(|option| {
+        option
+          .name("server_id")
+          .description("ID of the Minecraft server hosted by the Computer Society")
+          .kind(CommandOptionType::String)
+          .required(true)
+      })
+    }
+
+    pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+      // check if user has high enough permisssions
+      if let Some(msg) = is_admin(command, ctx).await {
+        return msg;
+      }
+      let g_id = match command.guild_id {
+        None => return "Not in a server".to_string(),
+        Some(x) => x,
+      };
+
+      let server_minecraft = if let CommandDataOptionValue::String(id) = command
+        .data
+        .options
+        .first()
+        .expect("Expected server_id option")
+        .resolved
+        .as_ref()
+        .expect("Expected server_id object")
+      {
+        id.to_owned()
+      } else {
+        return String::from("Expected Server ID");
+      };
+
+      let db_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
+      };
+      let db = db_lock.read().await;
+
+      match server_remove(&db, &g_id, &server_minecraft).await {
+        Ok(_) => {}
+        Err(e) => {
+          println!("{:?}", e);
+          return format!("Failure to insert into Minecraft {} {}", &g_id, &server_minecraft);
+        }
+      }
+
+      // no need to clear teh whitelist as it will be reset within 24hr anyways
+
+      "Removed minecraft_server info".to_string()
+    }
+
+    async fn server_remove(db: &Pool<Sqlite>, discord: &GuildId, minecraft: &str) -> Result<Option<Minecraft>, Error> {
+      sqlx::query_as::<_, Minecraft>(
+        "
+      DELETE FROM minecraft
+      WHERE server_discord = ?1 AND server_minecraft = ?2
+    ",
+      )
+      .bind(*discord.as_u64() as i64)
+      .bind(minecraft)
+      .fetch_optional(db)
+      .await
+    }
+  }
+}

src/commands/mod.rs

@@ -1,2 +1,5 @@
 pub mod add_server;
+pub mod committee;
 pub mod link_email;
+pub mod minecraft;
+pub mod role_adder;

src/commands/role_adder.rs

@@ -0,0 +1,238 @@
+use serenity::{
+  builder::CreateApplicationCommand,
+  client::Context,
+  model::{
+    application::interaction::application_command::ApplicationCommandInteraction,
+    prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
+  },
+};
+
+use skynet_discord_bot::{is_admin, DataBase, RoleAdder};
+use sqlx::{Error, Pool, Sqlite};
+
+pub mod edit {
+  use super::*;
+
+  pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+    // check if user has high enough permisssions
+    if let Some(msg) = is_admin(command, ctx).await {
+      return msg;
+    }
+
+    let role_a = if let CommandDataOptionValue::Role(role) = command
+      .data
+      .options
+      .first()
+      .expect("Expected role option")
+      .resolved
+      .as_ref()
+      .expect("Expected role object")
+    {
+      role.id.to_owned()
+    } else {
+      return "Please provide a valid role for ``Role Current``".to_string();
+    };
+
+    let role_b = if let CommandDataOptionValue::Role(role) = command
+      .data
+      .options
+      .get(1)
+      .expect("Expected role option")
+      .resolved
+      .as_ref()
+      .expect("Expected role object")
+    {
+      role.id.to_owned()
+    } else {
+      return "Please provide a valid role for ``Role Current``".to_string();
+    };
+
+    let role_c = if let CommandDataOptionValue::Role(role) = command
+      .data
+      .options
+      .get(2)
+      .expect("Expected role option")
+      .resolved
+      .as_ref()
+      .expect("Expected role object")
+    {
+      role.id.to_owned()
+    } else {
+      return "Please provide a valid role for ``Role Current``".to_string();
+    };
+
+    if role_a == role_b {
+      return "Roles A and B must be different".to_string();
+    }
+
+    if (role_c == role_a) || (role_c == role_b) {
+      return "Role C cannot be same as A or B".to_string();
+    }
+
+    let mut delete = false;
+
+    if let Some(x) = command.data.options.get(3) {
+      let tmp = x.to_owned();
+      if let Some(CommandDataOptionValue::Boolean(z)) = tmp.resolved {
+        delete = z;
+      }
+    }
+
+    let db_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
+    };
+    let db = db_lock.read().await;
+
+    let server = command.guild_id.unwrap_or_default();
+    let server_data = RoleAdder {
+      server,
+      role_a,
+      role_b,
+      role_c,
+    };
+
+    match add_server(&db, &server_data, delete).await {
+      Ok(_) => {}
+      Err(e) => {
+        println!("{:?}", e);
+        return format!("Failure to insert into Servers {:?}", server_data);
+      }
+    }
+
+    let mut role_a_name = String::new();
+    let mut role_b_name = String::new();
+    let mut role_c_name = String::new();
+
+    if let Ok(x) = server.roles(&ctx).await {
+      if let Some(y) = x.get(&role_a) {
+        role_a_name = y.to_owned().name;
+      }
+      if let Some(y) = x.get(&role_b) {
+        role_b_name = y.to_owned().name;
+      }
+      if let Some(y) = x.get(&role_b) {
+        role_c_name = y.to_owned().name;
+      }
+    }
+
+    if delete {
+      format!("Removed {} + {} = {}", role_a_name, role_b_name, role_c_name)
+    } else {
+      format!("Added {} + {} = {}", role_a_name, role_b_name, role_c_name)
+    }
+  }
+
+  pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+    command
+      .name("roles_adder")
+      .description("Combine roles together to an new one")
+      .create_option(|option| {
+        option
+          .name("role_a")
+          .description("A role you want to add to Role B")
+          .kind(CommandOptionType::Role)
+          .required(true)
+      })
+      .create_option(|option| {
+        option
+          .name("role_b")
+          .description("A role you want to add to Role A")
+          .kind(CommandOptionType::Role)
+          .required(true)
+      })
+      .create_option(|option| option.name("role_c").description("Sum of A and B").kind(CommandOptionType::Role).required(true))
+      .create_option(|option| {
+        option
+          .name("delete")
+          .description("Delete this entry.")
+          .kind(CommandOptionType::Boolean)
+          .required(false)
+      })
+  }
+
+  async fn add_server(db: &Pool<Sqlite>, server: &RoleAdder, delete: bool) -> Result<Option<RoleAdder>, Error> {
+    if delete {
+      sqlx::query_as::<_, RoleAdder>(
+        "
+      DELETE FROM roles_adder
+      WHERE server = ?1 AND role_a = ?2 AND role_b = ?3 AND role_c = ?4
+    ",
+      )
+      .bind(*server.server.as_u64() as i64)
+      .bind(*server.role_a.as_u64() as i64)
+      .bind(*server.role_b.as_u64() as i64)
+      .bind(*server.role_c.as_u64() as i64)
+      .fetch_optional(db)
+      .await
+    } else {
+      sqlx::query_as::<_, RoleAdder>(
+        "
+      INSERT OR REPLACE INTO roles_adder (server, role_a, role_b, role_c)
+      VALUES (?1, ?2, ?3, ?4)
+    ",
+      )
+      .bind(*server.server.as_u64() as i64)
+      .bind(*server.role_a.as_u64() as i64)
+      .bind(*server.role_b.as_u64() as i64)
+      .bind(*server.role_c.as_u64() as i64)
+      .fetch_optional(db)
+      .await
+    }
+  }
+}
+
+// TODO
+pub mod list {}
+
+pub mod tools {
+  use serenity::client::Context;
+  use serenity::model::guild::Member;
+  use skynet_discord_bot::RoleAdder;
+  use sqlx::{Pool, Sqlite};
+
+  pub async fn on_role_change(db: &Pool<Sqlite>, ctx: &Context, mut new_data: Member) {
+    // check if the role changed is part of the oens for this server
+    if let Ok(role_adders) = sqlx::query_as::<_, RoleAdder>(
+      r#"
+      SELECT *
+      FROM roles_adder
+      WHERE server = ?
+      "#,
+    )
+    .bind(*new_data.guild_id.as_u64() as i64)
+    .fetch_all(db)
+    .await
+    {
+      let mut roles_add = vec![];
+      let mut roles_remove = vec![];
+
+      for role_adder in role_adders {
+        // if the user has both A dnd B give them C
+        if new_data.roles.contains(&role_adder.role_a) && new_data.roles.contains(&role_adder.role_b) && !new_data.roles.contains(&role_adder.role_c)
+        {
+          roles_add.push(role_adder.role_c);
+        }
+
+        // If the suer has C but not A or B remove C
+        if new_data.roles.contains(&role_adder.role_c)
+          && (!new_data.roles.contains(&role_adder.role_a) || !new_data.roles.contains(&role_adder.role_b))
+        {
+          roles_remove.push(role_adder.role_c);
+        }
+      }
+
+      if !roles_add.is_empty() {
+        if let Err(e) = new_data.add_roles(&ctx, &roles_add).await {
+          println!("{:?}", e);
+        }
+      }
+
+      if !roles_remove.is_empty() {
+        if let Err(e) = new_data.remove_roles(&ctx, &roles_remove).await {
+          println!("{:?}", e);
+        }
+      }
+    }
+  }
+}

src/lib.rs

@@ -3,15 +3,18 @@ use serde::{Deserialize, Serialize};
 use serenity::{
   model::{
     guild,
-    id::{GuildId, RoleId},
+    id::{ChannelId, GuildId, RoleId},
   },
   prelude::TypeMapKey,
 };
 
+use crate::set_roles::get_server_member_bulk;
 use chrono::{Datelike, SecondsFormat, Utc};
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
+use serde::de::DeserializeOwned;
 use serenity::client::Context;
 use serenity::model::id::UserId;
+use serenity::model::prelude::application_command::ApplicationCommandInteraction;
 use sqlx::{
   sqlite::{SqliteConnectOptions, SqlitePoolOptions, SqliteRow},
   Error, FromRow, Pool, Row, Sqlite,
@@ -20,18 +23,20 @@ use std::{env, str::FromStr, sync::Arc};
 use tokio::sync::RwLock;
 
 pub struct Config {
-  pub skynet_server: GuildId,
+  // manages where teh database is stored
-  pub ldap_api: String,
   pub home: String,
   pub database: String,
 
-  pub auth: String,
+  // tokens for discord and other API's
   pub discord_token: String,
+  pub discord_token_minecraft: String,
 
+  // email settings
   pub mail_smtp: String,
   pub mail_user: String,
   pub mail_pass: String,
 
+  // wolves API base for clubs/socs
   pub wolves_url: String,
 }
 impl TypeMapKey for Config {
@@ -48,10 +53,8 @@ pub fn get_config() -> Config {
 
   // reasonable defaults
   let mut config = Config {
-    skynet_server: Default::default(),
-    ldap_api: "https://api.account.skynet.ie".to_string(),
-    auth: "".to_string(),
     discord_token: "".to_string(),
+    discord_token_minecraft: "".to_string(),
 
     home: ".".to_string(),
     database: "database.db".to_string(),
@@ -62,26 +65,19 @@ pub fn get_config() -> Config {
     wolves_url: "".to_string(),
   };
 
-  if let Ok(x) = env::var("LDAP_API") {
+  if let Ok(x) = env::var("DATABASE_HOME") {
-    config.ldap_api = x.trim().to_string();
-  }
-  if let Ok(x) = env::var("SKYNET_SERVER") {
-    config.skynet_server = GuildId::from(str_to_num::<u64>(&x));
-  }
-  if let Ok(x) = env::var("HOME") {
     config.home = x.trim().to_string();
   }
   if let Ok(x) = env::var("DATABASE") {
     config.database = x.trim().to_string();
   }
 
-  if let Ok(x) = env::var("LDAP_DISCORD_AUTH") {
-    config.auth = x.trim().to_string();
-  }
-
   if let Ok(x) = env::var("DISCORD_TOKEN") {
     config.discord_token = x.trim().to_string();
   }
+  if let Ok(x) = env::var("DISCORD_TOKEN_MINECRAFT") {
+    config.discord_token_minecraft = x.trim().to_string();
+  }
 
   if let Ok(x) = env::var("EMAIL_SMTP") {
     config.mail_smtp = x.trim().to_string();
@@ -100,10 +96,6 @@ pub fn get_config() -> Config {
   config
 }
 
-fn str_to_num<T: FromStr + Default>(x: &str) -> T {
-  x.trim().parse::<T>().unwrap_or_default()
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ServerMembers {
   pub server: GuildId,
@@ -210,14 +202,39 @@ impl<'r> FromRow<'r, SqliteRow> for WolvesVerify {
   }
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Committee {
+  pub email: String,
+  pub discord: UserId,
+  pub auth_code: String,
+  pub committee: i64,
+}
+impl<'r> FromRow<'r, SqliteRow> for Committee {
+  fn from_row(row: &'r SqliteRow) -> Result<Self, Error> {
+    let user_tmp: i64 = row.try_get("discord")?;
+    let discord = UserId::from(user_tmp as u64);
+
+    Ok(Self {
+      email: row.try_get("email")?,
+      discord,
+      auth_code: row.try_get("auth_code")?,
+      committee: row.try_get("committee")?,
+    })
+  }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Servers {
   pub server: GuildId,
   pub wolves_api: String,
   pub role_past: Option<RoleId>,
-  pub role_current: Option<RoleId>,
+  pub role_current: RoleId,
   pub member_past: i64,
   pub member_current: i64,
+  pub bot_channel_id: ChannelId,
+  // these can be removed in teh future with an API update
+  pub server_name: String,
+  pub wolves_link: String,
 }
 impl<'r> FromRow<'r, SqliteRow> for Servers {
   fn from_row(row: &'r SqliteRow) -> Result<Self, Error> {
@@ -237,15 +254,14 @@ impl<'r> FromRow<'r, SqliteRow> for Servers {
     let role_current = match row.try_get("role_current") {
       Ok(x) => {
         let tmp: i64 = x;
-        if tmp == 0 {
+        RoleId::from(tmp as u64)
-          None
-        } else {
-          Some(RoleId::from(tmp as u64))
-        }
       }
-      _ => None,
+      _ => RoleId::from(0u64),
     };
 
+    let bot_channel_tmp: i64 = row.try_get("bot_channel_id")?;
+    let bot_channel_id = ChannelId::from(bot_channel_tmp as u64);
+
     Ok(Self {
       server,
       wolves_api: row.try_get("wolves_api")?,
@@ -253,10 +269,61 @@ impl<'r> FromRow<'r, SqliteRow> for Servers {
       role_current,
       member_past: row.try_get("member_past")?,
       member_current: row.try_get("member_current")?,
+      bot_channel_id,
+      server_name: row.try_get("server_name")?,
+      wolves_link: row.try_get("wolves_link")?,
     })
   }
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Minecraft {
+  pub discord: GuildId,
+  pub minecraft: String,
+}
+impl<'r> FromRow<'r, SqliteRow> for Minecraft {
+  fn from_row(row: &'r SqliteRow) -> Result<Self, Error> {
+    let server_tmp: i64 = row.try_get("server_discord")?;
+    let discord = GuildId::from(server_tmp as u64);
+
+    Ok(Self {
+      discord,
+      minecraft: row.try_get("server_minecraft")?,
+    })
+  }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RoleAdder {
+  pub server: GuildId,
+  pub role_a: RoleId,
+  pub role_b: RoleId,
+  pub role_c: RoleId,
+}
+impl<'r> FromRow<'r, SqliteRow> for RoleAdder {
+  fn from_row(row: &'r SqliteRow) -> Result<Self, Error> {
+    let server_tmp: i64 = row.try_get("server")?;
+    let server = GuildId::from(server_tmp as u64);
+
+    Ok(Self {
+      server,
+      role_a: get_role_from_row(row, "role_a"),
+      role_b: get_role_from_row(row, "role_b"),
+      role_c: get_role_from_row(row, "role_c"),
+    })
+  }
+}
+
+fn get_role_from_row(row: &SqliteRow, col: &str) -> RoleId {
+  match row.try_get(col) {
+    Ok(x) => {
+      let tmp: i64 = x;
+      RoleId(tmp as u64)
+    }
+    _ => RoleId::from(0u64),
+  }
+}
+
 pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> {
   let database = format!("{}/{}", &config.home, &config.database);
 
@@ -269,58 +336,8 @@ pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> {
     )
     .await?;
 
-  sqlx::query(
+  // migrations are amazing!
-    "CREATE TABLE IF NOT EXISTS wolves (
+  sqlx::migrate!("./db/migrations").run(&pool).await?;
-      id_wolves integer PRIMARY KEY,
-      email     text    not null,
-      discord   integer,
-      minecraft text
-    )",
-  )
-  .execute(&pool)
-  .await?;
-
-  sqlx::query("CREATE INDEX IF NOT EXISTS index_discord ON wolves (discord)").execute(&pool).await?;
-
-  sqlx::query(
-    "CREATE TABLE IF NOT EXISTS wolves_verify (
-      discord     integer PRIMARY KEY, 
-      email       text    not null,
-      auth_code   text    not null,
-      date_expiry text    not null
-    )",
-  )
-  .execute(&pool)
-  .await?;
-
-  sqlx::query("CREATE INDEX IF NOT EXISTS index_date_expiry ON wolves_verify (date_expiry)")
-    .execute(&pool)
-    .await?;
-
-  sqlx::query(
-    "CREATE TABLE IF NOT EXISTS server_members (
-      server    integer not null,
-      id_wolves integer not null,
-      expiry    text    not null,
-      PRIMARY KEY(server,id_wolves),
-      FOREIGN KEY (id_wolves) REFERENCES wolves (id_wolves) 
-    )",
-  )
-  .execute(&pool)
-  .await?;
-
-  sqlx::query(
-    "CREATE TABLE IF NOT EXISTS servers (
-      server          integer PRIMARY KEY,
-      wolves_api      text    not null,
-      role_past       integer,
-      role_current    integer,
-      member_past     integer DEFAULT 0,
-      member_current  integer DEFAULT 0
-    )",
-  )
-  .execute(&pool)
-  .await?;
 
   Ok(pool)
 }
@@ -381,7 +398,7 @@ pub fn random_string(len: usize) -> String {
 
 pub mod set_roles {
   use super::*;
-  pub async fn update_server(ctx: &Context, server: &Servers, remove_roles: &[Option<RoleId>], members_changed: &Vec<UserId>) {
+  pub async fn update_server(ctx: &Context, server: &Servers, remove_roles: &[Option<RoleId>], members_changed: &[UserId]) {
     let db_lock = {
       let data_read = ctx.data.read().await;
       data_read.get::<DataBase>().expect("Expected Database in TypeMap.").clone()
@@ -423,11 +440,9 @@ pub mod set_roles {
             }
           }
 
-          if let Some(role) = &role_current {
+          if !member.roles.contains(role_current) {
-            if !member.roles.contains(role) {
+            roles_set[1] += 1;
-              roles_set[1] += 1;
+            roles.push(role_current.to_owned());
-              roles.push(role.to_owned());
-            }
           }
 
           if let Err(e) = member.add_roles(ctx, &roles).await {
@@ -442,13 +457,11 @@ pub mod set_roles {
             }
           }
 
-          if let Some(role) = &role_current {
+          if member.roles.contains(role_current) {
-            if member.roles.contains(role) {
+            roles_set[2] += 1;
-              roles_set[2] += 1;
+            // if theya re not a current member and have the role then remove it
-              // if theya re not a current member and have the role then remove it
+            if let Err(e) = member.remove_role(ctx, role_current).await {
-              if let Err(e) = member.remove_role(ctx, role).await {
+              println!("{:?}", e);
-                println!("{:?}", e);
-              }
             }
           }
         }
@@ -466,7 +479,7 @@ pub mod set_roles {
     println!("{:?} Changes: New: +{}, Current: +{}/-{}", server.as_u64(), roles_set[0], roles_set[1], roles_set[2]);
   }
 
-  async fn get_server_member_bulk(db: &Pool<Sqlite>, server: &GuildId) -> Vec<ServerMembersWolves> {
+  pub async fn get_server_member_bulk(db: &Pool<Sqlite>, server: &GuildId) -> Vec<ServerMembersWolves> {
     sqlx::query_as::<_, ServerMembersWolves>(
       r#"
       SELECT * 
@@ -517,10 +530,11 @@ pub mod get_data {
   #[derive(Deserialize, Serialize, Debug)]
   struct WolvesResultUser {
     committee: String,
-    wolves_id: String,
+    member_id: String,
     first_name: String,
     last_name: String,
     contact_email: String,
+    opt_in_email: String,
     student_id: Option<String>,
     note: Option<String>,
     expiry: String,
@@ -568,7 +582,7 @@ pub mod get_data {
       // list of users that need to be updated for this server
       let mut user_to_update = vec![];
       for user in get_wolves_sub(&config, wolves_api).await {
-        let id = user.wolves_id.parse::<u64>().unwrap_or_default();
+        let id = user.member_id.parse::<u64>().unwrap_or_default();
         match existing.get(&(id as i64)) {
           None => {
             // user does not exist already, add everything
@@ -645,7 +659,7 @@ pub mod get_data {
       ON CONFLICT(id_wolves) DO UPDATE SET email = $2
     ",
     )
-    .bind(&user.wolves_id)
+    .bind(&user.member_id)
     .bind(&user.contact_email)
     .fetch_optional(db)
     .await
@@ -665,7 +679,7 @@ pub mod get_data {
     ",
     )
     .bind(*server.as_u64() as i64)
-    .bind(&user.wolves_id)
+    .bind(&user.member_id)
     .bind(&user.expiry)
     .fetch_optional(db)
     .await
@@ -678,3 +692,179 @@ pub mod get_data {
     }
   }
 }
+
+/**
+ For any time ye need to check if a user who calls a command has admin privlages
+*/
+pub async fn is_admin(command: &ApplicationCommandInteraction, ctx: &Context) -> Option<String> {
+  let mut admin = false;
+
+  let g_id = match command.guild_id {
+    None => return Some("Not in a server".to_string()),
+    Some(x) => x,
+  };
+
+  let roles_server = g_id.roles(&ctx.http).await.unwrap_or_default();
+
+  if let Ok(member) = g_id.member(&ctx.http, command.user.id).await {
+    if let Some(permissions) = member.permissions {
+      if permissions.administrator() {
+        admin = true;
+      }
+    }
+
+    for role_id in member.roles {
+      if admin {
+        break;
+      }
+      if let Some(role) = roles_server.get(&role_id) {
+        if role.permissions.administrator() {
+          admin = true;
+        }
+      }
+    }
+  }
+  if !admin {
+    Some("Administrator permission required".to_string())
+  } else {
+    None
+  }
+}
+
+/**
+loop through all members of server
+get a list of folks with mc accounts that are members
+and a list that arent members
+ */
+pub async fn update_server(server_id: &str, db: &Pool<Sqlite>, g_id: &GuildId, config: &Config) {
+  let mut usernames = vec![];
+  for member in get_server_member_bulk(db, g_id).await {
+    if let Some(x) = member.minecraft {
+      usernames.push(x);
+    }
+  }
+  if !usernames.is_empty() {
+    whitelist_update(&usernames, server_id, &config.discord_token_minecraft).await;
+  }
+}
+
+async fn post<T: Serialize>(url: &str, bearer: &str, data: &T) {
+  match surf::post(url)
+    .header("Authorization", bearer)
+    .header("Content-Type", "application/json")
+    .header("Accept", "Application/vnd.pterodactyl.v1+json")
+    .body_json(&data)
+  {
+    Ok(req) => {
+      req.await.ok();
+    }
+    Err(e) => {
+      dbg!(e);
+    }
+  }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ServerDetailsResSub {
+  pub identifier: String,
+  pub name: String,
+  pub description: String,
+  pub is_suspended: bool,
+}
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ServerDetailsRes {
+  pub attributes: ServerDetailsResSub,
+}
+
+async fn get<T: Serialize + DeserializeOwned>(url: &str, bearer: &str) -> Option<T> {
+  match surf::get(url)
+    .header("Authorization", bearer)
+    .header("Content-Type", "application/json")
+    .header("Accept", "Application/vnd.pterodactyl.v1+json")
+    .recv_json()
+    .await
+  {
+    Ok(res) => Some(res),
+    Err(e) => {
+      dbg!(e);
+
+      None
+    }
+  }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+struct BodyCommand {
+  command: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+struct BodyDelete {
+  root: String,
+  files: Vec<String>,
+}
+
+pub async fn whitelist_update(add: &Vec<String>, server: &str, token: &str) {
+  let url_base = format!("http://panel.games.skynet.ie/api/client/servers/{server}");
+  let bearer = format!("Bearer {token}");
+
+  for name in add {
+    let data = BodyCommand {
+      command: format!("whitelist add {name}"),
+    };
+    post(&format!("{url_base}/command"), &bearer, &data).await;
+  }
+}
+
+pub async fn whitelist_wipe(server: &str, token: &str) {
+  let url_base = format!("http://panel.games.skynet.ie/api/client/servers/{server}");
+  let bearer = format!("Bearer {token}");
+
+  // delete whitelist
+  let deletion = BodyDelete {
+    root: "/".to_string(),
+    files: vec!["whitelist.json".to_string()],
+  };
+  post(&format!("{url_base}/files/delete"), &bearer, &deletion).await;
+
+  // recreate teh file, passing in the type here so the compiler knows what type of vec it is
+  post::<Vec<&str>>(&format!("{url_base}/files/write?file=%2Fwhitelist.json"), &bearer, &vec![]).await;
+
+  // reload the whitelist
+  let data = BodyCommand {
+    command: "whitelist reload".to_string(),
+  };
+  post(&format!("{url_base}/command"), &bearer, &data).await;
+}
+
+pub async fn server_information(server: &str, token: &str) -> Option<ServerDetailsRes> {
+  let url_base = format!("http://panel.games.skynet.ie/api/client/servers/{server}");
+  let bearer = format!("Bearer {token}");
+  get::<ServerDetailsRes>(&format!("{url_base}/"), &bearer).await
+}
+
+pub async fn get_minecraft_config(db: &Pool<Sqlite>) -> Vec<Minecraft> {
+  sqlx::query_as::<_, Minecraft>(
+    r#"
+        SELECT *
+        FROM minecraft
+        "#,
+  )
+  .fetch_all(db)
+  .await
+  .unwrap_or_default()
+}
+
+pub async fn get_minecraft_config_server(db: &Pool<Sqlite>, g_id: GuildId) -> Vec<Minecraft> {
+  sqlx::query_as::<_, Minecraft>(
+    r#"
+        SELECT *
+        FROM minecraft
+        WHERE server_discord = ?1
+        "#,
+  )
+  .bind(*g_id.as_u64() as i64)
+  .fetch_all(db)
+  .await
+  .unwrap_or_default()
+}

src/main.rs

@@ -1,25 +1,28 @@
-mod commands;
+pub mod commands;
 
+use crate::commands::role_adder::tools::on_role_change;
+use serenity::model::guild::Member;
 use serenity::{
   async_trait,
   client::{Context, EventHandler},
   model::{
     application::{command::Command, interaction::Interaction},
     gateway::{GatewayIntents, Ready},
-    guild,
+    prelude::Activity,
+    user::OnlineStatus,
   },
   Client,
 };
-use std::sync::Arc;
-
 use skynet_discord_bot::{db_init, get_config, get_server_config, get_server_member, Config, DataBase};
+use std::sync::Arc;
 use tokio::sync::RwLock;
 
 struct Handler;
 
 #[async_trait]
 impl EventHandler for Handler {
-  async fn guild_member_addition(&self, ctx: Context, mut new_member: guild::Member) {
+  // handles previously linked accounts joining the server
+  async fn guild_member_addition(&self, ctx: Context, mut new_member: Member) {
     let db_lock = {
       let data_read = ctx.data.read().await;
       data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
@@ -40,26 +43,49 @@ impl EventHandler for Handler {
         }
       }
 
-      if let Some(role) = &config.role_current {
+      if !new_member.roles.contains(&config.role_current) {
-        if !new_member.roles.contains(role) {
+        roles.push(config.role_current.to_owned());
-          roles.push(role.to_owned());
-        }
       }
 
       if let Err(e) = new_member.add_roles(&ctx, &roles).await {
         println!("{:?}", e);
       }
+    } else {
+      let msg = format!(
+        r#"
+Welcome {} to the {} server!
+Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use ``/link_wolves`` to get full access.
+        "#,
+        new_member.display_name(),
+        &config.server_name,
+        &config.wolves_link,
+        &config.server,
+        &config.bot_channel_id
+      );
+
+      if let Err(err) = new_member.user.direct_message(&ctx, |m| m.content(&msg)).await {
+        dbg!(err);
+      }
     }
   }
 
   async fn ready(&self, ctx: Context, ready: Ready) {
     println!("[Main] {} is connected!", ready.user.name);
+    ctx.set_presence(Some(Activity::playing("with humanity's fate")), OnlineStatus::Online).await;
 
     match Command::set_global_application_commands(&ctx.http, |commands| {
       commands
         .create_application_command(|command| commands::add_server::register(command))
+        .create_application_command(|command| commands::role_adder::edit::register(command))
         .create_application_command(|command| commands::link_email::link::register(command))
         .create_application_command(|command| commands::link_email::verify::register(command))
+        .create_application_command(|command| commands::minecraft::server::add::register(command))
+        .create_application_command(|command| commands::minecraft::server::list::register(command))
+        .create_application_command(|command| commands::minecraft::server::delete::register(command))
+        .create_application_command(|command| commands::minecraft::user::add::register(command))
+        // for committee server, temp
+        .create_application_command(|command| commands::committee::link::register(command))
+        .create_application_command(|command| commands::committee::verify::register(command))
     })
     .await
     {
@@ -76,9 +102,19 @@ impl EventHandler for Handler {
       //println!("Received command interaction: {:#?}", command);
 
       let content = match command.data.name.as_str() {
-        "add" => commands::add_server::run(&command, &ctx).await,
+        // user commands
-        "link" => commands::link_email::link::run(&command, &ctx).await,
+        "link_wolves" => commands::link_email::link::run(&command, &ctx).await,
         "verify" => commands::link_email::verify::run(&command, &ctx).await,
+        "link_minecraft" => commands::minecraft::user::add::run(&command, &ctx).await,
+        // admin commands
+        "add" => commands::add_server::run(&command, &ctx).await,
+        "roles_adder" => commands::role_adder::edit::run(&command, &ctx).await,
+        "minecraft_add" => commands::minecraft::server::add::run(&command, &ctx).await,
+        "minecraft_list" => commands::minecraft::server::list::run(&command, &ctx).await,
+        "minecraft_delete" => commands::minecraft::server::delete::run(&command, &ctx).await,
+        // for teh committee server, temporary
+        "link_committee" => commands::committee::link::run(&command, &ctx).await,
+        "verify_committee" => commands::committee::verify::run(&command, &ctx).await,
         _ => "not implemented :(".to_string(),
       };
 
@@ -87,6 +123,20 @@ impl EventHandler for Handler {
       }
     }
   }
+
+  // handles role updates
+  async fn guild_member_update(&self, ctx: Context, _old_data: Option<Member>, new_data: Member) {
+    // get config/db
+    let db_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
+    };
+
+    let db = db_lock.read().await;
+
+    // check if the role changed is part of the oens for this server
+    on_role_change(&db, &ctx, new_data).await;
+  }
 }
 
 #[tokio::main]
@@ -94,7 +144,10 @@ async fn main() {
   let config = get_config();
   let db = match db_init(&config).await {
     Ok(x) => x,
-    Err(_) => return,
+    Err(err) => {
+      dbg!(err);
+      return;
+    }
   };
 
   // Intents are a bitflag, bitwise operations can be used to dictate which intents to use