Fix docker run.sh

Add .env to ignore and remove warning.
Use flags for email / registration correctly.
2020-08-30 18:56:43 +01:00 · 2020-08-30 18:04:38 +01:00 · 2020-08-30 17:48:30 +01:00 · 2020-08-30 17:16:53 +01:00 · 2020-08-30 15:44:56 +01:00 · 2020-08-30 15:07:45 +01:00
37 changed files with 1654 additions and 918 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,3 @@
+assets
+target
+.env
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -0,0 +1,20 @@
+stages:
+  - build
+
+# Rocket does not currently compile on stable Rust.
+# Once it does, we can uncomment this, and instead
+# put `allow-failure: true` on the nightly build.
+#
+# rust-latest:
+#   stage: build
+#   image: rust:latest
+#   script:
+#     - cargo build --verbose
+#     - cargo test --verbose
+
+rust-nightly:
+  stage: build
+  image: rustlang/rust:nightly
+  script:
+    - cargo build --verbose
+    - cargo test --verbose
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -15,15 +15,6 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"

-[[package]]
-name = "ahash"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f33b5018f120946c1dcf279194f238a9f146725593ead1c08fa47ff22b0b5d3"
-dependencies = [
- "const-random",
-]
-
 [[package]]
 name = "ahash"
 version = "0.3.8"
@@ -39,6 +30,12 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "arrayvec"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"
+
 [[package]]
 name = "async-attributes"
 version = "1.1.1"
@@ -174,15 +171,14 @@ checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"

 [[package]]
 name = "bcrypt"
-version = "0.7.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f02d7d008a57bcb2251ba115b803934e02315edbde9a861c88713493e381b63"
+checksum = "e2cab630912253fb9dc92c0e2fabd0a7b51f5a5a4007177cfa31e517015b7204"
 dependencies = [
 "base64 0.12.3",
 "blowfish",
 "byteorder",
- "lazy_static",
- "rand 0.7.3",
+ "getrandom",
 ]

 [[package]]
@@ -206,16 +202,16 @@ dependencies = [
 "block-padding",
 "byte-tools",
 "byteorder",
- "generic-array",
+ "generic-array 0.12.3",
 ]

 [[package]]
-name = "block-cipher-trait"
-version = "0.6.2"
+name = "block-cipher"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c924d49bd09e7c06003acda26cd9742e796e34282ec6c1189404dee0c1f4774"
+checksum = "f337a3e6da609650eb74e02bc9fac7b735049f7623ab12f2e4c719316fcc7e80"
 dependencies = [
- "generic-array",
+ "generic-array 0.14.4",
 ]

 [[package]]
@@ -243,20 +239,20 @@ dependencies = [

 [[package]]
 name = "blowfish"
-version = "0.4.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aeb80d00f2688459b8542068abd974cfb101e7a82182414a99b5026c0d85cc3"
+checksum = "0f06850ba969bc59388b2cc0a4f186fc6d9d37208863b15b84ae3866ac90ac06"
 dependencies = [
- "block-cipher-trait",
+ "block-cipher",
 "byteorder",
- "opaque-debug",
+ "opaque-debug 0.3.0",
 ]

 [[package]]
 name = "bson"
-version = "1.1.0-beta"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef53f55e2f3e8b57182771db30a3e32d0aeaaa5aebbe18ce81b2d75e69b922ec"
+checksum = "c11f16001d679cb13d14b2c93c7d0fa13bb484a87c34a6c4c39707ad936499b5"
 dependencies = [
 "base64 0.12.3",
 "chrono",
@@ -268,6 +264,12 @@ dependencies = [
 "serde_json",
 ]

+[[package]]
+name = "bufstream"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40e38929add23cdf8a366df9b0e088953150724bcbe5fc330b0d8eb3b328eec8"
+
 [[package]]
 name = "bumpalo"
 version = "3.4.0"
@@ -322,9 +324,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

 [[package]]
 name = "chrono"
-version = "0.4.13"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c74d84029116787153e02106bf53e66828452a4b325cc8652b788b5967c0a0b6"
+checksum = "942f72db697d8767c22d46a598e01f2d3b475501ea43d0db4f16d90259182d0b"
 dependencies = [
 "js-sys",
 "num-integer",
@@ -342,6 +344,15 @@ dependencies = [
 "bitflags",
 ]

+[[package]]
+name = "cloudabi"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4344512281c643ae7638bbabc3af17a11307803ec8f0fcad9fae512a8bf36467"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "concurrent-queue"
 version = "1.2.0"
@@ -351,26 +362,6 @@ dependencies = [
 "cache-padded",
 ]

-[[package]]
-name = "const-random"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f1af9ac737b2dd2d577701e59fd09ba34822f6f2ebdb30a7647405d9e55e16a"
-dependencies = [
- "const-random-macro",
- "proc-macro-hack",
-]
-
-[[package]]
-name = "const-random-macro"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25e4c606eb459dd29f7c57b2e0879f2b6f14ee130918c2b78ccb58a9624e6c7a"
-dependencies = [
- "getrandom",
- "proc-macro-hack",
-]
-
 [[package]]
 name = "cookie"
 version = "0.11.3"
@@ -414,7 +405,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
 dependencies = [
- "generic-array",
+ "generic-array 0.12.3",
 "subtle",
 ]

@@ -467,7 +458,7 @@ version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
 dependencies = [
- "generic-array",
+ "generic-array 0.12.3",
 ]

 [[package]]
@@ -509,6 +500,19 @@ dependencies = [
 "syn 1.0.37",
 ]

+[[package]]
+name = "env_logger"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+dependencies = [
+ "atty",
+ "humantime",
+ "log 0.4.11",
+ "regex",
+ "termcolor",
+]
+
 [[package]]
 name = "err-derive"
 version = "0.2.4"
@@ -664,8 +668,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc1529d07bd55fa54fc6c2d8460f621cfde0ae3fd2b96b2fa7eb4883478e1703"
 dependencies = [
 "futures-core",
- "lock_api",
- "parking_lot",
+ "lock_api 0.3.4",
+ "parking_lot 0.10.2",
 ]

 [[package]]
@@ -745,6 +749,16 @@ dependencies = [
 "typenum",
 ]

+[[package]]
+name = "generic-array"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+dependencies = [
+ "typenum",
+ "version_check 0.9.2",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.1.14"
@@ -789,30 +803,11 @@ dependencies = [

 [[package]]
 name = "hashbrown"
-version = "0.6.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e6073d0ca812575946eb5f35ff68dbe519907b25c42530389ff946dc84c6ead"
-dependencies = [
- "ahash 0.2.18",
- "autocfg 0.1.7",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96282e96bfcd3da0d3aa9938bedf1e50df3269b6db08b4876d2da0bb1a0841cf"
-dependencies = [
- "ahash 0.3.8",
- "autocfg 1.0.0",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34f595585f103464d8d2f6e9864682d74c1601fed5e07d62b1c9058dba8246fb"
+checksum = "e91b62f79061a0bc2e046024cb7ba44b08419ed238ecbd9adbd787434b9e8c25"
 dependencies = [
+ "ahash",
 "autocfg 1.0.0",
 ]

@@ -888,6 +883,15 @@ version = "1.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"

+[[package]]
+name = "humantime"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
+dependencies = [
+ "quick-error",
+]
+
 [[package]]
 name = "hyper"
 version = "0.10.16"
@@ -944,6 +948,24 @@ dependencies = [
 "tokio-tls",
 ]

+[[package]]
+name = "hyperx"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9eae1ec4abdc4530fb001ebf585fd14e52ed17f0aacd3e13de497b71ed451750"
+dependencies = [
+ "base64 0.12.3",
+ "bytes 0.5.6",
+ "http",
+ "httparse",
+ "language-tags",
+ "log 0.4.11",
+ "mime 0.3.16",
+ "percent-encoding 2.1.0",
+ "time 0.1.43",
+ "unicase 2.6.0",
+]
+
 [[package]]
 name = "idna"
 version = "0.1.5"
@@ -973,7 +995,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b88cd59ee5f71fea89a62248fc8f387d44400cefe05ef548466d61ced9029a7"
 dependencies = [
 "autocfg 1.0.0",
- "hashbrown 0.8.1",
+ "hashbrown",
 ]

 [[package]]
@@ -996,6 +1018,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "instant"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b141fdc7836c525d4d594027d318c84161ca17aaf8113ab1f81ab93ae897485"
+
 [[package]]
 name = "iovec"
 version = "0.1.4"
@@ -1075,12 +1103,61 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"

+[[package]]
+name = "lettre"
+version = "0.10.0-alpha.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "deaf9b74d40fcb52d0f762eb08e45d5152b4db59d29bb73edd4cac7fe796862c"
+dependencies = [
+ "base64 0.12.3",
+ "bufstream",
+ "hostname",
+ "hyperx",
+ "idna 0.2.0",
+ "line-wrap",
+ "mime 0.3.16",
+ "nom",
+ "once_cell",
+ "quoted_printable",
+ "r2d2",
+ "regex",
+ "rustls",
+ "serde",
+ "serde_json",
+ "textnonce",
+ "uuid",
+ "webpki",
+ "webpki-roots 0.19.0",
+]
+
+[[package]]
+name = "lexical-core"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db65c6da02e61f55dae90a0ae427b2a5f6b3e8db09f58d10efab23af92592616"
+dependencies = [
+ "arrayvec",
+ "bitflags",
+ "cfg-if",
+ "ryu",
+ "static_assertions",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2f02823cf78b754822df5f7f268fb59822e7296276d3e069d8e8cb26a14bd10"

+[[package]]
+name = "line-wrap"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f30344350a2a51da54c1d53be93fade8a237e545dbcc4bdbe635413f2117cab9"
+dependencies = [
+ "safemem",
+]
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.3"
@@ -1096,6 +1173,15 @@ dependencies = [
 "scopeguard",
 ]

+[[package]]
+name = "lock_api"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28247cc5a5be2f05fbcd76dd0cf2c7d3b5400cb978a28042abcd4fa0b3f8261c"
+dependencies = [
+ "scopeguard",
+]
+
 [[package]]
 name = "log"
 version = "0.3.9"
@@ -1116,11 +1202,11 @@ dependencies = [

 [[package]]
 name = "lru"
-version = "0.5.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35c456c123957de3a220cd03786e0d86aa542a88b46029973b542f426da6ef34"
+checksum = "111b945ac72ec09eb7bc62a0fbdc3cc6e80555a7245f52a69d3921a75b53b153"
 dependencies = [
- "hashbrown 0.6.3",
+ "hashbrown",
 ]

 [[package]]
@@ -1152,7 +1238,7 @@ checksum = "a18af3dcaf2b0219366cdb4e2af65a6101457b415c3d1a5c71dd9c2b7c77b9c8"
 dependencies = [
 "block-buffer",
 "digest",
- "opaque-debug",
+ "opaque-debug 0.2.3",
 ]

 [[package]]
@@ -1240,9 +1326,9 @@ dependencies = [

 [[package]]
 name = "mongodb"
-version = "1.1.0-beta"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78f8c23edb98f47884f7f419c7dfce7aa5a5334d27983c86f26847b3b6225552"
+checksum = "f8cb54f85e6380c8cfe130a55a85cfc2584e8317f4bb8bda464d367fd4f24957"
 dependencies = [
 "async-std",
 "async-trait",
@@ -1280,7 +1366,7 @@ dependencies = [
 "uuid",
 "version_check 0.9.2",
 "webpki",
- "webpki-roots",
+ "webpki-roots 0.18.0",
 ]

 [[package]]
@@ -1312,6 +1398,17 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "nom"
+version = "5.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af"
+dependencies = [
+ "lexical-core",
+ "memchr",
+ "version_check 0.9.2",
+]
+
 [[package]]
 name = "notify"
 version = "4.0.15"
@@ -1361,9 +1458,9 @@ dependencies = [

 [[package]]
 name = "num_enum"
-version = "0.4.3"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca565a7df06f3d4b485494f25ba05da1435950f4dc263440eda7a6fa9b8e36e4"
+checksum = "226b45a5c2ac4dd696ed30fa6b94b057ad909c7b7fc2e0d0808192bced894066"
 dependencies = [
 "derivative",
 "num_enum_derive",
@@ -1371,9 +1468,9 @@ dependencies = [

 [[package]]
 name = "num_enum_derive"
-version = "0.4.3"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffa5a33ddddfee04c0283a7653987d634e880347e96b5b2ed64de07efb59db9d"
+checksum = "1c0fd9eba1d5db0994a239e09c1be402d35622277e35468ba891aa5e3188ce7e"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2 1.0.19",
@@ -1389,9 +1486,9 @@ checksum = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5"

 [[package]]
 name = "once_cell"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b631f7e854af39a1739f401cf34a8a013dfe09eac4fa4dba91e9768bd28168d"
+checksum = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad"

 [[package]]
 name = "opaque-debug"
@@ -1399,6 +1496,12 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"

+[[package]]
+name = "opaque-debug"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+
 [[package]]
 name = "openssl"
 version = "0.10.30"
@@ -1454,8 +1557,19 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3a704eb390aafdc107b0e392f56a82b668e3a71366993b5340f5833fd62505e"
 dependencies = [
- "lock_api",
- "parking_lot_core",
+ "lock_api 0.3.4",
+ "parking_lot_core 0.7.2",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4893845fa2ca272e647da5d0e46660a314ead9c2fdd9a883aabc32e481a8733"
+dependencies = [
+ "instant",
+ "lock_api 0.4.1",
+ "parking_lot_core 0.8.0",
 ]

 [[package]]
@@ -1465,7 +1579,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d58c7c768d4ba344e3e8d72518ac13e259d7c7ade24167003b8488e10b6740a3"
 dependencies = [
 "cfg-if",
- "cloudabi",
+ "cloudabi 0.0.3",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c361aa727dd08437f2f1447be8b59a33b0edd15e0fcee698f935613d9efbca9b"
+dependencies = [
+ "cfg-if",
+ "cloudabi 0.1.0",
+ "instant",
 "libc",
 "redox_syscall",
 "smallvec",
@@ -1647,6 +1776,23 @@ dependencies = [
 "proc-macro2 1.0.19",
 ]

+[[package]]
+name = "quoted_printable"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b080c5db639b292ac79cbd34be0cfc5d36694768d8341109634d90b86930e2"
+
+[[package]]
+name = "r2d2"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "545c5bc2b880973c9c10e4067418407a0ccaa3091781d1671d46eb35107cb26f"
+dependencies = [
+ "log 0.4.11",
+ "parking_lot 0.11.0",
+ "scheduled-thread-pool",
+]
+
 [[package]]
 name = "rand"
 version = "0.6.5"
@@ -1767,7 +1913,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
 dependencies = [
- "cloudabi",
+ "cloudabi 0.0.3",
 "fuchsia-cprng",
 "libc",
 "rand_core 0.4.2",
@@ -1839,9 +1985,9 @@ dependencies = [

 [[package]]
 name = "reqwest"
-version = "0.10.7"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12427a5577082c24419c9c417db35cfeb65962efc7675bb6b0d5f1f9d315bfe6"
+checksum = "e9eaa17ac5d7b838b7503d118fa16ad88f440498bf9ffe5424e621f93190d61e"
 dependencies = [
 "base64 0.12.3",
 "bytes 0.5.6",
@@ -1885,14 +2031,17 @@ dependencies = [

 [[package]]
 name = "revolt"
-version = "0.2.3"
+version = "0.2.10"
 dependencies = [
 "bcrypt",
 "bitfield",
 "chrono",
 "dotenv",
- "hashbrown 0.7.2",
+ "env_logger",
+ "hashbrown",
 "lazy_static",
+ "lettre",
+ "log 0.4.11",
 "lru",
 "mongodb",
 "num_enum",
@@ -2077,6 +2226,15 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "scheduled-thread-pool"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6f74fd1204073fa02d5d5d68bec8021be4c38690b61264b2fdb48083d0e7d7"
+dependencies = [
+ "parking_lot 0.11.0",
+]
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.0"
@@ -2139,18 +2297,18 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"

 [[package]]
 name = "serde"
-version = "1.0.114"
+version = "1.0.115"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5317f7588f0a5078ee60ef675ef96735a1442132dc645eb1d12c018620ed8cd3"
+checksum = "e54c9a88f2da7238af84b5101443f0c0d0a3bbdc455e34a5c9497b1903ed55d5"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.114"
+version = "1.0.115"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0be94b04690fbaed37cddffc5c134bf537c8e3329d53e982fe04c374978f8e"
+checksum = "609feed1d0a73cc36a0182a840a9b37b4a82f0b1150369f0536a9e3f2a31dc48"
 dependencies = [
 "proc-macro2 1.0.19",
 "quote 1.0.7",
@@ -2211,7 +2369,7 @@ dependencies = [
 "block-buffer",
 "digest",
 "fake-simd",
- "opaque-debug",
+ "opaque-debug 0.2.3",
 ]

 [[package]]
@@ -2229,7 +2387,7 @@ dependencies = [
 "block-buffer",
 "digest",
 "fake-simd",
- "opaque-debug",
+ "opaque-debug 0.2.3",
 ]

 [[package]]
@@ -2298,6 +2456,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7345c971d1ef21ffdbd103a75990a15eb03604fc8b8852ca8cb418ee1a099028"

+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
 [[package]]
 name = "stdweb"
 version = "0.4.20"
@@ -2423,6 +2587,28 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "termcolor"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textnonce"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acc659075a12c12c07bbb384862c352506707f6597f5b495f65427d08519b617"
+dependencies = [
+ "base64 0.12.3",
+ "byteorder",
+ "chrono",
+ "rand 0.7.3",
+ "serde",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.20"
@@ -2586,9 +2772,9 @@ checksum = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"

 [[package]]
 name = "tracing"
-version = "0.1.18"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0aae59226cf195d8e74d4b34beae1859257efb4e5fed3f147d2dc2c7d372178"
+checksum = "6d79ca061b032d6ce30c660fded31189ca0b9922bf483cd70759f13a2d86786c"
 dependencies = [
 "cfg-if",
 "log 0.4.11",
@@ -2597,9 +2783,9 @@ dependencies = [

 [[package]]
 name = "tracing-core"
-version = "0.1.12"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2734b5a028fa697686f16c6d18c2c6a3c7e41513f9a213abb6754c4acb3c8d7"
+checksum = "db63662723c316b43ca36d833707cc93dff82a02ba3d7e354f342682cc8b3545"
 dependencies = [
 "lazy_static",
 ]
@@ -2681,9 +2867,9 @@ checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"

 [[package]]
 name = "ulid"
-version = "0.3.3"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39ea3ad32d4895ee0681033bd93f16939e186dac72259fa5efc158703f8be4bc"
+checksum = "cacfb60872052779608509dcb3dbc8b9d955f5686d71e7ad3173029dc482d07d"
 dependencies = [
 "chrono",
 "lazy_static",
@@ -2954,6 +3140,15 @@ dependencies = [
 "webpki",
 ]

+[[package]]
+name = "webpki-roots"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8eff4b7516a57307f9349c64bf34caa34b940b66fed4b2fb3136cb7386e5739"
+dependencies = [
+ "webpki",
+]
+
 [[package]]
 name = "wepoll-sys-stjepang"
 version = "1.0.6"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,30 +1,33 @@
 [package]
 name = "revolt"
-version = "0.2.3"
+version = "0.2.10"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-mongodb = { version = "1.1.0-beta", default-features = false, features = ["sync"] } # FIXME: rewrite database with async API
-rocket = { version = "0.4.4", default-features = false }
-once_cell = "1.3.1"
+mongodb = { version = "1.1.0", default-features = false, features = ["sync"] } # FIXME: rewrite database with async API
+rocket = { version = "0.4.5", default-features = false }
+once_cell = "1.4.1"
 dotenv = "0.15.0"
-ulid = "0.3.1"
-serde = { version = "1.0", features = ["derive"] }
-rocket_contrib = "0.4.4"
-validator = "0.10.0"
-bcrypt = "0.7.0"
-chrono = "0.4.11"
+ulid = "0.4.0"
+serde = { version = "1.0.115", features = ["derive"] }
+rocket_contrib = "0.4.5"
+validator = "0.10.1"
+bcrypt = "0.8.2"
+chrono = "0.4.15"
 rand = "0.7.3"
-time = "0.2.9"
-reqwest = { version = "0.10.4", features = ["blocking", "json"] }
-num_enum = "0.4.3"
+time = "0.2.16"
+reqwest = { version = "0.10.8", features = ["blocking", "json"] }
+num_enum = "0.5.1"
 ws = "0.9.1"
-hashbrown = "0.7.1"
-serde_json = "1.0.51"
+hashbrown = "0.8.2"
+serde_json = "1.0.57"
 rocket_cors = "0.5.2"
 bitfield = "0.13.2"
-lru = "0.5.3"
+lru = "0.6.0"
 lazy_static = "1.4.0"
+log = "0.4.11"
+env_logger = "0.7.1"
+lettre = "0.10.0-alpha.1"
--- a/16
+++ b/16
@@ -0,0 +1,16 @@
+# Build Stage
+FROM ekidd/rust-musl-builder:nightly-2020-08-26 AS builder
+WORKDIR /home/rust/src
+
+RUN USER=root cargo new --bin revolt
+WORKDIR ./revolt
+COPY Cargo.toml Cargo.lock ./
+COPY src ./src
+RUN cargo build --release
+
+# Bundle Stage
+FROM scratch
+COPY --from=builder /home/rust/src/revolt/target/x86_64-unknown-linux-musl/release/revolt ./
+EXPOSE 8000
+EXPOSE 9000
+CMD ["./revolt"]
--- a/README.md
+++ b/README.md
@@ -7,3 +7,14 @@ Features:
 - Distributed notification system, allowing any node to be seamlessly connected.
 - Simple deployment, based mostly on pure Rust code and libraries.
 - Hooks up to a MongoDB deployment, provide URI and no extra work needed.
+
+## Docker Helper Scripts
+
+If you have Docker installed, you can use the helper scripts to deploy Revolt in your development environment.
+
+```bash
+./build.sh   # build Docker image
+./run.sh     # run Docker container
+./monitor.sh # view container logs
+./remove.sh  # kill and remove container
+```
--- a/build.sh
+++ b/build.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+docker build -t revolt --progress plain .
--- a/monitor.sh
+++ b/monitor.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+docker logs -f revolt
--- a/remove.sh
+++ b/remove.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+echo "Removing Revolt container."
+docker kill revolt
+docker rm revolt
--- a/run.sh
+++ b/run.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+# Split at \n instead of space.
+# https://unix.stackexchange.com/a/39482
+set -f
+IFS='
+'
+
+input=($(egrep -v '^#' .env))
+prepended=(${input[@]/#/-e\"})
+variables=${prepended[@]/%/\"}
+
+unset IFS
+set +f
+
+echo "Running Revolt in detached mode."
+docker run \
+    -d \
+    --name revolt \
+    -p 8000:8000 \
+    -p 9000:9000 \
+    $variables \
+    revolt
--- a/src/database/channel.rs
+++ b/src/database/channel.rs
@@ -4,6 +4,7 @@ use lru::LruCache;
 use mongodb::bson::{doc, from_bson, Bson};
 use rocket::http::RawStr;
 use rocket::request::FromParam;
+use rocket_contrib::json::JsonValue;
 use serde::{Deserialize, Serialize};
 use std::sync::{Arc, Mutex};

@@ -40,6 +41,36 @@ pub struct Channel {
    pub description: Option<String>,
 }

+impl Channel {
+    pub fn serialise(self) -> JsonValue {
+        match self.channel_type {
+            0 => json!({
+                "id": self.id,
+                "type": self.channel_type,
+                "last_message": self.last_message,
+                "recipients": self.recipients,
+            }),
+            1 => json!({
+                "id": self.id,
+                "type": self.channel_type,
+                "last_message": self.last_message,
+                "recipients": self.recipients,
+                "name": self.name,
+                "owner": self.owner,
+                "description": self.description,
+            }),
+            2 => json!({
+                "id": self.id,
+                "type": self.channel_type,
+                "guild": self.guild,
+                "name": self.name,
+                "description": self.description,
+            }),
+            _ => unreachable!(),
+        }
+    }
+}
+
 lazy_static! {
    static ref CACHE: Arc<Mutex<LruCache<String, Channel>>> =
        Arc::new(Mutex::new(LruCache::new(4_000_000)));
@@ -77,19 +108,19 @@ pub fn fetch_channel(id: &str) -> Result<Option<Channel>, String> {
    }
 }

-pub fn fetch_channels(ids: &Vec<String>) -> Result<Option<Vec<Channel>>, String> {
+pub fn fetch_channels(ids: &Vec<String>) -> Result<Vec<Channel>, String> {
    let mut missing = vec![];
    let mut channels = vec![];

    {
        if let Ok(mut cache) = CACHE.lock() {
-            for gid in ids {
-                let existing = cache.get(gid);
+            for id in ids {
+                let existing = cache.get(id);

                if let Some(channel) = existing {
                    channels.push((*channel).clone());
                } else {
-                    missing.push(gid);
+                    missing.push(id);
                }
            }
        } else {
@@ -98,7 +129,7 @@ pub fn fetch_channels(ids: &Vec<String>) -> Result<Option<Vec<Channel>>, String>
    }

    if missing.len() == 0 {
-        return Ok(Some(channels));
+        return Ok(channels);
    }

    let col = get_collection("channels");
@@ -117,7 +148,7 @@ pub fn fetch_channels(ids: &Vec<String>) -> Result<Option<Vec<Channel>>, String>
            }
        }

-        Ok(Some(channels))
+        Ok(channels)
    } else {
        Err("Failed to fetch channel from database.".to_string())
    }
@@ -139,36 +170,46 @@ impl<'r> FromParam<'r> for Channel {
    }
 }

-/*pub fn test() {
-    use std::time::Instant;
+use crate::notifications::events::Notification;

-    let now = Instant::now();
-    let mut cache = CACHE.lock().unwrap();
-    println!("I'm about to write 4 million entries to cache.");
-    for i in 0..4_000_000 {
-        let c = Channel {
-            id: "potato".to_string(),
-            channel_type: 0,
-
-            active: None,
-            last_message: None,
-            description: None,
-            guild: None,
-            name: None,
-            owner: None,
-            recipients: None
-        };
-
-        cache.put(format!("{}", i), c);
+pub fn process_event(event: &Notification) {
+    match event {
+        Notification::group_user_join(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            if let Some(channel) = cache.peek_mut(&ev.id) {
+                channel.recipients.as_mut().unwrap().push(ev.user.clone());
+            }
+        }
+        Notification::group_user_leave(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            if let Some(channel) = cache.peek_mut(&ev.id) {
+                let recipients = channel.recipients.as_mut().unwrap();
+                if let Some(pos) = recipients.iter().position(|x| *x == ev.user) {
+                    recipients.remove(pos);
+                }
+            }
+        }
+        Notification::guild_channel_create(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            cache.put(
+                ev.id.clone(),
+                Channel {
+                    id: ev.channel.clone(),
+                    channel_type: 2,
+                    active: None,
+                    last_message: None,
+                    recipients: None,
+                    owner: None,
+                    guild: Some(ev.id.clone()),
+                    name: Some(ev.name.clone()),
+                    description: Some(ev.description.clone()),
+                },
+            );
+        }
+        Notification::guild_channel_delete(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            cache.pop(&ev.channel);
+        }
+        _ => {}
    }
-
-    println!("It took {} seconds, roughly {}ms per entry.", now.elapsed().as_secs_f64(), now.elapsed().as_millis() as f64 / 1_000_000.0);
-
-    let now = Instant::now();
-    println!("Now I'm going to read every entry and immediately dispose of it.");
-    for i in 0..4_000_000 {
-        cache.get(&format!("{}", i));
-    }
-
-    println!("It took {} seconds, roughly {}ms per entry.", now.elapsed().as_secs_f64(), now.elapsed().as_millis() as f64 / 1_000_000.0);
-}*/
+}
--- a/src/database/guild.rs
+++ b/src/database/guild.rs
@@ -1,9 +1,11 @@
+use super::channel::fetch_channels;
 use super::get_collection;

 use lru::LruCache;
 use mongodb::bson::{doc, from_bson, Bson};
 use rocket::http::RawStr;
 use rocket::request::FromParam;
+use rocket_contrib::json::JsonValue;
 use serde::{Deserialize, Serialize};
 use std::sync::{Arc, Mutex};

@@ -42,15 +44,51 @@ pub struct Guild {
    pub description: String,
    pub owner: String,

+    pub channels: Vec<String>,
    pub invites: Vec<Invite>,
    pub bans: Vec<Ban>,

    pub default_permissions: u32,
 }

+impl Guild {
+    pub fn serialise(self) -> JsonValue {
+        json!({
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "owner": self.owner
+        })
+    }
+
+    pub fn fetch_channels(&self) -> Result<Vec<super::channel::Channel>, String> {
+        super::channel::fetch_channels(&self.channels)
+    }
+
+    pub fn seralise_with_channels(self) -> Result<JsonValue, String> {
+        let channels = self
+            .fetch_channels()?
+            .into_iter()
+            .map(|x| x.serialise())
+            .collect();
+
+        let mut value = self.serialise();
+        value
+            .as_object_mut()
+            .unwrap()
+            .insert("channels".to_string(), channels);
+        Ok(value)
+    }
+}
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct MemberKey(pub String, pub String);
+
 lazy_static! {
    static ref CACHE: Arc<Mutex<LruCache<String, Guild>>> =
        Arc::new(Mutex::new(LruCache::new(4_000_000)));
+    static ref MEMBER_CACHE: Arc<Mutex<LruCache<MemberKey, Member>>> =
+        Arc::new(Mutex::new(LruCache::new(4_000_000)));
 }

 pub fn fetch_guild(id: &str) -> Result<Option<Guild>, String> {
@@ -85,6 +123,113 @@ pub fn fetch_guild(id: &str) -> Result<Option<Guild>, String> {
    }
 }

+pub fn fetch_guilds(ids: &Vec<String>) -> Result<Vec<Guild>, String> {
+    let mut missing = vec![];
+    let mut guilds = vec![];
+
+    {
+        if let Ok(mut cache) = CACHE.lock() {
+            for id in ids {
+                let existing = cache.get(id);
+
+                if let Some(guild) = existing {
+                    guilds.push((*guild).clone());
+                } else {
+                    missing.push(id);
+                }
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    if missing.len() == 0 {
+        return Ok(guilds);
+    }
+
+    let col = get_collection("guilds");
+    if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
+        for item in result {
+            let mut cache = CACHE.lock().unwrap();
+            if let Ok(doc) = item {
+                if let Ok(guild) = from_bson(Bson::Document(doc)) as Result<Guild, _> {
+                    cache.put(guild.id.clone(), guild.clone());
+                    guilds.push(guild);
+                } else {
+                    return Err("Failed to deserialize guild!".to_string());
+                }
+            } else {
+                return Err("Failed to fetch guild.".to_string());
+            }
+        }
+
+        Ok(guilds)
+    } else {
+        Err("Failed to fetch channel from database.".to_string())
+    }
+}
+
+pub fn serialise_guilds_with_channels(ids: &Vec<String>) -> Result<Vec<JsonValue>, String> {
+    let guilds = fetch_guilds(&ids)?;
+    let cids: Vec<String> = guilds.iter().flat_map(|x| x.channels.clone()).collect();
+
+    let channels = fetch_channels(&cids)?;
+    Ok(guilds
+        .into_iter()
+        .map(|x| {
+            let id = x.id.clone();
+            let mut obj = x.serialise();
+            obj.as_object_mut().unwrap().insert(
+                "channels".to_string(),
+                channels
+                    .iter()
+                    .filter(|x| x.guild.is_some() && x.guild.as_ref().unwrap() == &id)
+                    .map(|x| x.clone().serialise())
+                    .collect(),
+            );
+            obj
+        })
+        .collect())
+}
+
+pub fn fetch_member(key: MemberKey) -> Result<Option<Member>, String> {
+    {
+        if let Ok(mut cache) = MEMBER_CACHE.lock() {
+            let existing = cache.get(&key);
+
+            if let Some(member) = existing {
+                return Ok(Some((*member).clone()));
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    let col = get_collection("members");
+    if let Ok(result) = col.find_one(
+        doc! {
+            "_id.guild": &key.0,
+            "_id.user": &key.1,
+        },
+        None,
+    ) {
+        if let Some(doc) = result {
+            if let Ok(member) = from_bson(Bson::Document(doc)) as Result<Member, _> {
+                let mut cache = MEMBER_CACHE.lock().unwrap();
+                cache.put(key, member.clone());
+
+                Ok(Some(member))
+            } else {
+                Err("Failed to deserialize member!".to_string())
+            }
+        } else {
+            Ok(None)
+        }
+    } else {
+        Err("Failed to fetch member from database.".to_string())
+    }
+}
+
 impl<'r> FromParam<'r> for Guild {
    type Error = &'r RawStr;

@@ -101,24 +246,6 @@ impl<'r> FromParam<'r> for Guild {
    }
 }

-pub fn get_member(guild_id: &String, member: &String) -> Option<Member> {
-    if let Ok(result) = get_collection("members").find_one(
-        doc! {
-            "_id.guild": &guild_id,
-            "_id.user": &member,
-        },
-        None,
-    ) {
-        if let Some(doc) = result {
-            Some(from_bson(Bson::Document(doc)).expect("Failed to unwrap member."))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
 pub fn get_invite<U: Into<Option<String>>>(
    code: &String,
    user: U,
@@ -176,3 +303,34 @@ pub fn get_invite<U: Into<Option<String>>>(
        None
    }
 }
+
+use crate::notifications::events::Notification;
+
+pub fn process_event(event: &Notification) {
+    match event {
+        Notification::guild_channel_create(_ev) => {} // ? for later use
+        Notification::guild_channel_delete(_ev) => {} // ? for later use
+        Notification::guild_delete(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            cache.pop(&ev.id);
+        }
+        Notification::guild_user_join(ev) => {
+            let mut cache = MEMBER_CACHE.lock().unwrap();
+            cache.put(
+                MemberKey(ev.id.clone(), ev.user.clone()),
+                Member {
+                    id: MemberRef {
+                        guild: ev.id.clone(),
+                        user: ev.user.clone(),
+                    },
+                    nickname: None,
+                },
+            );
+        }
+        Notification::guild_user_leave(ev) => {
+            let mut cache = MEMBER_CACHE.lock().unwrap();
+            cache.pop(&MemberKey(ev.id.clone(), ev.user.clone()));
+        }
+        _ => {}
+    }
+}
--- a/src/database/migrations/init.rs
+++ b/src/database/migrations/init.rs
@@ -0,0 +1,45 @@
+use super::super::get_db;
+use super::scripts::LATEST_REVISION;
+
+use log::info;
+use mongodb::bson::doc;
+use mongodb::options::CreateCollectionOptions;
+
+pub fn create_database() {
+    info!("Creating database.");
+    let db = get_db();
+
+    db.create_collection("users", None)
+        .expect("Failed to create users collection.");
+    db.create_collection("channels", None)
+        .expect("Failed to create channels collection.");
+    db.create_collection("guilds", None)
+        .expect("Failed to create guilds collection.");
+    db.create_collection("members", None)
+        .expect("Failed to create members collection.");
+    db.create_collection("messages", None)
+        .expect("Failed to create messages collection.");
+    db.create_collection("migrations", None)
+        .expect("Failed to create migrations collection.");
+
+    db.create_collection(
+        "pubsub",
+        CreateCollectionOptions::builder()
+            .capped(true)
+            .size(1_000_000)
+            .build(),
+    )
+    .expect("Failed to create pubsub collection.");
+
+    db.collection("migrations")
+        .insert_one(
+            doc! {
+                "_id": 0,
+                "revision": LATEST_REVISION
+            },
+            None,
+        )
+        .expect("Failed to save migration info.");
+
+    info!("Created database.");
+}
--- a/src/database/migrations/mod.rs
+++ b/src/database/migrations/mod.rs
@@ -0,0 +1,18 @@
+use super::get_connection;
+
+pub mod init;
+pub mod scripts;
+
+pub fn run_migrations() {
+    let client = get_connection();
+
+    let list = client
+        .list_database_names(None, None)
+        .expect("Failed to fetch database names.");
+
+    if list.iter().position(|x| x == "revolt").is_none() {
+        init::create_database();
+    } else {
+        scripts::migrate_database();
+    }
+}
--- a/src/database/migrations/scripts.rs
+++ b/src/database/migrations/scripts.rs
@@ -0,0 +1,119 @@
+use super::super::get_collection;
+
+use log::info;
+use mongodb::bson::{doc, from_bson, Bson};
+use mongodb::options::FindOptions;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct MigrationInfo {
+    _id: i32,
+    revision: i32,
+}
+
+pub const LATEST_REVISION: i32 = 2;
+
+pub fn migrate_database() {
+    let migrations = get_collection("migrations");
+    let data = migrations
+        .find_one(None, None)
+        .expect("Failed to fetch migration data.");
+
+    if let Some(doc) = data {
+        let info: MigrationInfo =
+            from_bson(Bson::Document(doc)).expect("Failed to read migration information.");
+
+        let revision = run_migrations(info.revision);
+
+        migrations
+            .update_one(
+                doc! {
+                    "_id": info._id
+                },
+                doc! {
+                    "$set": {
+                        "revision": revision
+                    }
+                },
+                None,
+            )
+            .expect("Failed to commit migration information.");
+
+        info!("Migration complete. Currently at revision {}.", revision);
+    } else {
+        panic!("Database was configured incorrectly, possibly because initalization failed.")
+    }
+}
+
+pub fn run_migrations(revision: i32) -> i32 {
+    info!("Starting database migration.");
+
+    if revision <= 0 {
+        info!("Running migration [revision 0]: Test migration system.");
+    }
+
+    if revision <= 1 {
+        info!("Running migration [revision 1]: Add channels to guild object.");
+
+        let col = get_collection("guilds");
+        let guilds = col
+            .find(
+                None,
+                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+            )
+            .expect("Failed to fetch guilds.");
+
+        let result = get_collection("channels")
+            .find(
+                doc! {
+                    "type": 2
+                },
+                FindOptions::builder()
+                    .projection(doc! { "_id": 1, "guild": 1 })
+                    .build(),
+            )
+            .expect("Failed to fetch channels.");
+
+        let mut channels = vec![];
+        for doc in result {
+            let channel = doc.expect("Failed to fetch channel.");
+            let id = channel
+                .get_str("_id")
+                .expect("Failed to get channel id.")
+                .to_string();
+            let gid = channel
+                .get_str("guild")
+                .expect("Failed to get guild id.")
+                .to_string();
+
+            channels.push((id, gid));
+        }
+
+        for doc in guilds {
+            let guild = doc.expect("Failed to fetch guild.");
+            let id = guild.get_str("_id").expect("Failed to get guild id.");
+
+            let list: Vec<String> = channels
+                .iter()
+                .filter(|x| x.1 == id)
+                .map(|x| x.0.clone())
+                .collect();
+
+            col.update_one(
+                doc! {
+                    "_id": id
+                },
+                doc! {
+                    "$set": {
+                        "channels": list
+                    }
+                },
+                None,
+            )
+            .expect("Failed to update guild.");
+        }
+    }
+
+    // Reminder to update LATEST_REVISION when adding new migrations.
+    LATEST_REVISION
+}
--- a/src/database/mod.rs
+++ b/src/database/mod.rs
@@ -1,22 +1,15 @@
-use mongodb::bson::doc;
-use mongodb::sync::{Client, Collection, Database};
-use std::env;
+use crate::util::variables::MONGO_URI;

+use mongodb::sync::{Client, Collection, Database};
 use once_cell::sync::OnceCell;
+
 static DBCONN: OnceCell<Client> = OnceCell::new();

 pub fn connect() {
-    let client =
-        Client::with_uri_str(&env::var("DB_URI").expect("DB_URI not in environment variables!"))
-            .expect("Failed to init db connection.");
-
-    client
-        .database("revolt")
-        .collection("migrations")
-        .find(doc! {}, None)
-        .expect("Failed to get migration data from database.");
+    let client = Client::with_uri_str(&MONGO_URI).expect("Failed to init db connection.");

    DBCONN.set(client).unwrap();
+    migrations::run_migrations();
 }

 pub fn get_connection() -> &'static Client {
@@ -31,6 +24,8 @@ pub fn get_collection(collection: &str) -> Collection {
    get_db().collection(collection)
 }

+pub mod migrations;
+
 pub mod channel;
 pub mod guild;
 pub mod message;
--- a/src/database/mutual.rs
+++ b/src/database/mutual.rs
@@ -118,12 +118,10 @@ pub fn has_mutual_connection(user_id: &str, target_id: &str, with_permission: bo
            }

            false
+        } else if result.count() > 0 {
+            true
        } else {
-            if result.count() > 0 {
-                true
-            } else {
-                false
-            }
+            false
        }
    } else {
        false
--- a/src/database/permissions.rs
+++ b/src/database/permissions.rs
@@ -1,8 +1,7 @@
 use super::mutual::has_mutual_connection;
 use crate::database::channel::Channel;
-use crate::database::guild::{fetch_guild, get_member, Guild, Member};
-use crate::database::user::UserRelationship;
-use crate::guards::auth::UserRef;
+use crate::database::guild::{fetch_guild, fetch_member, Guild, Member, MemberKey};
+use crate::database::user::{User, UserRelationship};

 use num_enum::TryFromPrimitive;

@@ -77,23 +76,23 @@ pub fn get_relationship_internal(
    Relationship::NONE
 }

-pub fn get_relationship(a: &UserRef, b: &UserRef) -> Relationship {
+pub fn get_relationship(a: &User, b: &User) -> Relationship {
    if a.id == b.id {
        return Relationship::SELF;
    }

-    get_relationship_internal(&a.id, &b.id, &a.fetch_relationships())
+    get_relationship_internal(&a.id, &b.id, &a.relations)
 }

 pub struct PermissionCalculator {
-    pub user: UserRef,
+    pub user: User,
    pub channel: Option<Channel>,
    pub guild: Option<Guild>,
    pub member: Option<Member>,
 }

 impl PermissionCalculator {
-    pub fn new(user: UserRef) -> PermissionCalculator {
+    pub fn new(user: User) -> PermissionCalculator {
        PermissionCalculator {
            user,
            channel: None,
@@ -140,7 +139,9 @@ impl PermissionCalculator {
        };

        if let Some(guild) = &guild {
-            self.member = get_member(&guild.id, &self.user.id);
+            if let Ok(result) = fetch_member(MemberKey(guild.id.clone(), self.user.id.clone())) {
+                self.member = result;
+            }
        }

        self.guild = guild;
@@ -164,32 +165,34 @@ impl PermissionCalculator {
            match channel.channel_type {
                0 => {
                    if let Some(arr) = &channel.recipients {
-                        let mut other_user = "";
+                        let mut other_user = None;
                        for item in arr {
                            if item != &self.user.id {
-                                other_user = item;
+                                other_user = Some(item);
                            }
                        }

-                        // ? In this case, it is a "self DM".
-                        if other_user == "" {
-                            return 1024 + 128 + 32 + 16 + 1;
-                        }
+                        if let Some(other) = other_user {
+                            let relationship = get_relationship_internal(
+                                &self.user.id,
+                                &other,
+                                &self.user.relations,
+                            );

-                        let relationships = self.user.fetch_relationships();
-                        let relationship =
-                            get_relationship_internal(&self.user.id, &other_user, &relationships);
-
-                        if relationship == Relationship::Friend {
-                            permissions = 1024 + 128 + 32 + 16 + 1;
-                        } else if relationship == Relationship::Blocked
-                            || relationship == Relationship::BlockedOther
-                        {
-                            permissions = 1;
-                        } else if has_mutual_connection(&self.user.id, other_user, true) {
-                            permissions = 1024 + 128 + 32 + 16 + 1;
+                            if relationship == Relationship::Friend {
+                                permissions = 1024 + 128 + 32 + 16 + 1;
+                            } else if relationship == Relationship::Blocked
+                                || relationship == Relationship::BlockedOther
+                            {
+                                permissions = 1;
+                            } else if has_mutual_connection(&self.user.id, other, true) {
+                                permissions = 1024 + 128 + 32 + 16 + 1;
+                            } else {
+                                permissions = 1;
+                            }
                        } else {
-                            permissions = 1;
+                            // ? In this case, it is a "self DM".
+                            return 1024 + 128 + 32 + 16 + 1;
                        }
                    }
                }
--- a/src/database/user.rs
+++ b/src/database/user.rs
@@ -1,5 +1,16 @@
-use mongodb::bson::DateTime;
+use super::channel::fetch_channels;
+use super::get_collection;
+use super::guild::serialise_guilds_with_channels;
+
+use lru::LruCache;
+use mongodb::bson::{doc, from_bson, Bson, DateTime};
+use mongodb::options::FindOptions;
+use rocket::http::{RawStr, Status};
+use rocket::request::{self, FromParam, FromRequest, Request};
+use rocket::Outcome;
+use rocket_contrib::json::JsonValue;
 use serde::{Deserialize, Serialize};
+use std::sync::{Arc, Mutex};

 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct UserEmailVerification {
@@ -28,3 +39,262 @@ pub struct User {
    pub email_verification: UserEmailVerification,
    pub relations: Option<Vec<UserRelationship>>,
 }
+
+impl User {
+    pub fn serialise(self, relationship: i32) -> JsonValue {
+        if relationship == super::Relationship::SELF as i32 {
+            json!({
+                "id": self.id,
+                "username": self.username,
+                "display_name": self.display_name,
+                "email": self.email,
+                "verified": self.email_verification.verified,
+            })
+        } else {
+            json!({
+                "id": self.id,
+                "username": self.username,
+                "display_name": self.display_name,
+                "relationship": relationship
+            })
+        }
+    }
+
+    pub fn find_guilds(&self) -> Result<Vec<String>, String> {
+        let members = get_collection("members")
+            .find(
+                doc! {
+                    "_id.user": &self.id
+                },
+                None,
+            )
+            .map_err(|_| "Failed to fetch members.")?;
+
+        Ok(members
+            .into_iter()
+            .filter_map(|x| match x {
+                Ok(doc) => match doc.get_document("_id") {
+                    Ok(id) => match id.get_str("guild") {
+                        Ok(value) => Some(value.to_string()),
+                        Err(_) => None,
+                    },
+                    Err(_) => None,
+                },
+                Err(_) => None,
+            })
+            .collect())
+    }
+
+    pub fn find_dms(&self) -> Result<Vec<String>, String> {
+        let channels = get_collection("channels")
+            .find(
+                doc! {
+                    "recipients": &self.id
+                },
+                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+            )
+            .map_err(|_| "Failed to fetch channel ids.")?;
+
+        Ok(channels
+            .into_iter()
+            .filter_map(|x| x.ok())
+            .filter_map(|x| match x.get_str("_id") {
+                Ok(value) => Some(value.to_string()),
+                Err(_) => None,
+            })
+            .collect())
+    }
+
+    pub fn create_payload(self) -> Result<JsonValue, String> {
+        let v = vec![];
+        let relations = self.relations.as_ref().unwrap_or(&v);
+
+        let users: Vec<JsonValue> = fetch_users(&relations.iter().map(|x| x.id.clone()).collect())?
+            .into_iter()
+            .map(|x| {
+                let id = x.id.clone();
+                x.serialise(relations.iter().find(|y| y.id == id).unwrap().status as i32)
+            })
+            .collect();
+
+        let channels: Vec<JsonValue> = fetch_channels(&self.find_dms()?)?
+            .into_iter()
+            .map(|x| x.serialise())
+            .collect();
+
+        Ok(json!({
+            "users": users,
+            "channels": channels,
+            "guilds": serialise_guilds_with_channels(&self.find_guilds()?)?,
+            "user": self.serialise(super::Relationship::SELF as i32)
+        }))
+    }
+}
+
+lazy_static! {
+    static ref CACHE: Arc<Mutex<LruCache<String, User>>> =
+        Arc::new(Mutex::new(LruCache::new(4_000_000)));
+}
+
+pub fn fetch_user(id: &str) -> Result<Option<User>, String> {
+    {
+        if let Ok(mut cache) = CACHE.lock() {
+            let existing = cache.get(&id.to_string());
+
+            if let Some(user) = existing {
+                return Ok(Some((*user).clone()));
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    let col = get_collection("users");
+    if let Ok(result) = col.find_one(doc! { "_id": id }, None) {
+        if let Some(doc) = result {
+            if let Ok(user) = from_bson(Bson::Document(doc)) as Result<User, _> {
+                let mut cache = CACHE.lock().unwrap();
+                cache.put(id.to_string(), user.clone());
+
+                Ok(Some(user))
+            } else {
+                Err("Failed to deserialize user!".to_string())
+            }
+        } else {
+            Ok(None)
+        }
+    } else {
+        Err("Failed to fetch user from database.".to_string())
+    }
+}
+
+pub fn fetch_users(ids: &Vec<String>) -> Result<Vec<User>, String> {
+    let mut missing = vec![];
+    let mut users = vec![];
+
+    {
+        if let Ok(mut cache) = CACHE.lock() {
+            for id in ids {
+                let existing = cache.get(id);
+
+                if let Some(user) = existing {
+                    users.push((*user).clone());
+                } else {
+                    missing.push(id);
+                }
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    if missing.len() == 0 {
+        return Ok(users);
+    }
+
+    let col = get_collection("users");
+    if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
+        for item in result {
+            let mut cache = CACHE.lock().unwrap();
+            if let Ok(doc) = item {
+                if let Ok(user) = from_bson(Bson::Document(doc)) as Result<User, _> {
+                    cache.put(user.id.clone(), user.clone());
+                    users.push(user);
+                } else {
+                    return Err("Failed to deserialize user!".to_string());
+                }
+            } else {
+                return Err("Failed to fetch user.".to_string());
+            }
+        }
+
+        Ok(users)
+    } else {
+        Err("Failed to fetch user from database.".to_string())
+    }
+}
+
+#[derive(Debug)]
+pub enum AuthError {
+    Failed,
+    Missing,
+    Invalid,
+}
+
+impl<'a, 'r> FromRequest<'a, 'r> for User {
+    type Error = AuthError;
+
+    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let u = request.headers().get("x-user").next();
+        let t = request.headers().get("x-auth-token").next();
+
+        if let Some(uid) = u {
+            if let Some(token) = t {
+                if let Ok(result) = fetch_user(uid) {
+                    if let Some(user) = result {
+                        if let Some(access_token) = &user.access_token {
+                            if access_token == token {
+                                Outcome::Success(user)
+                            } else {
+                                Outcome::Failure((Status::Forbidden, AuthError::Invalid))
+                            }
+                        } else {
+                            Outcome::Failure((Status::Forbidden, AuthError::Invalid))
+                        }
+                    } else {
+                        Outcome::Failure((Status::Forbidden, AuthError::Invalid))
+                    }
+                } else {
+                    Outcome::Failure((Status::Forbidden, AuthError::Failed))
+                }
+            } else {
+                Outcome::Failure((Status::Forbidden, AuthError::Missing))
+            }
+        } else {
+            Outcome::Failure((Status::Forbidden, AuthError::Missing))
+        }
+    }
+}
+
+impl<'r> FromParam<'r> for User {
+    type Error = &'r RawStr;
+
+    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
+        if let Ok(result) = fetch_user(&param.to_string()) {
+            if let Some(user) = result {
+                Ok(user)
+            } else {
+                Err(param)
+            }
+        } else {
+            Err(param)
+        }
+    }
+}
+
+use crate::notifications::events::Notification;
+
+pub fn process_event(event: &Notification) {
+    match event {
+        Notification::user_friend_status(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            if let Some(user) = cache.peek_mut(&ev.id) {
+                if let Some(relations) = user.relations.as_mut() {
+                    if ev.status == 0 {
+                        if let Some(pos) = relations.iter().position(|x| x.id == ev.user) {
+                            relations.remove(pos);
+                        }
+                    } else if let Some(entry) = relations.iter_mut().find(|x| x.id == ev.user) {
+                        entry.status = ev.status as u8;
+                    } else {
+                        relations.push(UserRelationship {
+                            id: ev.id.clone(),
+                            status: ev.status as u8,
+                        });
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+}
--- a/src/email.rs
+++ b/src/email.rs
@@ -1,61 +0,0 @@
-use reqwest::blocking::Client;
-use std::collections::HashMap;
-use std::env;
-
-fn public_uri() -> String {
-    env::var("PUBLIC_URI").expect("PUBLIC_URI not in environment variables!")
-}
-
-fn portal() -> String {
-    env::var("PORTAL_URL").expect("PORTAL_URL not in environment variables!")
-}
-
-pub fn send_email(target: String, subject: String, body: String, html: String) -> Result<(), ()> {
-    let mut map = HashMap::new();
-    map.insert("target", target.clone());
-    map.insert("subject", subject);
-    map.insert("body", body);
-    map.insert("html", html);
-
-    let client = Client::new();
-    match client.post(&portal()).json(&map).send() {
-        Ok(_) => Ok(()),
-        Err(_) => Err(()),
-    }
-}
-
-pub fn send_verification_email(email: String, code: String) -> bool {
-    let url = format!("{}/api/account/verify/{}", public_uri(), code);
-    send_email(
-        email,
-        "Verify your email!".to_string(),
-        format!("Verify your email here: {}", url),
-        format!("<a href=\"{}\">Click to verify your email!</a>", url),
-    )
-    .is_ok()
-}
-
-pub fn send_password_reset(email: String, code: String) -> bool {
-    let url = format!("{}/api/account/reset/{}", public_uri(), code);
-    send_email(
-        email,
-        "Reset your password.".to_string(),
-        format!("Reset your password here: {}", url),
-        format!("<a href=\"{}\">Click to reset your password!</a>", url),
-    )
-    .is_ok()
-}
-
-pub fn send_welcome_email(email: String, username: String) -> bool {
-    send_email(
-        email,
-        "Welcome to REVOLT!".to_string(),
-        format!("Welcome, {}! You can now use REVOLT.", username.clone()),
-        format!(
-            "<b>Welcome, {}!</b><br/>You can now use REVOLT.<br/><a href=\"{}\">Go to REVOLT</a>",
-            username.clone(),
-            public_uri()
-        ),
-    )
-    .is_ok()
-}
--- a/src/guards/auth.rs
+++ b/src/guards/auth.rs
@@ -1,167 +0,0 @@
-use mongodb::bson::{doc, from_bson, Bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::{RawStr, Status};
-use rocket::request::{self, FromParam, FromRequest, Request};
-use rocket::Outcome;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-use database::user::{User, UserRelationship};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserRef {
-    pub id: String,
-    pub username: String,
-    pub display_name: String,
-    pub email_verified: bool,
-}
-
-impl UserRef {
-    pub fn from(id: String) -> Option<UserRef> {
-        match database::get_collection("users").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "username": 1,
-                    "display_name": 1,
-                    "email_verification.verified": 1,
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => Some(UserRef {
-                    id: doc.get_str("_id").unwrap().to_string(),
-                    username: doc.get_str("username").unwrap().to_string(),
-                    display_name: doc.get_str("display_name").unwrap().to_string(),
-                    email_verified: doc
-                        .get_document("email_verification")
-                        .unwrap()
-                        .get_bool("verified")
-                        .unwrap(),
-                }),
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("users")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch user from database.")
-    }
-
-    pub fn fetch_relationships(&self) -> Option<Vec<UserRelationship>> {
-        let user = database::get_collection("users")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder()
-                    .projection(doc! { "relations": 1 })
-                    .build(),
-            )
-            .expect("Failed to fetch user relationships from database.")
-            .expect("Missing user document.");
-
-        if let Ok(arr) = user.get_array("relations") {
-            let mut relationships = vec![];
-            for item in arr {
-                relationships.push(from_bson(item.clone()).unwrap());
-            }
-
-            Some(relationships)
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum AuthError {
-    BadCount,
-    Missing,
-    Invalid,
-}
-
-impl<'a, 'r> FromRequest<'a, 'r> for UserRef {
-    type Error = AuthError;
-
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let keys: Vec<_> = request.headers().get("x-auth-token").collect();
-        match keys.len() {
-            0 => Outcome::Failure((Status::Forbidden, AuthError::Missing)),
-            1 => {
-                let key = keys[0];
-                let result = database::get_collection("users")
-                    .find_one(
-                        doc! { "access_token": key },
-                        FindOneOptions::builder()
-                            .projection(doc! {
-                                "_id": 1,
-                                "username": 1,
-                                "display_name": 1,
-                                "email_verification.verified": 1,
-                            })
-                            .build(),
-                    )
-                    .unwrap();
-
-                if let Some(user) = result {
-                    Outcome::Success(UserRef {
-                        id: user.get_str("_id").unwrap().to_string(),
-                        username: user.get_str("username").unwrap().to_string(),
-                        display_name: user.get_str("display_name").unwrap().to_string(),
-                        email_verified: user
-                            .get_document("email_verification")
-                            .unwrap()
-                            .get_bool("verified")
-                            .unwrap(),
-                    })
-                } else {
-                    Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                }
-            }
-            _ => Outcome::Failure((Status::BadRequest, AuthError::BadCount)),
-        }
-    }
-}
-
-impl<'a, 'r> FromRequest<'a, 'r> for User {
-    type Error = AuthError;
-
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let keys: Vec<_> = request.headers().get("x-auth-token").collect();
-        match keys.len() {
-            0 => Outcome::Failure((Status::Forbidden, AuthError::Missing)),
-            1 => {
-                let key = keys[0];
-                let col = database::get_collection("users");
-                let result = col.find_one(doc! { "access_token": key }, None).unwrap();
-
-                if let Some(user) = result {
-                    Outcome::Success(
-                        from_bson(Bson::Document(user)).expect("Failed to unwrap user."),
-                    )
-                } else {
-                    Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                }
-            }
-            _ => Outcome::Failure((Status::BadRequest, AuthError::BadCount)),
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for UserRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(user) = UserRef::from(param.to_string()) {
-            Ok(user)
-        } else {
-            Err(param)
-        }
-    }
-}
--- a/src/guards/guild.rs
+++ b/src/guards/guild.rs
@@ -1,153 +0,0 @@
-use mongodb::bson::{doc, from_bson, Bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-use crate::database::guild::{Ban, Invite, Member};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct GuildRef {
-    #[serde(rename = "_id")]
-    pub id: String,
-    pub name: String,
-    pub description: String,
-    pub owner: String,
-
-    pub bans: Vec<Ban>,
-
-    pub default_permissions: i32,
-}
-
-impl GuildRef {
-    pub fn from(id: String) -> Option<GuildRef> {
-        match database::get_collection("guilds").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "name": 1,
-                    "description": 1,
-                    "owner": 1,
-                    "bans": 1,
-                    "default_permissions": 1
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => {
-                    Some(from_bson(mongodb::bson::mongodb::bson::Document(doc)).expect("Failed to unwrap guild."))
-                }
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("guilds")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch guild from database.")
-    }
-
-    pub fn fetch_data_given(&self, mut filter: Document, projection: Document) -> Option<Document> {
-        filter.insert("_id", self.id.clone());
-        database::get_collection("guilds")
-            .find_one(
-                filter,
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch guild from database.")
-    }
-}
-
-impl<'r> FromParam<'r> for GuildRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(guild) = GuildRef::from(param.to_string()) {
-            Ok(guild)
-        } else {
-            Err(param)
-        }
-    }
-}
-
-pub fn get_member(guild_id: &String, member: &String) -> Option<Member> {
-    if let Ok(result) = database::get_collection("members").find_one(
-        doc! {
-            "_id.guild": &guild_id,
-            "_id.user": &member,
-        },
-        None,
-    ) {
-        if let Some(doc) = result {
-            Some(from_bson(mongodb::bson::Document(doc)).expect("Failed to unwrap member."))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
-pub fn get_invite<U: Into<Option<String>>>(
-    code: &String,
-    user: U,
-) -> Option<(String, String, Invite)> {
-    let mut doc = doc! {
-        "invites": {
-            "$elemMatch": {
-                "code": &code
-            }
-        }
-    };
-
-    if let Some(user_id) = user.into() {
-        doc.insert(
-            "bans",
-            doc! {
-                "$not": {
-                    "$elemMatch": {
-                        "id": user_id
-                    }
-                }
-            },
-        );
-    }
-
-    if let Ok(result) = database::get_collection("guilds").find_one(
-        doc,
-        FindOneOptions::builder()
-            .projection(doc! {
-                "_id": 1,
-                "name": 1,
-                "invites.$": 1,
-            })
-            .build(),
-    ) {
-        if let Some(doc) = result {
-            let invite = doc
-                .get_array("invites")
-                .unwrap()
-                .iter()
-                .next()
-                .unwrap()
-                .as_document()
-                .unwrap();
-
-            Some((
-                doc.get_str("_id").unwrap().to_string(),
-                doc.get_str("name").unwrap().to_string(),
-                from_bson(mongodb::bson::Document(invite.clone())).unwrap(),
-            ))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
--- a/src/guards/mod.rs
+++ b/src/guards/mod.rs
@@ -1 +0,0 @@
-pub mod auth;
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,18 +10,24 @@ extern crate bitfield;
 extern crate lazy_static;

 pub mod database;
-pub mod email;
-pub mod guards;
 pub mod notifications;
 pub mod routes;
 pub mod util;

-use dotenv;
 use rocket_cors::AllowedOrigins;
 use std::thread;
+use log::info;

 fn main() {
    dotenv::dotenv().ok();
+    env_logger::init_from_env(
+        env_logger::Env::default()
+            .filter_or("RUST_LOG", "info")
+    );
+
+    info!("Starting REVOLT server.");
+
+    util::variables::preflight_checks();
    database::connect();
    notifications::start_worker();

--- a/src/notifications/events/mod.rs
+++ b/src/notifications/events/mod.rs
@@ -38,4 +38,10 @@ impl Notification {
            unreachable!()
        }
    }
+
+    pub fn push_to_cache(&self) {
+        crate::database::channel::process_event(&self);
+        crate::database::guild::process_event(&self);
+        crate::database::user::process_event(&self);
+    }
 }
--- a/src/notifications/events/users.rs
+++ b/src/notifications/events/users.rs
@@ -3,5 +3,6 @@ use serde::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct FriendStatus {
    pub id: String,
+    pub user: String,
    pub status: i32,
 }
--- a/src/notifications/mod.rs
+++ b/src/notifications/mod.rs
@@ -17,6 +17,8 @@ pub fn send_message<U: Into<Option<Vec<String>>>, G: Into<Option<String>>>(
    let users = users.into();
    let guild = guild.into();

+    data.push_to_cache();
+
    if pubsub::send_message(users.clone(), guild.clone(), data.clone()) {
        state::send_message(users, guild, data.serialize());

--- a/src/notifications/ws.rs
+++ b/src/notifications/ws.rs
@@ -1,7 +1,7 @@
 use super::state::{self, StateResult};
+use crate::util::variables::WS_HOST;

 use serde_json::{from_str, json, Value};
-use std::env;
 use ulid::Ulid;
 use ws::{listen, CloseCode, Error, Handler, Handshake, Message, Result, Sender};

@@ -36,14 +36,33 @@ impl Handler for Server {

                            match state.try_authenticate(self.id.clone(), token.to_string()) {
                                StateResult::Success(user_id) => {
+                                    let user = crate::database::user::fetch_user(&user_id)
+                                        .unwrap()
+                                        .unwrap();
                                    self.user_id = Some(user_id);
+
                                    self.sender.send(
                                        json!({
                                            "type": "authenticate",
                                            "success": true,
                                        })
                                        .to_string(),
-                                    )
+                                    )?;
+
+                                    if let Ok(payload) = user.create_payload() {
+                                        self.sender.send(
+                                            json!({
+                                                "type": "ready",
+                                                "data": payload
+                                            })
+                                            .to_string(),
+                                        )
+                                    } else {
+                                        // ! TODO: FIXME: ALL THE NOTIFICATIONS CODE NEEDS TO BE
+                                        // ! RESTRUCTURED, IT IS UTTER GARBAGE. :)))))
+
+                                        Ok(())
+                                    }
                                }
                                StateResult::DatabaseError => self.sender.send(
                                    json!({
@@ -107,13 +126,10 @@ impl Handler for Server {
 pub fn launch_server() {
    state::init();

-    listen(
-        env::var("WS_HOST").unwrap_or("0.0.0.0:9999".to_string()),
-        |sender| Server {
-            sender,
-            user_id: None,
-            id: Ulid::new().to_string(),
-        },
-    )
+    listen(WS_HOST.to_string(), |sender| Server {
+        sender,
+        user_id: None,
+        id: Ulid::new().to_string(),
+    })
    .unwrap()
 }
--- a/src/routes/account.rs
+++ b/src/routes/account.rs
@@ -1,11 +1,12 @@
 use super::Response;
 use crate::database;
-use crate::email;
-use crate::util::gen_token;
+use crate::util::{captcha, email, gen_token};
+use crate::util::variables::{DISABLE_REGISTRATION, USE_EMAIL};

 use bcrypt::{hash, verify};
 use chrono::prelude::*;
 use database::user::User;
+use log::error;
 use mongodb::bson::{doc, from_bson, Bson};
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
@@ -17,6 +18,7 @@ pub struct Create {
    username: String,
    password: String,
    email: String,
+    captcha: Option<String>,
 }

 /// create a new Revolt account
@@ -28,6 +30,14 @@ pub struct Create {
 /// (3) add user and send email verification
 #[post("/create", data = "<info>")]
 pub fn create(info: Json<Create>) -> Response {
+    if let Err(error) = captcha::verify(&info.captcha) {
+        return Response::BadRequest(json!({ "error": error }));
+    }
+
+    if *DISABLE_REGISTRATION {
+        return Response::BadRequest(json!({ "error": "Registration disabled." }));
+    }
+
    let col = database::get_collection("users");

    if info.username.len() < 2 || info.username.len() > 32 {
@@ -64,30 +74,45 @@ pub fn create(info: Json<Create>) -> Response {
        let access_token = gen_token(92);
        let code = gen_token(48);

+        let email_verification = match *USE_EMAIL {
+            true => doc! {
+                "verified": false,
+                "target": info.email.clone(),
+                "expiry": Bson::DateTime(Utc::now() + chrono::Duration::days(1)),
+                "rate_limit": Bson::DateTime(Utc::now() + chrono::Duration::minutes(1)),
+                "code": code.clone(),
+            },
+            false => doc! {
+                "verified": true
+            }
+        };
+
+        let id = Ulid::new().to_string();
        match col.insert_one(
            doc! {
-                "_id": Ulid::new().to_string(),
+                "_id": &id,
                "email": info.email.clone(),
                "username": info.username.clone(),
                "display_name": info.username.clone(),
                "password": hashed,
-                "access_token": access_token,
-                "email_verification": {
-                    "verified": false,
-                    "target": info.email.clone(),
-                    "expiry": Bson::DateTime(Utc::now() + chrono::Duration::days(1)),
-                    "rate_limit": Bson::DateTime(Utc::now() + chrono::Duration::minutes(1)),
-                    "code": code.clone(),
-                }
+                "access_token": &access_token,
+                "email_verification": email_verification
            },
            None,
        ) {
            Ok(_) => {
-                let sent = email::send_verification_email(info.email.clone(), code);
+                if *USE_EMAIL {
+                    let sent = email::send_verification_email(info.email.clone(), code);

-                Response::Success(json!({
-                    "email_sent": sent,
-                }))
+                    Response::Success(json!({
+                        "email_sent": sent,
+                    }))
+                } else {
+                    Response::Success(json!({
+                        "id": id,
+                        "access_token": access_token
+                    }))
+                }
            }
            Err(_) => {
                Response::InternalServerError(json!({ "error": "Failed to create account." }))
@@ -138,7 +163,11 @@ pub fn verify_email(code: String) -> Response {
            )
            .expect("Failed to update user!");

-            email::send_welcome_email(target.to_string(), user.username);
+            if *USE_EMAIL {
+                if let Err(err) = email::send_welcome_email(target.to_string(), user.username) {
+                    error!("Failed to send welcome email! {}", err);
+                }
+            }

            Response::Redirect(super::Redirect::to("https://app.revolt.chat"))
        }
@@ -150,6 +179,7 @@ pub fn verify_email(code: String) -> Response {
 #[derive(Serialize, Deserialize)]
 pub struct Resend {
    email: String,
+    captcha: Option<String>,
 }

 /// resend a verification email
@@ -158,6 +188,10 @@ pub struct Resend {
 /// (3) resend the email
 #[post("/resend", data = "<info>")]
 pub fn resend_email(info: Json<Resend>) -> Response {
+    if let Err(error) = captcha::verify(&info.captcha) {
+        return Response::BadRequest(json!({ "error": error }));
+    }
+
    let col = database::get_collection("users");

    if let Some(u) = col
@@ -202,12 +236,11 @@ pub fn resend_email(info: Json<Resend>) -> Response {
 					None,
 				).expect("Failed to update user!");

-            match email::send_verification_email(info.email.to_string(), code) {
-                true => Response::Result(super::Status::Ok),
-                false => Response::InternalServerError(
-                    json!({ "error": "Failed to send email! Likely an issue with the backend API." }),
-                ),
+            if let Err(err) = email::send_verification_email(info.email.clone(), code) {
+                return Response::InternalServerError(json!({ "error": err }));
            }
+
+            Response::Result(super::Status::Ok)
        }
    } else {
        Response::NotFound(json!({ "error": "Email not found or pending verification!" }))
@@ -218,6 +251,7 @@ pub fn resend_email(info: Json<Resend>) -> Response {
 pub struct Login {
    email: String,
    password: String,
+    captcha: Option<String>,
 }

 /// login to a Revolt account
@@ -226,6 +260,10 @@ pub struct Login {
 /// (3) return access token
 #[post("/login", data = "<info>")]
 pub fn login(info: Json<Login>) -> Response {
+    if let Err(error) = captcha::verify(&info.captcha) {
+        return Response::BadRequest(json!({ "error": error }));
+    }
+
    let col = database::get_collection("users");

    if let Some(u) = col
--- a/src/routes/channel.rs
+++ b/src/routes/channel.rs
@@ -1,9 +1,8 @@
 use super::Response;
 use crate::database::{
    self, channel::Channel, get_relationship, get_relationship_internal, message::Message,
-    Permission, PermissionCalculator, Relationship,
+    user::User, Permission, PermissionCalculator, Relationship,
 };
-use crate::guards::auth::UserRef;
 use crate::notifications::{
    self,
    events::{groups::*, guilds::ChannelDelete, message::*, Notification},
@@ -53,7 +52,7 @@ pub struct CreateGroup {

 /// create a new group
 #[post("/create", data = "<info>")]
-pub fn create_group(user: UserRef, info: Json<CreateGroup>) -> Response {
+pub fn create_group(user: User, info: Json<CreateGroup>) -> Response {
    let name: String = info.name.chars().take(32).collect();
    let nonce: String = info.nonce.chars().take(32).collect();

@@ -90,13 +89,12 @@ pub fn create_group(user: UserRef, info: Json<CreateGroup>) -> Response {
            return Response::BadRequest(json!({ "error": "Specified non-existant user(s)." }));
        }

-        let relationships = user.fetch_relationships();
        for item in set {
            if item == user.id {
                continue;
            }

-            if get_relationship_internal(&user.id, &item, &relationships) != Relationship::Friend {
+            if get_relationship_internal(&user.id, &item, &user.relations) != Relationship::Friend {
                return Response::BadRequest(json!({ "error": "Not friends with user(s)." }));
            }
        }
@@ -129,58 +127,14 @@ pub fn create_group(user: UserRef, info: Json<CreateGroup>) -> Response {

 /// fetch channel information
 #[get("/<target>")]
-pub fn channel(user: UserRef, target: Channel) -> Option<Response> {
+pub fn channel(user: User, target: Channel) -> Option<Response> {
    with_permissions!(user, target);
-
-    match target.channel_type {
-        0 => Some(Response::Success(json!({
-            "id": target.id,
-            "type": target.channel_type,
-            "last_message": target.last_message,
-            "recipients": target.recipients,
-        }))),
-        1 => {
-            /*if let Some(info) = target.fetch_data(doc! {
-                "name": 1,
-                "description": 1,
-                "owner": 1,
-            }) {*/
-            Some(Response::Success(json!({
-                "id": target.id,
-                "type": target.channel_type,
-                "last_message": target.last_message,
-                "recipients": target.recipients,
-                "name": target.name,
-                "owner": target.owner,
-                "description": target.description,
-            })))
-            /*} else {
-                None
-            }*/
-        }
-        2 => {
-            /*if let Some(info) = target.fetch_data(doc! {
-                "name": 1,
-                "description": 1,
-            }) {*/
-            Some(Response::Success(json!({
-                "id": target.id,
-                "type": target.channel_type,
-                "guild": target.guild,
-                "name": target.name,
-                "description": target.description,
-            })))
-            /*} else {
-                None
-            }*/
-        }
-        _ => unreachable!(),
-    }
+    Some(Response::Success(target.serialise()))
 }

 /// [groups] add user to channel
 #[put("/<target>/recipients/<member>")]
-pub fn add_member(user: UserRef, target: Channel, member: UserRef) -> Option<Response> {
+pub fn add_member(user: User, target: Channel, member: User) -> Option<Response> {
    if target.channel_type != 1 {
        return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
    }
@@ -254,7 +208,7 @@ pub fn add_member(user: UserRef, target: Channel, member: UserRef) -> Option<Res

 /// [groups] remove user from channel
 #[delete("/<target>/recipients/<member>")]
-pub fn remove_member(user: UserRef, target: Channel, member: UserRef) -> Option<Response> {
+pub fn remove_member(user: User, target: Channel, member: User) -> Option<Response> {
    if target.channel_type != 1 {
        return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
    }
@@ -326,7 +280,7 @@ pub fn remove_member(user: UserRef, target: Channel, member: UserRef) -> Option<
 /// or leave group DM
 /// or close DM conversation
 #[delete("/<target>")]
-pub fn delete(user: UserRef, target: Channel) -> Option<Response> {
+pub fn delete(user: User, target: Channel) -> Option<Response> {
    let permissions = with_permissions!(user, target);

    if !permissions.get_manage_channels() {
@@ -449,7 +403,8 @@ pub fn delete(user: UserRef, target: Channel) -> Option<Response> {
                        "$pull": {
                            "invites": {
                                "channel": &target.id
-                            }
+                            },
+                            "channels": &target.id
                        }
                    },
                    None,
@@ -488,7 +443,7 @@ pub struct MessageFetchOptions {
 /// fetch channel messages
 #[get("/<target>/messages?<options..>")]
 pub fn messages(
-    user: UserRef,
+    user: User,
    target: Channel,
    options: Form<MessageFetchOptions>,
 ) -> Option<Response> {
@@ -551,11 +506,7 @@ pub struct SendMessage {

 /// send a message to a channel
 #[post("/<target>/messages", data = "<message>")]
-pub fn send_message(
-    user: UserRef,
-    target: Channel,
-    message: Json<SendMessage>,
-) -> Option<Response> {
+pub fn send_message(user: User, target: Channel, message: Json<SendMessage>) -> Option<Response> {
    let permissions = with_permissions!(user, target);

    if !permissions.get_send_messages() {
@@ -608,7 +559,7 @@ pub fn send_message(

 /// get a message
 #[get("/<target>/messages/<message>")]
-pub fn get_message(user: UserRef, target: Channel, message: Message) -> Option<Response> {
+pub fn get_message(user: User, target: Channel, message: Message) -> Option<Response> {
    let permissions = with_permissions!(user, target);

    if !permissions.get_read_messages() {
@@ -641,7 +592,7 @@ pub struct EditMessage {
 /// edit a message
 #[patch("/<target>/messages/<message>", data = "<edit>")]
 pub fn edit_message(
-    user: UserRef,
+    user: User,
    target: Channel,
    message: Message,
    edit: Json<EditMessage>,
@@ -699,13 +650,11 @@ pub fn edit_message(

 /// delete a message
 #[delete("/<target>/messages/<message>")]
-pub fn delete_message(user: UserRef, target: Channel, message: Message) -> Option<Response> {
+pub fn delete_message(user: User, target: Channel, message: Message) -> Option<Response> {
    let permissions = with_permissions!(user, target);

-    if !permissions.get_manage_messages() {
-        if message.author != user.id {
-            return Some(Response::LackingPermission(Permission::ManageMessages));
-        }
+    if !permissions.get_manage_messages() && message.author != user.id {
+        return Some(Response::LackingPermission(Permission::ManageMessages));
    }

    let col = database::get_collection("messages");
--- a/src/routes/guild.rs
+++ b/src/routes/guild.rs
@@ -1,23 +1,24 @@
 use super::channel::ChannelType;
 use super::Response;
-use crate::database::guild::{get_invite, get_member, Guild};
+use crate::database::guild::{fetch_member as get_member, get_invite, Guild, MemberKey};
 use crate::database::{
-    self, channel::fetch_channel, channel::Channel, Permission, PermissionCalculator,
+    self, channel::fetch_channel, channel::Channel, guild::serialise_guilds_with_channels,
+    user::User, Permission, PermissionCalculator,
 };
-use crate::guards::auth::UserRef;
 use crate::notifications::{
    self,
    events::{guilds::*, Notification},
 };
 use crate::util::gen_token;

-use mongodb::bson::{doc, from_bson, Bson};
+use mongodb::bson::{doc, Bson};
 use mongodb::options::{FindOneOptions, FindOptions};
 use rocket::request::Form;
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;

+// ! FIXME: GET RID OF THIS
 macro_rules! with_permissions {
    ($user: expr, $target: expr) => {{
        let permissions = PermissionCalculator::new($user.clone())
@@ -35,54 +36,10 @@ macro_rules! with_permissions {

 /// fetch your guilds
 #[get("/@me")]
-pub fn my_guilds(user: UserRef) -> Response {
-    if let Ok(result) = database::get_collection("members").find(
-        doc! {
-            "_id.user": &user.id
-        },
-        None,
-    ) {
-        let mut guilds = vec![];
-        for item in result {
-            if let Ok(entry) = item {
-                guilds.push(Bson::String(
-                    entry
-                        .get_document("_id")
-                        .unwrap()
-                        .get_str("guild")
-                        .unwrap()
-                        .to_string(),
-                ));
-            }
-        }
-
-        if let Ok(result) = database::get_collection("guilds").find(
-            doc! {
-                "_id": {
-                    "$in": guilds
-                }
-            },
-            FindOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "name": 1,
-                    "description": 1,
-                    "owner": 1,
-                })
-                .build(),
-        ) {
-            let mut parsed = vec![];
-            for item in result {
-                let doc = item.unwrap();
-                parsed.push(json!({
-                    "id": doc.get_str("_id").unwrap(),
-                    "name": doc.get_str("name").unwrap(),
-                    "description": doc.get_str("description").unwrap(),
-                    "owner": doc.get_str("owner").unwrap(),
-                }));
-            }
-
-            Response::Success(json!(parsed))
+pub fn my_guilds(user: User) -> Response {
+    if let Ok(gids) = user.find_guilds() {
+        if let Ok(data) = serialise_guilds_with_channels(&gids) {
+            Response::Success(json!(data))
        } else {
            Response::InternalServerError(json!({ "error": "Failed to fetch guilds." }))
        }
@@ -93,48 +50,21 @@ pub fn my_guilds(user: UserRef) -> Response {

 /// fetch a guild
 #[get("/<target>")]
-pub fn guild(user: UserRef, target: Guild) -> Option<Response> {
+pub fn guild(user: User, target: Guild) -> Option<Response> {
    with_permissions!(user, target);

-    let col = database::get_collection("channels");
-    match col.find(
-        doc! {
-            "type": 2,
-            "guild": &target.id,
-        },
-        None,
-    ) {
-        Ok(results) => {
-            let mut channels = vec![];
-            for item in results {
-                if let Ok(entry) = item {
-                    if let Ok(channel) = from_bson(Bson::Document(entry)) as Result<Channel, _> {
-                        channels.push(json!({
-                            "id": channel.id,
-                            "name": channel.name,
-                            "description": channel.description,
-                        }));
-                    }
-                }
-            }
-
-            Some(Response::Success(json!({
-                "id": target.id,
-                "name": target.name,
-                "description": target.description,
-                "owner": target.owner,
-                "channels": channels,
-            })))
-        }
-        Err(_) => Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch channels." }),
-        )),
+    if let Ok(result) = target.seralise_with_channels() {
+        Some(Response::Success(result))
+    } else {
+        Some(Response::InternalServerError(
+            json!({ "error": "Failed to fetch channels!" }),
+        ))
    }
 }

 /// delete or leave a guild
 #[delete("/<target>")]
-pub fn remove_guild(user: UserRef, target: Guild) -> Option<Response> {
+pub fn remove_guild(user: User, target: Guild) -> Option<Response> {
    with_permissions!(user, target);

    if user.id == target.owner {
@@ -226,33 +156,31 @@ pub fn remove_guild(user: UserRef, target: Guild) -> Option<Response> {
                json!({ "error": "Could not fetch channels." }),
            ))
        }
-    } else {
-        if database::get_collection("members")
-            .delete_one(
-                doc! {
-                    "_id.guild": &target.id,
-                    "_id.user": &user.id,
-                },
-                None,
-            )
-            .is_ok()
-        {
-            notifications::send_message_threaded(
-                None,
-                target.id.clone(),
-                Notification::guild_user_leave(UserLeave {
-                    id: target.id.clone(),
-                    user: user.id.clone(),
-                    banned: false,
-                }),
-            );
+    } else if database::get_collection("members")
+        .delete_one(
+            doc! {
+                "_id.guild": &target.id,
+                "_id.user": &user.id,
+            },
+            None,
+        )
+        .is_ok()
+    {
+        notifications::send_message_threaded(
+            None,
+            target.id.clone(),
+            Notification::guild_user_leave(UserLeave {
+                id: target.id.clone(),
+                user: user.id.clone(),
+                banned: false,
+            }),
+        );

-            Some(Response::Result(super::Status::Ok))
-        } else {
-            Some(Response::InternalServerError(
-                json!({ "error": "Failed to remove you from the guild." }),
-            ))
-        }
+        Some(Response::Result(super::Status::Ok))
+    } else {
+        Some(Response::InternalServerError(
+            json!({ "error": "Failed to remove you from the guild." }),
+        ))
    }
 }

@@ -265,7 +193,7 @@ pub struct CreateChannel {

 /// create a new channel
 #[post("/<target>/channels", data = "<info>")]
-pub fn create_channel(user: UserRef, target: Guild, info: Json<CreateChannel>) -> Option<Response> {
+pub fn create_channel(user: User, target: Guild, info: Json<CreateChannel>) -> Option<Response> {
    let (permissions, _) = with_permissions!(user, target);

    if !permissions.get_manage_channels() {
@@ -306,20 +234,39 @@ pub fn create_channel(user: UserRef, target: Guild, info: Json<CreateChannel>) -
            )
            .is_ok()
        {
-            notifications::send_message_threaded(
-                None,
-                target.id.clone(),
-                Notification::guild_channel_create(ChannelCreate {
-                    id: target.id.clone(),
-                    channel: id.clone(),
-                    name: name.clone(),
-                    description: description.clone(),
-                }),
-            );
+            if database::get_collection("guilds")
+                .update_one(
+                    doc! {
+                        "_id": &target.id
+                    },
+                    doc! {
+                        "$addToSet": {
+                            "channels": &id
+                        }
+                    },
+                    None,
+                )
+                .is_ok()
+            {
+                notifications::send_message_threaded(
+                    None,
+                    target.id.clone(),
+                    Notification::guild_channel_create(ChannelCreate {
+                        id: target.id.clone(),
+                        channel: id.clone(),
+                        name: name.clone(),
+                        description: description.clone(),
+                    }),
+                );

-            Some(Response::Success(json!({ "id": &id })))
+                Some(Response::Success(json!({ "id": &id })))
+            } else {
+                Some(Response::InternalServerError(
+                    json!({ "error": "Couldn't save channel list." }),
+                ))
+            }
        } else {
-            Some(Response::BadRequest(
+            Some(Response::InternalServerError(
                json!({ "error": "Couldn't create channel." }),
            ))
        }
@@ -338,7 +285,7 @@ pub struct InviteOptions {
 /// create a new invite
 #[post("/<target>/channels/<channel>/invite", data = "<_options>")]
 pub fn create_invite(
-    user: UserRef,
+    user: User,
    target: Guild,
    channel: Channel,
    _options: Json<InviteOptions>,
@@ -376,14 +323,12 @@ pub fn create_invite(

 /// remove an invite
 #[delete("/<target>/invites/<code>")]
-pub fn remove_invite(user: UserRef, target: Guild, code: String) -> Option<Response> {
+pub fn remove_invite(user: User, target: Guild, code: String) -> Option<Response> {
    let (permissions, _) = with_permissions!(user, target);

    if let Some((guild_id, _, invite)) = get_invite(&code, None) {
-        if invite.creator != user.id {
-            if !permissions.get_manage_server() {
-                return Some(Response::LackingPermission(Permission::ManageServer));
-            }
+        if invite.creator != user.id && !permissions.get_manage_server() {
+            return Some(Response::LackingPermission(Permission::ManageServer));
        }

        if database::get_collection("guilds")
@@ -417,7 +362,7 @@ pub fn remove_invite(user: UserRef, target: Guild, code: String) -> Option<Respo

 /// fetch all guild invites
 #[get("/<target>/invites")]
-pub fn fetch_invites(user: UserRef, target: Guild) -> Option<Response> {
+pub fn fetch_invites(user: User, target: Guild) -> Option<Response> {
    let (permissions, _) = with_permissions!(user, target);

    if !permissions.get_manage_server() {
@@ -429,7 +374,7 @@ pub fn fetch_invites(user: UserRef, target: Guild) -> Option<Response> {

 /// view an invite before joining
 #[get("/join/<code>", rank = 1)]
-pub fn fetch_invite(user: UserRef, code: String) -> Response {
+pub fn fetch_invite(user: User, code: String) -> Response {
    if let Some((guild_id, name, invite)) = get_invite(&code, user.id) {
        match fetch_channel(&invite.channel) {
            Ok(result) => {
@@ -457,7 +402,7 @@ pub fn fetch_invite(user: UserRef, code: String) -> Response {

 /// join a guild using an invite
 #[post("/join/<code>", rank = 1)]
-pub fn use_invite(user: UserRef, code: String) -> Response {
+pub fn use_invite(user: User, code: String) -> Response {
    if let Some((guild_id, _, invite)) = get_invite(&code, Some(user.id.clone())) {
        if let Ok(result) = database::get_collection("members").find_one(
            doc! {
@@ -521,8 +466,8 @@ pub struct CreateGuild {

 /// create a new guild
 #[post("/create", data = "<info>")]
-pub fn create_guild(user: UserRef, info: Json<CreateGuild>) -> Response {
-    if !user.email_verified {
+pub fn create_guild(user: User, info: Json<CreateGuild>) -> Response {
+    if !user.email_verification.verified {
        return Response::Unauthorized(json!({ "error": "Email not verified!" }));
    }

@@ -591,6 +536,7 @@ pub fn create_guild(user: UserRef, info: Json<CreateGuild>) -> Response {
                "name": name,
                "description": description,
                "owner": &user.id,
+                "channels": [ channel_id.clone() ],
                "invites": [],
                "bans": [],
                "default_permissions": 51,
@@ -611,7 +557,7 @@ pub fn create_guild(user: UserRef, info: Json<CreateGuild>) -> Response {

 /// fetch a guild's member
 #[get("/<target>/members")]
-pub fn fetch_members(user: UserRef, target: Guild) -> Option<Response> {
+pub fn fetch_members(user: User, target: Guild) -> Option<Response> {
    with_permissions!(user, target);

    if let Ok(result) =
@@ -638,24 +584,30 @@ pub fn fetch_members(user: UserRef, target: Guild) -> Option<Response> {

 /// fetch a guild member
 #[get("/<target>/members/<other>")]
-pub fn fetch_member(user: UserRef, target: Guild, other: String) -> Option<Response> {
+pub fn fetch_member(user: User, target: Guild, other: String) -> Option<Response> {
    with_permissions!(user, target);

-    if let Some(member) = get_member(&target.id, &other) {
-        Some(Response::Success(json!({
-            "id": member.id.user,
-            "nickname": member.nickname,
-        })))
+    if let Ok(result) = get_member(MemberKey(target.id, other)) {
+        if let Some(member) = result {
+            Some(Response::Success(json!({
+                "id": member.id.user,
+                "nickname": member.nickname,
+            })))
+        } else {
+            Some(Response::NotFound(
+                json!({ "error": "Member does not exist!" }),
+            ))
+        }
    } else {
        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch member or user does not exist." }),
+            json!({ "error": "Failed to fetch member." }),
        ))
    }
 }

 /// kick a guild member
 #[delete("/<target>/members/<other>")]
-pub fn kick_member(user: UserRef, target: Guild, other: String) -> Option<Response> {
+pub fn kick_member(user: User, target: Guild, other: String) -> Option<Response> {
    let (permissions, _) = with_permissions!(user, target);

    if user.id == other {
@@ -668,9 +620,15 @@ pub fn kick_member(user: UserRef, target: Guild, other: String) -> Option<Respon
        return Some(Response::LackingPermission(Permission::KickMembers));
    }

-    if get_member(&target.id, &other).is_none() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User not part of guild." }),
+    if let Ok(result) = get_member(MemberKey(target.id.clone(), other.clone())) {
+        if result.is_none() {
+            return Some(Response::BadRequest(
+                json!({ "error": "User not part of guild." }),
+            ));
+        }
+    } else {
+        return Some(Response::InternalServerError(
+            json!({ "error": "Failed to fetch member." }),
        ));
    }

@@ -710,7 +668,7 @@ pub struct BanOptions {
 /// ban a guild member
 #[put("/<target>/members/<other>/ban?<options..>")]
 pub fn ban_member(
-    user: UserRef,
+    user: User,
    target: Guild,
    other: String,
    options: Form<BanOptions>,
@@ -734,9 +692,15 @@ pub fn ban_member(
        return Some(Response::LackingPermission(Permission::BanMembers));
    }

-    if get_member(&target.id, &other).is_none() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User not part of guild." }),
+    if let Ok(result) = get_member(MemberKey(target.id.clone(), other.clone())) {
+        if result.is_none() {
+            return Some(Response::BadRequest(
+                json!({ "error": "User not part of guild." }),
+            ));
+        }
+    } else {
+        return Some(Response::InternalServerError(
+            json!({ "error": "Failed to fetch member." }),
        ));
    }

@@ -790,7 +754,7 @@ pub fn ban_member(

 /// unban a guild member
 #[delete("/<target>/members/<other>/ban")]
-pub fn unban_member(user: UserRef, target: Guild, other: String) -> Option<Response> {
+pub fn unban_member(user: User, target: Guild, other: String) -> Option<Response> {
    let (permissions, _) = with_permissions!(user, target);

    if user.id == other {
--- a/src/routes/root.rs
+++ b/src/routes/root.rs
@@ -1,4 +1,5 @@
 use super::Response;
+use crate::util::variables::{USE_EMAIL, DISABLE_REGISTRATION, USE_HCAPTCHA};

 use mongodb::bson::doc;

@@ -6,7 +7,17 @@ use mongodb::bson::doc;
 #[get("/")]
 pub fn root() -> Response {
    Response::Success(json!({
-        "revolt": "0.2.3"
+        "revolt": "0.2.10",
+        "version": {
+            "major": 0,
+            "minor": 2,
+            "patch": 10
+        },
+        "features": {
+            "registration": !*DISABLE_REGISTRATION,
+            "captcha": *USE_HCAPTCHA,
+            "email": *USE_EMAIL,
+        }
    }))
 }

--- a/src/routes/user.rs
+++ b/src/routes/user.rs
@@ -1,6 +1,7 @@
 use super::Response;
-use crate::database::{self, get_relationship, get_relationship_internal, mutual, Relationship};
-use crate::guards::auth::UserRef;
+use crate::database::{
+    self, get_relationship, get_relationship_internal, user::User, Relationship,
+};
 use crate::notifications::{
    self,
    events::{users::*, Notification},
@@ -15,36 +16,15 @@ use ulid::Ulid;

 /// retrieve your user information
 #[get("/@me")]
-pub fn me(user: UserRef) -> Response {
-    if let Some(info) = user.fetch_data(doc! { "email": 1 }) {
-        Response::Success(json!({
-            "id": user.id,
-            "username": user.username,
-            "display_name": user.display_name,
-            "email": info.get_str("email").unwrap(),
-            "verified": user.email_verified,
-        }))
-    } else {
-        Response::InternalServerError(
-            json!({ "error": "Failed to fetch information from database." }),
-        )
-    }
+pub fn me(user: User) -> Response {
+    Response::Success(user.serialise(Relationship::SELF as i32))
 }

 /// retrieve another user's information
 #[get("/<target>")]
-pub fn user(user: UserRef, target: UserRef) -> Response {
-    Response::Success(json!({
-        "id": target.id,
-        "username": target.username,
-        "display_name": target.display_name,
-        "relationship": get_relationship(&user, &target) as i32,
-        "mutual": {
-            "guilds": mutual::find_mutual_guilds(&user.id, &target.id),
-            "friends": mutual::find_mutual_friends(&user.id, &target.id),
-            "groups": mutual::find_mutual_groups(&user.id, &target.id),
-        }
-    }))
+pub fn user(user: User, target: User) -> Response {
+    let relationship = get_relationship(&user, &target) as i32;
+    Response::Success(user.serialise(relationship))
 }

 #[derive(Serialize, Deserialize)]
@@ -54,8 +34,7 @@ pub struct UserQuery {

 /// find a user by their username
 #[post("/query", data = "<query>")]
-pub fn query(user: UserRef, query: Json<UserQuery>) -> Response {
-    let relationships = user.fetch_relationships();
+pub fn query(user: User, query: Json<UserQuery>) -> Response {
    let col = database::get_collection("users");

    if let Ok(result) = col.find_one(
@@ -70,7 +49,7 @@ pub fn query(user: UserRef, query: Json<UserQuery>) -> Response {
                "id": id,
                "username": doc.get_str("username").unwrap(),
                "display_name": doc.get_str("display_name").unwrap(),
-                "relationship": get_relationship_internal(&user.id, &id, &relationships) as i32
+                "relationship": get_relationship_internal(&user.id, &id, &user.relations) as i32
            }))
        } else {
            Response::NotFound(json!({
@@ -90,7 +69,7 @@ pub struct LookupQuery {
 /// lookup a user on Revolt
 /// currently only supports exact username searches
 #[post("/lookup", data = "<query>")]
-pub fn lookup(user: UserRef, query: Json<LookupQuery>) -> Response {
+pub fn lookup(user: User, query: Json<LookupQuery>) -> Response {
    let relationships = user.fetch_relationships();
    let col = database::get_collection("users");

@@ -121,7 +100,7 @@ pub fn lookup(user: UserRef, query: Json<LookupQuery>) -> Response {

 /// retrieve all of your DMs
 #[get("/@me/dms")]
-pub fn dms(user: UserRef) -> Response {
+pub fn dms(user: User) -> Response {
    let col = database::get_collection("channels");

    if let Ok(results) = col.find(
@@ -178,7 +157,7 @@ pub fn dms(user: UserRef) -> Response {

 /// open a DM with a user
 #[get("/<target>/dm")]
-pub fn dm(user: UserRef, target: UserRef) -> Response {
+pub fn dm(user: User, target: User) -> Response {
    let col = database::get_collection("channels");

    if let Ok(result) = col.find_one(
@@ -211,11 +190,9 @@ pub fn dm(user: UserRef, target: UserRef) -> Response {

 /// retrieve all of your friends
 #[get("/@me/friend")]
-pub fn get_friends(user: UserRef) -> Response {
-    let relationships = user.fetch_relationships();
-
+pub fn get_friends(user: User) -> Response {
    let mut results = Vec::new();
-    if let Some(arr) = relationships {
+    if let Some(arr) = user.relations {
        for item in arr {
            results.push(json!({
                "id": item.id,
@@ -229,13 +206,13 @@ pub fn get_friends(user: UserRef) -> Response {

 /// retrieve friend status with user
 #[get("/<target>/friend")]
-pub fn get_friend(user: UserRef, target: UserRef) -> Response {
+pub fn get_friend(user: User, target: User) -> Response {
    Response::Success(json!({ "status": get_relationship(&user, &target) as i32 }))
 }

 /// create or accept a friend request
 #[put("/<target>/friend")]
-pub fn add_friend(user: UserRef, target: UserRef) -> Response {
+pub fn add_friend(user: User, target: User) -> Response {
    let col = database::get_collection("users");

    match get_relationship(&user, &target) {
@@ -278,7 +255,8 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                        vec![target.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
+                            id: target.id.clone(),
+                            user: user.id.clone(),
                            status: Relationship::Friend as i32,
                        }),
                    );
@@ -287,7 +265,8 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                        vec![user.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
+                            id: user.id.clone(),
+                            user: target.id.clone(),
                            status: Relationship::Friend as i32,
                        }),
                    );
@@ -349,7 +328,8 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                        vec![user.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
+                            id: user.id.clone(),
+                            user: target.id.clone(),
                            status: Relationship::Outgoing as i32,
                        }),
                    );
@@ -358,7 +338,8 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {
                        vec![target.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
+                            id: target.id.clone(),
+                            user: user.id.clone(),
                            status: Relationship::Incoming as i32,
                        }),
                    );
@@ -383,7 +364,7 @@ pub fn add_friend(user: UserRef, target: UserRef) -> Response {

 /// remove a friend or deny a request
 #[delete("/<target>/friend")]
-pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
+pub fn remove_friend(user: User, target: User) -> Response {
    let col = database::get_collection("users");

    match get_relationship(&user, &target) {
@@ -424,7 +405,8 @@ pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
                        vec![user.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
+                            id: user.id.clone(),
+                            user: target.id.clone(),
                            status: Relationship::NONE as i32,
                        }),
                    );
@@ -433,7 +415,8 @@ pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
                        vec![target.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
+                            id: target.id.clone(),
+                            user: user.id.clone(),
                            status: Relationship::NONE as i32,
                        }),
                    );
@@ -459,7 +442,7 @@ pub fn remove_friend(user: UserRef, target: UserRef) -> Response {

 /// block a user
 #[put("/<target>/block")]
-pub fn block_user(user: UserRef, target: UserRef) -> Response {
+pub fn block_user(user: User, target: User) -> Response {
    let col = database::get_collection("users");

    match get_relationship(&user, &target) {
@@ -498,7 +481,8 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                        vec![user.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
+                            id: user.id.clone(),
+                            user: target.id.clone(),
                            status: Relationship::Blocked as i32,
                        }),
                    );
@@ -507,7 +491,8 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                        vec![target.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
+                            id: target.id.clone(),
+                            user: user.id.clone(),
                            status: Relationship::BlockedOther as i32,
                        }),
                    );
@@ -564,7 +549,8 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                        vec![user.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
+                            id: user.id.clone(),
+                            user: target.id.clone(),
                            status: Relationship::Blocked as i32,
                        }),
                    );
@@ -573,7 +559,8 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                        vec![target.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
+                            id: target.id.clone(),
+                            user: user.id.clone(),
                            status: Relationship::BlockedOther as i32,
                        }),
                    );
@@ -613,7 +600,8 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {
                    vec![user.id.clone()],
                    None,
                    Notification::user_friend_status(FriendStatus {
-                        id: target.id.clone(),
+                        id: user.id.clone(),
+                        user: target.id.clone(),
                        status: Relationship::Blocked as i32,
                    }),
                );
@@ -631,7 +619,7 @@ pub fn block_user(user: UserRef, target: UserRef) -> Response {

 /// unblock a user
 #[delete("/<target>/block")]
-pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
+pub fn unblock_user(user: User, target: User) -> Response {
    let col = database::get_collection("users");

    match get_relationship(&user, &target) {
@@ -656,7 +644,8 @@ pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
                        vec![user.id.clone()],
                        None,
                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
+                            id: user.id.clone(),
+                            user: target.id.clone(),
                            status: Relationship::BlockedOther as i32,
                        }),
                    );
@@ -705,7 +694,8 @@ pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
                            vec![user.id.clone()],
                            None,
                            Notification::user_friend_status(FriendStatus {
-                                id: target.id.clone(),
+                                id: user.id.clone(),
+                                user: target.id.clone(),
                                status: Relationship::NONE as i32,
                            }),
                        );
@@ -714,7 +704,8 @@ pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
                            vec![target.id.clone()],
                            None,
                            Notification::user_friend_status(FriendStatus {
-                                id: user.id.clone(),
+                                id: target.id.clone(),
+                                user: user.id.clone(),
                                status: Relationship::NONE as i32,
                            }),
                        );
--- a/src/util/captcha.rs
+++ b/src/util/captcha.rs
@@ -0,0 +1,43 @@
+use crate::util::variables::{HCAPTCHA_KEY, USE_HCAPTCHA};
+
+use reqwest::blocking::Client;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Serialize, Deserialize)]
+struct CaptchaResponse {
+    success: bool,
+}
+
+pub fn verify(user_token: &Option<String>) -> Result<(), String> {
+    if *USE_HCAPTCHA {
+        if let Some(token) = user_token {
+            let mut map = HashMap::new();
+            map.insert("secret", HCAPTCHA_KEY.to_string());
+            map.insert("response", token.to_string());
+
+            let client = Client::new();
+            if let Ok(response) = client
+                .post("https://hcaptcha.com/siteverify")
+                .form(&map)
+                .send()
+            {
+                let result: CaptchaResponse = response
+                    .json()
+                    .map_err(|_| "Failed to deserialise captcha result.".to_string())?;
+
+                if result.success {
+                    Ok(())
+                } else {
+                    Err("Unsuccessful captcha verification".to_string())
+                }
+            } else {
+                Err("Failed to verify with hCaptcha".to_string())
+            }
+        } else {
+            Err("Missing hCaptcha token!".to_string())
+        }
+    } else {
+        Ok(())
+    }
+}
--- a/src/util/email.rs
+++ b/src/util/email.rs
@@ -0,0 +1,96 @@
+use lettre::message::{header, MultiPart, SinglePart};
+use lettre::transport::smtp::authentication::Credentials;
+use lettre::{Message, SmtpTransport, Transport};
+
+use super::variables::{PUBLIC_URL, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME};
+
+lazy_static! {
+    static ref MAILER: lettre::transport::smtp::SmtpTransport =
+        SmtpTransport::relay(SMTP_HOST.as_ref())
+            .unwrap()
+            .credentials(Credentials::new(
+                SMTP_USERNAME.to_string(),
+                SMTP_PASSWORD.to_string()
+            ))
+            .build();
+}
+
+fn send(message: Message) -> Result<(), String> {
+    MAILER
+        .send(&message)
+        .map_err(|err| format!("Failed to send email! {}", err.to_string()))?;
+
+    Ok(())
+}
+
+fn generate_multipart(text: &str, html: &str) -> MultiPart {
+    MultiPart::mixed().multipart(
+        MultiPart::alternative()
+            .singlepart(
+                SinglePart::quoted_printable()
+                    .header(header::ContentType(
+                        "text/plain; charset=utf8".parse().unwrap(),
+                    ))
+                    .body(text),
+            )
+            .multipart(
+                MultiPart::related().singlepart(
+                    SinglePart::eight_bit()
+                        .header(header::ContentType(
+                            "text/html; charset=utf8".parse().unwrap(),
+                        ))
+                        .body(html),
+                ),
+            ),
+    )
+}
+
+pub fn send_verification_email(email: String, code: String) -> Result<(), String> {
+    let url = format!("{}/api/account/verify/{}", PUBLIC_URL.to_string(), code);
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Verify your email!")
+        .multipart(generate_multipart(
+            &format!("Verify your email here: {}", url),
+            &format!("<a href=\"{}\">Click to verify your email!</a>", url),
+        ))
+        .unwrap();
+
+    send(email)
+}
+
+pub fn send_password_reset(email: String, code: String) -> Result<(), String> {
+    let url = format!("{}/api/account/reset/{}", PUBLIC_URL.to_string(), code);
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Reset your password.")
+        .multipart(generate_multipart(
+            &format!("Reset your password here: {}", url),
+            &format!("<a href=\"{}\">Click to reset your password!</a>", url),
+        ))
+        .unwrap();
+
+    send(email)
+}
+
+pub fn send_welcome_email(email: String, username: String) -> Result<(), String> {
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Welcome to REVOLT!")
+        .multipart(
+        generate_multipart(
+            &format!("Welcome, {}! You can now use REVOLT.", username),
+            &format!(
+                    "<b>Welcome, {}!</b><br/>You can now use REVOLT.<br/><a href=\"{}\">Go to REVOLT</a>",
+                    username,
+                    PUBLIC_URL.to_string()
+                )
+            )
+        )
+        .unwrap();
+
+    send(email)
+}
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -2,6 +2,10 @@ use hashbrown::HashSet;
 use rand::{distributions::Alphanumeric, Rng};
 use std::iter::FromIterator;

+pub mod captcha;
+pub mod email;
+pub mod variables;
+
 pub fn vec_to_set<T: Clone + Eq + std::hash::Hash>(data: &[T]) -> HashSet<T> {
    HashSet::from_iter(data.iter().cloned())
 }
--- a/src/util/variables.rs
+++ b/src/util/variables.rs
@@ -0,0 +1,66 @@
+use std::env;
+
+#[cfg(debug_assertions)]
+use log::warn;
+
+lazy_static! {
+    // Application Settings
+    pub static ref MONGO_URI: String =
+        env::var("REVOLT_MONGO_URI").expect("Missing REVOLT_MONGO_URI environment variable.");
+    pub static ref PUBLIC_URL: String =
+        env::var("REVOLT_PUBLIC_URL").expect("Missing REVOLT_PUBLIC_URL environment variable.");
+    pub static ref HCAPTCHA_KEY: String =
+        env::var("REVOLT_HCAPTCHA_KEY").unwrap_or_else(|_| "".to_string());
+    pub static ref WS_HOST: String =
+        env::var("REVOLT_WS_HOST").unwrap_or_else(|_| "0.0.0.0:9999".to_string());
+    
+    // Application Flags
+    pub static ref DISABLE_REGISTRATION: bool = env::var("REVOLT_DISABLE_REGISTRATION").map_or(false, |v| v == "*1");
+    pub static ref USE_EMAIL: bool = env::var("REVOLT_USE_EMAIL_VERIFICATION").map_or(
+        env::var("REVOLT_SMTP_HOST").is_ok()
+            && env::var("REVOLT_SMTP_USERNAME").is_ok()
+            && env::var("REVOLT_SMTP_PASSWORD").is_ok()
+            && env::var("REVOLT_SMTP_FROM").is_ok(),
+        |v| v == *"1"
+    );
+    pub static ref USE_HCAPTCHA: bool = env::var("REVOLT_HCAPTCHA_KEY").is_ok();
+
+    // SMTP Settings
+    pub static ref SMTP_HOST: String =
+        env::var("REVOLT_SMTP_HOST").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_USERNAME: String =
+        env::var("SMTP_USERNAME").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_PASSWORD: String =
+        env::var("SMTP_PASSWORD").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_FROM: String = env::var("SMTP_FROM").unwrap_or_else(|_| "".to_string());
+}
+
+pub fn preflight_checks() {
+    if *USE_EMAIL == false {
+        #[cfg(not(debug_assertions))]
+        {
+            if !env::var("REVOLT_UNSAFE_NO_EMAIL")
+                .map_or(false, |v| v == *"1") {
+                panic!(
+                    "Not letting you run this in production, set REVOLT_UNSAFE_NO_EMAIL=1 to run."
+                );
+            }
+        }
+
+        #[cfg(debug_assertions)]
+        warn!("No SMTP settings specified! Remember to configure email.");
+    }
+
+    if *USE_HCAPTCHA == false {
+        #[cfg(not(debug_assertions))]
+        {
+            if !env::var("REVOLT_UNSAFE_NO_CAPTCHA")
+                .map_or(false, |v| v == *"1") {
+                panic!("Not letting you run this in production, set REVOLT_UNSAFE_NO_CAPTCHA=1 to run.");
+            }
+        }
+
+        #[cfg(debug_assertions)]
+        warn!("No Captcha key specified! Remember to add hCaptcha key.");
+    }
+}
Author	SHA1	Message	Date
Paul Makles	c95dc19f67	Fix docker run.sh	2020-08-30 18:56:43 +01:00
Paul Makles	ab2a510bc6	Add .env to ignore and remove warning.	2020-08-30 18:04:38 +01:00
Paul Makles	7c374ec756	Use flags for email / registration correctly.	2020-08-30 17:48:30 +01:00
Paul Makles	cbac802978	Re-write email backend, use SMTP directly.	2020-08-30 17:16:53 +01:00
Paul Makles	ff0e539c7b	Add docker helper scripts.	2020-08-30 15:44:56 +01:00
Paul Makles	8bb1977025	Add Docker and GitLab CI.	2020-08-30 15:07:45 +01:00
Paul Makles	000ffe6aaa	Fix bug.	2020-08-30 13:40:29 +01:00
Paul Makles	81111c5937	Fix guild creation, disable registration.	2020-08-25 08:50:25 +01:00
Paul Makles	49044d7796	Fix hCaptcha verification.	2020-08-13 13:56:54 +02:00
Paul Makles	f44180a980	Add hCaptcha support.	2020-08-13 13:06:06 +02:00
Paul Makles	8ee867eec7	Fix errors.	2020-08-12 16:17:58 +02:00
Paul Makles	dde4224deb	Attach channels on guild object.	2020-08-12 16:13:42 +02:00
Paul Makles	088490dfc3	Include guild channels in payload.	2020-08-12 16:07:10 +02:00
Paul Makles	7e7eb34f65	Add serialisation, ready payload and GET guilds.	2020-08-12 15:40:56 +02:00
Paul Makles	74b4238f04	Add channels field to guild object.	2020-08-12 11:45:05 +02:00
Paul Makles	a8eb403280	Logging + database migrations system.	2020-08-11 21:08:01 +02:00
Paul Makles	750f8c6738	Provide version object at /, add ready event.	2020-08-11 16:20:24 +02:00
Paul Makles	83ee9253fe	Fix fetch guild member.	2020-08-11 12:41:23 +02:00
Paul Makles	0b90145b31	Breaking change to FriendStatus, user cache sync.	2020-08-10 22:23:58 +02:00
Paul Makles	8cb697dfcd	Add user cache, no more "guard refs".	2020-08-10 21:11:01 +02:00
insert	cd5c7ce02c	Merge branch 'caching' into 'master' Caching and other small changes. See merge request revolt/delta!1	2020-08-10 16:59:50 +00:00
Paul Makles	6504f78518	Prepare to merge back into master.	2020-08-10 18:59:08 +02:00
Paul Makles	11ce7c9e30	Handle incoming changes and push to cache.	2020-08-10 18:58:23 +02:00
Paul Makles	8956400e44	Add caching for members, rewrite part of perms.	2020-08-10 18:53:24 +02:00
Paul Makles	aba0db268a	Update cached channel state from notifications.	2020-08-10 15:29:48 +02:00