Updated CHANGELOG.md

- Fixed intent error message condition

.dockerignore

@@ -9,6 +9,7 @@
 !src/NadekoBot.Generators/**
 # Use Ayu stuff
 !src/ayu/**
+!docker-entrypoint.sh
 
 # ignore bin and obj folders in projects
 src/**/bin/*

.gitignore

@@ -8,7 +8,7 @@ src/NadekoBot/creds.yml
 src/NadekoBot/Command Errors*.txt
 
 src/NadekoBot/creds.yml
-# credentials file before and after migrations
+# credentials file before and after v3
 src/NadekoBot/credentials.json 
 src/NadekoBot/old_credentials.json 
 src/NadekoBot/credentials.json.bak
@@ -256,7 +256,7 @@ PublishScripts/
 !**/packages/build/
 # Uncomment if necessary however generally it will be regenerated when needed
 #!**/packages/repositories.config
-# NuGet v3's project.json files produces more ignoreable files
+# NuGet v4's project.json files produces more ignoreable files
 *.nuget.props
 *.nuget.targets
 

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: mcr.microsoft.com/dotnet/sdk:5.0
+image: mcr.microsoft.com/dotnet/sdk:6.0
 
 stages:
   - build
@@ -30,29 +30,29 @@ build:
       - "$WIN_X64_OUTPUT_DIR/"
 
 upload-builds:
-  stage: upload-builds
-  image: alpine:latest
-  rules:
-    - if: $CI_COMMIT_TAG
-  script:    
-    - apk add --no-cache curl tar zip
-    - "tar cvf $LINUX_X64_RELEASE $LINUX_X64_OUTPUT_DIR/*"
-    - "zip -r $WIN_X64_RELEASE $WIN_X64_OUTPUT_DIR/*"
-    - |
-      curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $LINUX_X64_RELEASE $PACKAGE_REGISTRY_URL/$LINUX_X64_RELEASE
-    - |
-      curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $WIN_X64_RELEASE $PACKAGE_REGISTRY_URL/$WIN_X64_RELEASE
+ stage: upload-builds
+ image: alpine:latest
+ rules:
+   - if: $CI_COMMIT_TAG
+ script:    
+   - apk add --no-cache curl tar zip
+   - "tar cvf $LINUX_X64_RELEASE $LINUX_X64_OUTPUT_DIR/*"
+   - "zip -r $WIN_X64_RELEASE $WIN_X64_OUTPUT_DIR/*"
+   - |
+     curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $LINUX_X64_RELEASE $PACKAGE_REGISTRY_URL/$LINUX_X64_RELEASE
+   - |
+     curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $WIN_X64_RELEASE $PACKAGE_REGISTRY_URL/$WIN_X64_RELEASE
 
 release:
-  stage: release
-  image: registry.gitlab.com/gitlab-org/release-cli:latest
-  rules:
-    - if: $CI_COMMIT_TAG
-  script:
-    - |
-      release-cli create --name "NadekoBot v$CI_COMMIT_TAG" --description "## [Changelog](https://gitlab.com/Kwoth/nadekobot/-/blob/v3/CHANGELOG.md#$(echo "$CI_COMMIT_TAG" | sed "s/\.//g")-$(date +%d%m%Y))" --tag-name $CI_COMMIT_TAG \
-        --assets-link "{\"name\":\"${LINUX_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${LINUX_X64_RELEASE}\"}" \
-        --assets-link "{\"name\":\"${WIN_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${WIN_X64_RELEASE}\"}"
+ stage: release
+ image: registry.gitlab.com/gitlab-org/release-cli:latest
+ rules:
+   - if: $CI_COMMIT_TAG
+ script:
+   - |
+     release-cli create --name "NadekoBot v$CI_COMMIT_TAG" --description "## [Changelog](https://gitlab.com/Kwoth/nadekobot/-/blob/v4/CHANGELOG.md#$(echo "$CI_COMMIT_TAG" | sed "s/\.//g")-$(date +%d%m%Y))" --tag-name $CI_COMMIT_TAG \
+       --assets-link "{\"name\":\"${LINUX_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${LINUX_X64_RELEASE}\"}" \
+       --assets-link "{\"name\":\"${WIN_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${WIN_X64_RELEASE}\"}"
 
 test:
   stage: test
@@ -63,36 +63,63 @@ test:
     - "dotnet test"
 
 publish-windows:
-  stage: publish-windows 
-  rules:
-    - if: '$CI_COMMIT_TAG'
-  image: scottyhardy/docker-wine
-  before_script:
-    - choco install dotnet-5.0-runtime -y
-    - choco install dotnet-5.0-sdk -y
-    - choco install innosetup -y
-  artifacts:
-    paths:
-      - "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
-  script:
-    - dotnet clean
-    - dotnet restore
-    - dotnet publish -c Release --runtime win7-x64 /p:Version=$CI_COMMIT_TAG src/NadekoBot
-    - $env:NADEKOBOT_INSTALL_VERSION = $CI_COMMIT_TAG
-    - iscc.exe "/O+" ".\exe_builder.iss"
-  tags:
-    - windows
+ stage: publish-windows 
+ rules:
+   - if: '$CI_COMMIT_TAG'
+ image: scottyhardy/docker-wine
+ before_script:
+   - choco install dotnet-6.0-runtime -y
+   - choco install dotnet-6.0-sdk -y
+   - choco install innosetup -y
+ artifacts:
+   paths:
+     - "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
+ script:
+   - dotnet clean
+   - dotnet restore
+   - dotnet publish -c Release --runtime win7-x64 /p:Version=$CI_COMMIT_TAG src/NadekoBot
+   - $env:NADEKOBOT_INSTALL_VERSION = $CI_COMMIT_TAG
+   - iscc.exe "/O+" ".\exe_builder.iss"
+ tags:
+   - windows
 
 upload-windows-updater-release:
-  stage: upload-windows-updater-release
-  rules:
-    - if: '$CI_COMMIT_TAG'
-  image: 
-    name: amazon/aws-cli
-    entrypoint: [""]
-  script:  
-    - sed -i "s/_INSTALLER_FILE_NAME_/$INSTALLER_FILE_NAME/g" releases-v3.json
-    - sed -i "s/_VERSION_/$CI_COMMIT_TAG/g" releases-v3.json
-    - aws --version
-    - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/$INSTALLER_FILE_NAME" --acl public-read --body "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
-    - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/releases-v3.json" --acl public-read --body "releases-v3.json"
+ stage: upload-windows-updater-release
+ rules:
+   - if: '$CI_COMMIT_TAG'
+ image: 
+   name: amazon/aws-cli
+   entrypoint: [""]
+ script:  
+   - sed -i "s/_INSTALLER_FILE_NAME_/$INSTALLER_FILE_NAME/g" releases-v3.json
+   - sed -i "s/_VERSION_/$CI_COMMIT_TAG/g" releases-v3.json
+   - aws --version
+   - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/$INSTALLER_FILE_NAME" --acl public-read --body "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
+   - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/releases-v3.json" --acl public-read --body "releases-v3.json"
+
+# docker-build:
+#  # Use the official docker image.
+#  image: docker:latest
+#  stage: build
+#  services:
+#    - docker:dind
+#  before_script:
+#    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
+#  # Default branch leaves tag empty (= latest tag)
+#  # All other branches are tagged with the escaped branch name (commit ref slug)
+#  script:
+#    - |
+#      if [[ "$CI_COMMIT_BRANCH" == "$CI_DEFAULT_BRANCH" ]]; then
+#        tag=""
+#        echo "Running on default branch '$CI_DEFAULT_BRANCH': tag = 'latest'"
+#      else
+#        tag=":$CI_COMMIT_REF_SLUG"
+#        echo "Running on branch '$CI_COMMIT_BRANCH': tag = $tag"
+#      fi
+#    - docker build --pull -t "$CI_REGISTRY_IMAGE${tag}" .
+#    - docker push "$CI_REGISTRY_IMAGE${tag}"
+#  # Run this job in a branch where a Dockerfile exists
+#  rules:
+#    - if: $CI_COMMIT_BRANCH
+#      exists:
+#        - Dockerfile

CHANGELOG.md

@@ -1,10 +1,288 @@
 # Changelog
 
 Experimental changelog. Mostly based on [keepachangelog](https://keepachangelog.com/en/1.0.0/) except date format. a-c-f-r-o
+#todo .trans fix
 
 ## Unreleased
 
+- More cool stuff coming soon
 
+## [4.0.4] - 04.03.2022
+
+### Fixed
+
+- Fixed the `id` which shows up when you add a new Expression
+- Fixed some strings which were still referring to "CustomReaction(s)" instead of "Expression(s)" 
+
+## [4.0.3] - 04.03.2022
+
+### Fixed
+
+- Console should no longer spam numbers when `.antispam` is enabled
+
+## [4.0.2] - 03.03.2022
+
+### Fixed
+
+- Fixed `.rero` not working due to a bug introduced in 4.0
+
+## [4.0.1] - 03.03.2022
+
+### Added
+
+- Added `usePrivilegedIntents` to creds.yml if you don't have or don't want (?) to use them
+- Added a human-readable, detailed error message if logging in fails due to missing privileged intents
+
+## [4.0.0] - 02.03.2022
+
+### Added
+- Added `.deleteemptyservers` command
+- Added `.curtr <id>` which lets you see full information about one of your own transactions with the specified id
+- Added trovo.live support for stream notifications (`.stadd`) 
+- Added unclaimed waifu decay functionality
+  - Added 3 new settings to `data/gambling.yml` to control it:
+    - waifu.decay.percent - How much % to subtract from unclaimed waifu
+    - waifu.decay.hourInterval - How often to decay the price 
+    - waifu.decay.minPrice - Unclaimed waifus with price lower than the one specified here will not be affected by the decay
+- Added `currency.transactionsLifetime` to `data/gambling.yml` Any transaction older than the number of days specified will be automatically deleted
+- Added `.stock` command to check stock prices and charts
+- Re-added `.qap / .queueautoplay` 
+
+### Changed
+- CustomReactions module (and customreactions db table) has been renamed to Expressions.
+  - This was done to remove confusion about how it relates to discord Reactions (it doesn't, it was created and named before discord reactions existed) 
+  - Expression command now start with ex/expr and end with the name of the action or setting. 
+  - For example `.exd` (`.dcr`) is expression delete, `.exa` (`.acr`)
+  - Permissions (`.lp`) be automatically updated with "ACTUALEXPRESSIONS", "EXPRESSIONS" instead of "ACTUALCUSTOMREACTIONS" and "CUSTOMREACTIONS"
+  - Permissions for `.ecr` (now `.exe`), `.scr` (now `.exs`), `.dcr` (now `.exd`), `.acr` (now `.exa`), `.lcr` (now `.exl`) will be automatically updated
+  - If you have custom permissions for other CustomReaction commands
+  - Some of the old aliases like `.acr` `.dcr` `.lcr` and a few others have been kept
+- Currency output format improvement (will use guild locale now for some commands)
+- `.crypto` will now also show CoinMarketCap rank
+- Waifus can now be claimed for much higher prices (int -> long)
+- Several strings and commands related to music have been changed
+  - Changed `.ms / .movesong` to `.tm / .trackmove` but kept old aliases
+  - Changed ~~song~~ -> `track` throughout music module strings
+- Improved .curtrs (It will now have a lot more useful data in the database, show Tx ids, and be partially localized)
+  - [dev] Reason renamed to Note
+  - [dev] Added Type, Extra, OtherId fields to the database
+- [dev] CommandStrings will now use methodname as the key, and **not** the command name (first entry in aliases.yml)
+  - In other words aliases.yml and commands.en-US.yml will use the same keys (once again)
+- [dev] Reorganized module and submodule folders  
+- [dev] Permissionv2 db table renamed to Permissions 
+- [dev] Moved FilterWordsChannelId to a separate table
+
+### Fixed
+- Fixed twitch stream notifications (rewrote it to use the new api)
+- Fixed an extra whitespace in usage part of command help if the command has no arguments
+- Possible small fix for `.prune` ratelimiting
+- `.gvc` should now properly trigger when a user is already in a gvc and changes his activity
+- `.gvc` should now properly detect multiple activities
+- Fixed reference to non-existent command in bot.yml
+- Comment indentation in .yml files should now make more sense
+- Fixed `.warn` punishments not being applied properly when using weighted warnings
+- Fixed embed color when disabling `.antialt`
+
+### Removed
+- Removed `.bce` - use `.config` or `.config bot` specifically for bot config  
+- Removed obsolete placeholders: %users% %servers% %userfull% %username% %userdiscrim% %useravatar% %id% %uid% %chname% %cid% %sid% %members% %server_time% %shardid% %time% %mention%  
+- Removed some obsolete commands and strings  
+- Removed code which migrated 2.x to v3 credentials, settings, etc...
+
+## [3.0.13] - 14.01.2022
+
+### Fixed
+
+- Fixed `.greetdm` causing ratelimits during raids
+- Fixed `.gelbooru`
+
+## [3.0.12] - 06.01.2022
+
+### Fixed
+- `.smch` Fixed
+- `.trans` command will now work properly with capitilized language names
+- Ban message color with plain text fixed
+- Fixed some grpc coordinator bugs
+- Fixed a string in `.xpex`
+- Google version of .img will now have safe search enabled
+- Fixed a small bug in `.hangman`
+
+## [3.0.11] - 17.12.2021
+
+### Added
+- `.remindl` and `.remindrm` commands now supports optional 'server' parameter for Administrators which allows them to delete any reminder created on the server
+- Added slots.currencyFontColor to gambling.yml
+- Added `.qexport` and `.qimport` commands which allow you to export and import quotes just like `.crsexport`
+- Added `.showembed <msgid>` and `.showembed #channel <msgid>` which will show you embed json from the specified message
+
+### Changed
+- `.at` and `.atl` commands reworked
+  - Persist restarts
+  - Will now only translate non-commands
+  - You can switch between `.at del` and `.at` without clearing the user language registrations
+  - Disabling `.at` will clear all user language registrations on that channel
+  - Users can't register languages if the `.at` is not enabled
+  - Looks much nicer
+    - Bot will now reply to user messages with a translation if `del` is disabled
+    - Bot will make an embed with original and translated text with user avatar and name if `del` is enabled
+  - If the bot is unable to delete messages while having `del` enabled, it will reset back to the no-del behavior for the current session  
+
+### Fixed
+- `.crypto` now supports top 5000 coins
+
+## [3.0.10] - 01.12.2021
+
+### Changed
+- `.warn` now supports weighted warnings
+- `.warnlog` will now show current amount and total amount of warnings
+
+### Fixed
+- `.xprewsreset` now has correct permissions
+
+### Removed 
+- Removed slot.numbers from `images.yml` as they're no longer used
+
+## [3.0.9] - 21.11.2021
+
+### Changed
+- `.ea` will now use an image attachments if you omit imageUrl
+
+### Added
+- Added `.emojiadd` with 3 overloads
+  - `.ea :customEmoji:` which copies another server's emoji 
+  - `.ea newName :customEmoji:` which copies emoji under a different name
+  - `.ea emojiName <imagelink.png>` which creates a new emoji from the specified image
+- Patreon Access and Refresh Tokens should now be automatically updated once a month as long as the user has provided the necessary credentials in creds.yml file:
+  - `Patreon.ClientId`
+  - `Patreon.RefreshToken` (will also get updated once a month but needs an initial value)
+  - `Patreon.ClientSecret`
+  - `Patreon.CampaignId`
+
+### Fixed
+- Fixed an error that would show up in the console when a club image couldn't be drawn in certain circumstances
+
+## [3.0.8] - 03.11.2021
+
+### Added 
+- Created VotesApi project nad re-worked vote rewards handling
+  - Updated votes entries in creds.yml with explanations on how to set up vote links
+
+### Fixed
+- Fixed adding currency to users who don't exist in the database
+- Memory used by the bot is now correct (thanks to kotz)
+- Ban/kick will no longer fail due to too long reasons
+- Fixed some fields not preserving inline after string replacements
+
+### Changed
+- `images.json` moved to `images.yml`
+  - Links will use the new cdn url
+  - Heads and Tails images will be updated if you haven't changed them already
+- `.slot` redesigned (and updated entries in `images.yml`)
+- Reduced required permissions for .qdel (thanks to tbodt)
+
+## [3.0.7] - 05.10.2021
+
+### Added
+- `.streamsclear` re-added. It will remove all followed streams on the server.
+- `.gifts` now have 3 new ✂️ Haircut 🧻 ToiletPaper and 🥀 WiltedRose which **reduce** waifu's value
+  - They are called negative gifts
+  - They show up at the end of the `.gifts` page and are marked with a broken heart
+  - They have a separate multiplier (`waifu.multi.negative_gift_effect` default 0.5, changeable via `.config gambling` or `data/gambling.yml`)
+  - When gifted, the waifu's price will be reduced by the `price * multiplier` 
+  - Negative gifts don't show up in `.waifuinfo` nor is the record of them kept in the database
+
+### Fixed 
+- Fixed `%users%` and `%shard.usercount%` placeholders not showing correct values
+
+## [3.0.6] - 27.09.2021
+
+### Added
+
+- .logignore now supports ignoring users and channels. Use without parameters to see the ignore list
+
+### Changed
+
+- Hangman rewrite
+  - Hangman categories are now held in separate .yml files in data/hangman/XYZ.yml where XYZ is the category name
+
+### Fixed
+
+- Fixed an exception which caused repeater queue to break
+- Fixed url field not working in embeds
+
+## [3.0.5] - 20.09.2021
+
+### Fixed
+
+- Fixed images not automatically reloading on startup if the keys don't exist
+- Fixed `.logserver` - it should no longer throw an exception if you had no logsettings previously
+
+## [3.0.4] - 16.09.2021
+
+### Added
+
+- Fully translated to Brazilian Portuguese 🎉
+- Added `%server.boosters%` and `%server.boost_level%` placeholders
+- Added `DmHelpTextKeywords` to `data/bot.yml`
+  - Bot now sends dm help text ONLY if the message contains one of the keywords specified
+  - If no keywords are specified, bot will reply to every DM (like before)
+
+### Fixed
+
+- Possible fix for `.repeat` bug
+  - Slight adjustment for repeater logic
+  - Timer should no longer increase on some repeaters
+  - Repeaters should no longer have periods when they're missing from the list  
+- Fixed several commands which used error color for success confirmation messages
+
+## [3.0.3] - 15.09.2021
+
+### Added
+
+- Added `.massban` to ban multiple people at once. 30 second cooldown
+- Added `.youtubeuploadnotif` / `.yun` as a shortcut for subscribing to a youtube channel's rss feed
+- Added `.imageonlychannel` / `.imageonly` to prevent users from posting anything but images in the channel
+- Added `.config games hangman.currency_reward` and a property with the same name in games.yml
+  - If set, users will gain the specified amount of currency for each hangman win
+- Fully translated to Spanish, Russian and Ukrainian 🎉
+
+### Changed
+
+- Ban `.warnp` will now prune user's messages
+
+### Fixed
+
+- `.boostmsg` will now properly show boost, and not greet message
+
+## [3.0.2] - 12.09.2021
+
+### Added
+
+- `.rero` now optionally takes a message id to which to attach the reaction roles
+- Fully translated to German 🎉
+- Added `.boost`, `.boostmsg` and `.boostdel` commands which allow you to have customizable messages when someone boosts your server, with auto-deletion support
+
+### Changed
+
+- Updated `.greetmsg` and `.byemsg` command help to match the new `.boost` command help
+- Updated response embed colors in greet commands
+    - Success -> green
+    - Warning or Disable -> yellow.
+
+### Fixed
+
+- `.timely` will now correctly use `Ok` color
+- Fixed `.log` commands
+
+### Removed
+
+- Removed `.novel` command as it no longer works
+
+## [3.0.1] - 10.09.2021
+
+### Fixed
+
+- Fixed some issues with the embeds not showing the correct data
 
 ## [3.0.0] - 06.09.2021
 
@@ -215,4 +493,4 @@ Experimental changelog. Mostly based on [keepachangelog](https://keepachangelog.
 ### Removed
 
 - Removed admin requirement on `.scrm` as it didn't make sense
-- Some Music commands are removed because of the complexity they bring in with little value (if you *really* want them back, you can open an issue and specify your *good* reason)
+- Some Music commands are removed because of the complexity they bring in with little value (if you *really* want them back, you can open an issue and specify your *good* reason)

Dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
 WORKDIR /source
 
 COPY src/NadekoBot/*.csproj src/NadekoBot/
@@ -9,14 +9,34 @@ RUN dotnet restore src/NadekoBot/
 
 COPY . .
 WORKDIR /source/src/NadekoBot
-RUN dotnet --version
-RUN dotnet publish -c Release -o /app --no-restore
+RUN set -xe; \
+    dotnet --version; \
+    dotnet publish -c Release -o /app --no-restore; \
+    mv /app/data /app/data_init; \
+    rm -Rf libopus* libsodium* opus.* runtimes/win* runtimes/osx* runtimes/linux-arm* runtimes/linux-mips*; \
+    find /app -type f -exec chmod -x {} \; ;\
+    chmod +x /app/NadekoBot
 
 # final stage/image
-FROM mcr.microsoft.com/dotnet/runtime:5.0
+FROM mcr.microsoft.com/dotnet/runtime:6.0
+WORKDIR /app
+
+RUN set -xe; \
+    useradd -m nadeko; \
+    apt-get update; \
+    apt-get install -y libopus0 libsodium23 libsqlite3-0 curl ffmpeg python3 python3-pip sudo; \
+    update-alternatives --install /usr/bin/python python /usr/bin/python3.7 1; \
+    echo 'Defaults>nadeko env_keep+="ASPNETCORE_* DOTNET_* NadekoBot_* shard_id total_shards TZ"' > /etc/sudoers.d/nadeko; \
+    pip3 install --upgrade youtube-dl; \
+    apt-get remove -y python3-pip; \
+    chmod +x /usr/local/bin/youtube-dl
+
+COPY --from=build /app ./
+COPY docker-entrypoint.sh /usr/local/sbin
+
 ENV shard_id=0
 ENV total_shards=1
-WORKDIR /app
-COPY --from=build /app ./
-VOLUME [ "app/data", "app/creds.yml", "app/creds_example.yml" ]
-ENTRYPOINT dotnet NadekoBot.dll "$shard_id" "$total_shards"
+
+VOLUME [ "app/data" ]
+ENTRYPOINT [ "/usr/local/sbin/docker-entrypoint.sh" ]
+CMD dotnet NadekoBot.dll "$shard_id" "$total_shards"

NadekoBot.sln

@@ -25,6 +25,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.Coordinator", "sr
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.Generators", "src\NadekoBot.Generators\NadekoBot.Generators.csproj", "{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.VotesApi", "src\NadekoBot.VotesApi\NadekoBot.VotesApi.csproj", "{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -62,6 +64,12 @@ Global
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}.GlobalNadeko|Any CPU.Build.0 = Debug|Any CPU
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.GlobalNadeko|Any CPU.ActiveCfg = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.GlobalNadeko|Any CPU.Build.0 = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -73,6 +81,7 @@ Global
 		{DB448DD4-C97F-40E9-8BD3-F605FF1FF833} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 		{AE9B7F8C-81D7-4401-83A3-643B38258374} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {5F3F555C-855F-4BE8-B526-D062D3E8ACA4}

NuGet.Config

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <packageSources>
-    <add key="Discord.Net" value="https://www.myget.org/F/discord-net/api/v3/index.json" />
-    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
-    <add key="Kwoth-myget" value="https://www.myget.org/F/kwoth/api/v3/index.json" />
-  </packageSources>
-</configuration>

README.md

@@ -1,5 +1,5 @@
 [![Discord](https://discordapp.com/api/guilds/117523346618318850/widget.png)](https://discord.gg/nadekobot)
-[![Documentation Status](https://readthedocs.org/projects/nadekobot/badge/?version=latest)](http://nadekobot.readthedocs.io/en/v3/?badge=v3)
+[![Documentation Status](https://readthedocs.org/projects/nadekobot/badge/?version=latest)](http://nadekobot.readthedocs.io/en/v4/?badge=v4)
 [![Discord Bots](https://discordbots.org/api/widget/status/116275390695079945.svg)](https://top.gg/bot/116275390695079945)  
 
   
@@ -10,6 +10,5 @@
 [![nadeko2](https://cdn.nadeko.bot/tutorial/docs-bot.png)](https://nadeko.bot/commands)
 
 ### Useful links
-- ❗ [2.x to v3 migration guide](https://nadekobot.readthedocs.io/en/v3/guides/migration-guide/)
-- [Self hosting Guides and Docs](https://nadekobot.readthedocs.io/en/v3)
+- [Self hosting Guides and Docs](https://nadekobot.readthedocs.io/en/v4)
 - [Discord support server](https://discord.nadeko.bot)

docker-entrypoint.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+set -e;
+
+data_init=/app/data_init
+data=/app/data
+
+# populate /app/data if empty
+for i in $(ls $data_init)
+do
+    if [ ! -e "$data/$i" ]; then
+        [ -f "$data_init/$i" ] && cp "$data_init/$i" "$data/$i"
+        [ -d "$data_init/$i" ] && cp -r "$data_init/$i" "$data/$i"
+    fi
+done
+
+# fix folder permissions
+chown -R nadeko:nadeko "$data"
+
+# drop to regular user and launch command
+exec sudo -u nadeko "$@"

docs/contribution-guide.md

@@ -1,6 +1,6 @@
 # How to contribute
 
-1. Make Merge Requests to the [**v3 branch**](https://gitlab.com/Kwoth/nadekobot/tree/v3)
+1. Make Merge Requests to the [**v4 branch**](https://gitlab.com/Kwoth/nadekobot/tree/v4)
 2. Keep a single Merge Request to a single feature
 3. Fill out the MR template
 

docs/creds-guide.md

@@ -13,8 +13,13 @@ This document aims to guide you through the process of creating a Discord accoun
 - Click on the `Add a Bot` button and confirm that you do want to add a bot to this app.
 - **Optional:** Add bot's avatar and description.
 - Copy your Token to `creds.yml` as shown above.
-- Scroll down to the `Privileged Gateway Intents` section and enable both intents.
-  These are required for a number of features to function properly, and should both be on.
+- Scroll down to the **`Privileged Gateway Intents`** section
+    - **Enable the following:**
+         - **PRESENCE INTENT**
+         - **SERVER MEMBERS INTENT**
+         - **MESSAGE CONTENT INTENT**
+
+These are required for a number of features to function properly, and all should be on.
 
 ##### Getting Owner ID*(s)*:
 
@@ -32,7 +37,7 @@ For a single owner, it should look like this:
         - 105635576866156544
 ```
 
-For multiple owners, it should look like this (pay attention to the commas, the last ID should **never** have a comma next to it):
+For multiple owners, it should look like this:
 
 ```yml
     OwnerIds:
@@ -56,4 +61,4 @@ For multiple owners, it should look like this (pay attention to the commas, the
 
 That's it! You may now go back to the installation guide you were following before 🎉
 
-[DiscordApp]: https://discordapp.com/developers/applications/me
+[DiscordApp]: https://discordapp.com/developers/applications/me

docs/guides/docker-guide.md

@@ -1,3 +1,33 @@
 # Setting up NadekoBot with Docker
 
-Soon:tm:
+# DO NOT USE YET - WORK IN PROGRESS
+
+### Docker Compose 
+```yml
+version: "3.7"
+services:
+  nadeko:
+    image: registry.gitlab.com/veovis/nadekobot:v3-docker
+    depends_on:
+      - redis
+    environment:
+      TZ: Europe/Paris
+      #NadekoBot_RedisOptions: redis,name=nadeko
+      #NadekoBot_ShardRunCommand: dotnet
+      #NadekoBot_ShardRunArguments: /app/NadekoBot.dll {0} {1}
+    volumes:
+      - /srv/nadeko/conf/creds.yml:/app/creds.yml:ro
+      - /srv/nadeko/data:/app/data
+
+  redis:
+    image: redis:4-alpine
+    sysctls:
+      - net.core.somaxconn=511
+    command: redis-server --maxmemory 32M --maxmemory-policy volatile-lru
+    volumes:
+      - /srv/nadeko/redis-data:/data
+```
+### Updating
+- `cd /srv/nadeko`
+- `docker-compose pull`
+- `docker-compose up -d`

docs/guides/linux-guide.md

@@ -1,87 +1,120 @@
-## Migration from 2.x 
+# Setting up NadekoBot on Linux
 
-##### ⚠ If you're already hosting NadekoBot, _You **MUST** update to latest version of 2.x and **run your bot at least once**_ before switching over to v3.
+| Table of Contents                                   |
+| :-------------------------------------------------- |
+| [Linux From Source]                                 |
+| [Source Update Instructions]                        |
+| [Linux Release]                                     |
+| [Release Update Instructions]                       |
+| [Tmux (Preferred Method)]                           |
+| [Systemd]                                           |
+| [Systemd + Script]                                  |
+| [Setting up Nadeko on a VPS (Digital Ocean)]        |
 
-#### [Linux migration instructions](../migration-guide/#linux)
+#### Operating System Compatibility
+
+It is recommended that you use **Ubuntu 20.04**, as there have been nearly no problems with it. Also, **32-bit systems are incompatible**.
+
+##### Compatible operating systems:
+
+- Ubuntu: 16.04, 18.04, 20.04, 21.04, 21.10
+- Mint: 19, 20
+- Debian: 9, 10
+- CentOS: 7
+- openSUSE
+- Fedora: 33, 34, 35
 
 ## Linux From Source 
 
-Open Terminal (if you're on an installation with a window manager) and navigate to the location where you want to install the bot (for example `cd ~`) 
+##### Migration from v3 -> v4
+
+Follow the following few steps only if you're migrating from v3. If not, skip to installation instructions.
+
+Use the new installer script:  `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
+> - Install prerequisites (type `1` and press `enter`)
+> - Download (type `2` and press `enter`)
+> - Run (type `3` and press `enter`)
+> - Done
 
 ##### Installation Instructions
 
-1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+Open Terminal (if you're on an installation with a window manager) and navigate to the location where you want to install the bot (for example `cd ~`) 
+
+1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 2. Install prerequisites (type `1` and press enter)
 3. Download the bot (type `2` and press enter)
-4. Exit the installer in order to set up your `creds.yml` 
+4. Exit the installer (type `6` and press enter)
 5. Copy the creds.yml template `cp nadekobot/output/creds_example.yml nadekobot/output/creds.yml` 
 6. Open `nadekobot/output/creds.yml` with your favorite text editor. We will use nano here
-   - `nano nadekobot/output/creds.yml`
-7. [Enter your bot's token](../../creds-guide)
-   - After you're done, you can close nano (and save the file) by inputting, in order 
-      - `CTRL` + `X`
-      - `Y`
-      - `Enter`
-8. Run the bot (type `3` and press enter)
+    - `nano nadekobot/output/creds.yml`
+7. [Click here to follow creds guide](../../creds-guide)
+    - After you're done, you can close nano (and save the file) by inputting, in order 
+       - `CTRL` + `X`
+       - `Y`
+       - `Enter`
+8. Run the installer script again `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
+9. Run the bot (type `3` and press enter)
 
-##### Update Instructions
+##### Source Update Instructions
 
-1. ⚠ Stop the bot
-2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+1. ⚠ Stop the bot ⚠
+2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 3. Update the bot (type `2` and press enter)
 4. Run the bot (type `3` and press enter)
 5. 🎉 
 
 ## Linux Release
 
+**⚠ IF YOU ARE FOLLOWING THE GUIDE ABOVE, IGNORE THIS SECTION ⚠** 
+
 ##### Installation Instructions
 
 1. Download the latest release from <https://gitlab.com/Kwoth/nadekobot/-/releases>
-   - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
+    - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
 2. Untar it 
-   - ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 1!
-   - `tar xf X.XX.X-linux-x64-build.tar`
+    - ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 1!
+    - `tar xf X.XX.X-linux-x64-build.tar`
 3. Rename the `nadekobot-linux-x64` to `nadekobot` 
-   - `mv nadekobot-linux-x64 nadekobot`
+    - `mv nadekobot-linux-x64 nadekobot`
 4. Move into nadekobot directory and make NadekoBot executable
-   - `cd nadekobot && chmod +x NadekoBot`
+    - `cd nadekobot && chmod +x NadekoBot`
 5. Copy the creds.yml template 
-   - `cp creds_example.yml creds.yml` 
+    - `cp creds_example.yml creds.yml` 
 6. Open `creds.yml` with your favorite text editor. We will use nano here
-   - `nano nadekobot/output/creds.yml`
-8. [Enter your bot's token](#creds-guide)
-   - After you're done, you can close nano (and save the file) by inputting, in order 
-      - `CTRL` + `X`
-      - `Y`
-      - `Enter`
+    - `nano nadekobot/output/creds.yml`
+8. [Click here to follow creds guide](../../creds-guide)
+    - After you're done, you can close nano (and save the file) by inputting, in order 
+       - `CTRL` + `X`
+       - `Y`
+       - `Enter`
 9. Run the bot
-   - `./NadekoBot`
+    - `./NadekoBot`
 
-##### Update Instructions
+##### Release Update Instructions
 
 1. Stop the bot
 2. Download the latest release from <https://gitlab.com/Kwoth/nadekobot/-/releases>
-   - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
+    - Look for the file called "x.x.x-linux-x64-build.tar" (where `X.X.X` is a version, for example 3.0.4) and download it
 3. Untar it 
-   - ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 2!
-   - `tar xf 2.99.8-linux-x64-build.tar`
+    - ⚠ Make sure that you change `X.X.X` to the same series of numbers as in step 2!
+    - `tar xf x.x.x-linux-x64-build.tar`
 4. Rename the old nadekobot directory to nadekobot-old (remove your old backup first if you have one, or back it up under a different name)
-   - `rm -rf nadekobot-old 2>/dev/null`
-   - `mv nadekobot nadekobot-old`
+    - `rm -rf nadekobot-old 2>/dev/null`
+    - `mv nadekobot nadekobot-old`
 5. Rename the new nadekobot directory to nadekobot
-   - `mv nadekobot-linux-x64 nadekobot`
+    - `mv nadekobot-linux-x64 nadekobot`
 6. Remove old strings and aliases to avoid overwriting the updated versions of those files  
-   - ⚠ If you've modified said files, back them up instead
-   - `rm nadekobot-old/data/aliases.yml`
-   - `rm -r nadekobot-old/data/strings`
+    - ⚠ If you've modified said files, back them up instead
+    - `rm nadekobot-old/data/aliases.yml`
+    - `rm -r nadekobot-old/data/strings`
 7. Copy old data
-   - `cp -RT nadekobot-old/data/ nadekobot/data/`
+    - `cp -RT nadekobot-old/data/ nadekobot/data`
 8. Copy creds.yml
-   - `cp nadekobot-old/creds.yml nadekobot/`
+    - `cp nadekobot-old/creds.yml nadekobot/`
 9. Move into nadekobot directory and make the NadekoBot executable
-   - `cd nadekobot && chmod +x NadekoBot`
+    - `cd nadekobot && chmod +x NadekoBot`
 10. Run the bot 
-   - `./NadekoBot`
+    - `./NadekoBot`
 
 🎉 Enjoy
 
@@ -95,7 +128,192 @@ mv nadekobot nadekobot-old && \
 mv nadekobot-linux-x64 nadekobot && \
 rm nadekobot-old/data/aliases.yml && \
 rm -r nadekobot-old/data/strings && \
-cp -RT nadekobot-old/data/ nadekobot/data/ && \
+cp -RT nadekobot-old/data/ nadekobot/data && \
 cp nadekobot-old/creds.yml nadekobot/ && \
 cd nadekobot && chmod +x NadekoBot
 ```
+
+## Running Nadeko
+
+While there are two run modes built into the installer, these options only run Nadeko within the current session. Below are 3 methods of running Nadeko as a background process.
+
+### Tmux Method (Preferred)
+
+Using `tmux` is the simplest method, and is therefore recommended for most users.
+
+1. Start a tmux session:
+    - `tmux`
+2. Navigate to the project's root directory
+    - Project root directory location example: `/home/user/nadekobot/`
+3. Enter the `output` directory:
+    - `cd output`
+4. Run the bot using:
+    - `dotnet NadekoBot.dll`
+5. Detatch the tmux session:
+    - Press `Ctrl` + `B`
+    - Then press `D`
+
+Nadeko should now be running in the background of your system. To re-open the tmux session to either update, restart, or whatever, execute `tmux a`.
+
+### Systemd
+
+Compared to using tmux, this method requires a little bit more work to set up, but has the benefit of allowing Nadeko to automatically start back up after a system reboot or the execution of the `.die` command.
+
+1. Navigate to the project's root directory
+    - Project root directory location example: `/home/user/nadekobot/`
+2. Use the following command to create a service that will be used to start Nadeko:
+
+    ```bash
+    echo "[Unit]
+    Description=NadekoBot service
+    After=network.target
+    StartLimitIntervalSec=60
+    StartLimitBurst=2
+    
+    [Service]
+    Type=simple
+    User=$USER
+    WorkingDirectory=$PWD/output
+    # If you want Nadeko to be compiled prior to every startup, uncomment the lines
+    # below. Note  that it's not neccessary unless you are personally modifying the
+    # source code.
+    #ExecStartPre=/usr/bin/dotnet build ../src/NadekoBot/NadekoBot.csproj -c Release -o output/
+    ExecStart=/usr/bin/dotnet NadekoBot.dll
+    Restart=on-failure
+    RestartSec=5
+    StandardOutput=syslog
+    StandardError=syslog
+    SyslogIdentifier=NadekoBot
+    
+    [Install]
+    WantedBy=multi-user.target" | sudo tee /etc/systemd/system/nadeko.service
+    ```
+    
+3. Make the new service available:
+    - `sudo systemctl daemon-reload`
+4. Start Nadeko:
+    - `sudo systemctl start nadeko.service && sudo systemctl enable nadeko.service`
+    
+
+### Systemd + Script
+
+This method is similar to the one above, but requires one extra step, with the added benefit of better error logging and control over what happens before and after the startup of Nadeko.
+
+1. Locate the project and move to its parent directory
+    - Project location example: `/home/user/nadekobot/`
+    - Parent directory example: `/home/user/`
+2. Use the following command to create a service that will be used to execute `NadekoRun.sh`:
+
+    ```bash
+    echo "[Unit]
+    Description=NadekoBot service
+    After=network.target
+    StartLimitIntervalSec=60
+    StartLimitBurst=2
+    
+    [Service]
+    Type=simple
+    User=$USER
+    WorkingDirectory=$_WORKING_DIR
+    ExecStart=/bin/bash NadekoRun.sh
+    Restart=on-failure
+    RestartSec=5
+    StandardOutput=syslog
+    StandardError=syslog
+    SyslogIdentifier=NadekoBot
+    
+    [Install]
+    WantedBy=multi-user.target" | sudo tee /etc/systemd/system/nadeko.service
+    ```
+    
+3. Make the new service available:
+    - `sudo systemctl daemon-reload`
+4. Use the following command to create a script that will be used to start Nadeko:
+    
+    ```bash
+    {
+    echo '#!/bin/bash'
+    echo ""
+    echo "echo \"Running NadekoBot in the background with auto restart\"
+    youtube-dl -U
+    
+    # If you want Nadeko to be compiled prior to every startup, uncomment the lines
+    # below. Note  that it's not necessary unless you are personally modifying the
+    # source code.
+    #echo \"Compiling NadekoBot...\"
+    #cd \"$PWD\"/nadekobot
+    #dotnet build src/NadekoBot/NadekoBot.csproj -c Release -o output/
+
+    echo \"Starting NadekoBot...\"
+    
+    while true; do
+        if [[ -d $PWD/nadekobot/output ]]; then
+            cd $PWD/nadekobot/output || {
+                echo \"Failed to change working directory to $PWD/nadekobot/output\" >&2
+                echo \"Ensure that the working directory inside of '/etc/systemd/system/nadeko.service' is correct\"
+                echo \"Exiting...\"
+                exit 1
+            }
+        else
+            echo \"$PWD/nadekobot/output doesn't exist\"
+            exit 1
+        fi
+        
+        dotnet NadekoBot.dll || {
+            echo \"An error occurred when trying to start NadekBot\"
+            echo \"Exiting...\"
+            exit 1
+        }
+        
+        echo \"Waiting for 5 seconds...\"
+        sleep 5
+        youtube-dl -U
+        echo \"Restarting NadekoBot...\"
+    done
+    
+    echo \"Stopping NadekoBot...\""
+    } > NadekoRun.sh
+    ```
+    
+5. Start Nadeko:
+    - `sudo systemctl start nadeko.service && sudo systemctl enable nadeko.service`
+
+### Setting up Nadeko on a Linux VPS (Digital Ocean Droplet)
+
+If you want Nadeko to play music for you 24/7 without having to hosting it on your PC and want to keep it cheap, reliable and convenient as possible, you can try Nadeko on Linux Digital Ocean Droplet using the link [DigitalOcean](http://m.do.co/c/46b4d3d44795/) (by using this link, you will get **$10 credit** and also support Nadeko)
+
+**Setting up NadekoBot**
+Assuming you have followed the link above to setup an account and a Droplet with a 64-bit operational system on Digital Ocean and got the `IP address and root password (in your e-mail)` to login, it's time to get started.
+
+**This section is only relevant to those who want to host Nadeko on DigitalOcean. Go through this whole section before setting the bot up.**
+
+#### Prerequisites
+
+- Download [PuTTY](http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html)
+- Download [WinSCP](https://winscp.net/eng/download.php) *(optional)*
+- [Create and invite the bot](../../creds-guide).
+
+#### Starting up
+
+- **Open PuTTY** and paste or enter your `IP address` and then click **Open**.  
+  If you entered your Droplets IP address correctly, it should show **login as:** in a newly opened window.
+- Now for **login as:**, type `root` and press enter.
+- It should then ask for a password. Type the `root password` you have received in your e-mail address, then press Enter.
+
+If you are running your droplet for the first time, it will most likely ask you to change your root password. To do that, copy the **password you've received by e-mail** and paste it on PuTTY.
+
+- To paste, just right-click the window (it won't show any changes on the screen), then press Enter.
+- Type a **new password** somewhere, copy and paste it on PuTTY. Press Enter then paste it again.
+
+**Save the new password somewhere safe.**
+
+After that, your droplet should be ready for use. [Follow the guide from the beginning](#linux-from-source) to set Nadeko up on your newly created VPS.
+
+[Linux From Source]: #linux-from-source
+[Source Update Instructions]: #source-update-instructions
+[Linux Release]: #linux-release
+[Release Update Instructions]: #release-update-instructions
+[Tmux (Preferred Method)]: #tmux-preferred-method
+[Systemd]: #systemd
+[Systemd + Script]: #systemd-script
+[Setting up Nadeko on a VPS (Digital Ocean)]: #setting-up-nadeko-on-a-linux-vps-digital-ocean-droplet

docs/guides/migration-guide.md

@@ -1,62 +0,0 @@
-# Migration instructions (2.x to v3)
-
-## Windows
-
-1. Run your NadekoBot Updater first, and **make sure your bot is updated to at least 2.46.5**
-   - **Run your 2.46.5 Bot** and make sure it works, and then **stop it**
-2. Get the new NadekoBot v3 Updater [here](https://dl.nadeko.bot/v3)
-3. Click on the + icon to add a new bot
-4. Next to the path, click on the folder icon and select the folder where your 2.46.5 bot is
-   - ℹ In case you're not sure where it's located, you can open your old updater and see it
-5. If you've selected the correct path, you should have an **Update** button available, click it
-6. You're done; you can now run your bot, and you can uninstall your old updater if you no longer have 2.x bots
-7. 🎉
-
-## Linux
-
-1. In order to migrate a bot hosted on **Linux**, first update your current version to the latest 2.x version using the 2.x installer, run the bot, and make sure it works. Then:
-   - Run the **old** installer with `cd ~ && wget -N https://github.com/Kwoth/NadekoBot-BashScript/raw/1.9/linuxAIO.sh && bash linuxAIO.sh`
-   - Run option **1** again
-   - Run the bot
-   - Type `.stats` and ensure the version is `2.46.5` or later
-   - Stop the bot
-2. Make sure your bot's folder is called `NadekoBot`
-   - Run `cd ~ && ls`
-   - Confirm there is a folder called NadekoBot (not nadekobot, in all lowercase)
-3. Migrate your bot's data using the new installer:
-   - Run the **new** installer `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
-   - The installer should notify you that your data is ready for migration in a message above the menu.
-   - Install prerequisites (type `1` and press enter), and make sure it is successful
-   - Download NadekoBot v3 (type `2` and press enter)
-   - Run the bot (type `3` and press enter)
-4. Make sure your permissions, custom reactions, credentials, and other data is preserved
-   - `.stats` to ensure owner id (credentials) is correct
-   - `.lcr` to see custom reactions
-   - `.lp` to list permissions
-5. 🎉 Enjoy. If you want to learn how to update the bot, click (here)[../linux-guide/#update-instructions].
-
-## Manual 
-
-⚠ NOT RECOMMENDED  
-⚠ NadekoBot v3 requires [.net 5](https://dotnet.microsoft.com/download/dotnet/5.0)
-
-1. In order to migrate a bot hosted **on Linux or from source on Windows**, first update your current version to the latest 2.x version using the 2.x installer, run the bot, and make sure it works. Then:
-2. Rename your old nadeko bot folder to `nadekobot_2x`
-   - `mv NadekoBot nadekobot_2x`
-3. Build the new version and move old data to the output folder 
-   1. Clone the v3 branch to a separate folder 
-      - `git clone https://gitlab.com/kwoth/nadekobot -b v3 --depth 1`
-   2. Build the bot
-      - `dotnet publish -c Release -o output/ src/NadekoBot/`
-   3. Copy old data
-      - ⚠ Be sure you copy the correct command for your system!
-      - **Windows:** `cp -r -fo nadekobot_2x/src/NadekoBot/data nadekobot/src/NadekoBot/data`
-      - **Linux:** `cp -rf nadekobot_2x/src/NadekoBot/data nadekobot/src/NadekoBot/data`
-   4. Copy the database 
-      - `cp nadekobot_2x/src/NadekoBot/bin/Release/netcoreapp2.1/data/NadekoBot.db nadekobot/output/data`
-   5. Copy your credentials
-      - `cp nadekobot_2x/src/NadekoBot/credentials.json nadekobot/output/`
-4. Run the bot
-   - `cd nadekobot/output`
-   - `dotnet NadekoBot.dll`
-5. That's it. Just make sure that when you're updating the bot, you're properly backing up your old data.

docs/guides/osx-guide.md

@@ -1,18 +1,46 @@
-### Linux From Source 
+## MacOS From Source 
 
-Open Terminal (if you're on an installation with a window manager) and navigate to the location where you want to install the bot (for example `cd ~`) 
+Open Terminal (if you don't know how to, click on the magnifying glass on the top right corner of your screen and type **Terminal** on the window that pops up) and navigate to the location where you want to install the bot (for example `cd ~`) 
+
+##### Installing Homebrew, wget and dotnet  
+
+###### Homebrew/wget  
+*Skip this step if you already have homebrew installed*
+- Copy and paste this command, then press Enter:  
+    - `/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"`  
+- Install wget  
+    - `brew install wget`  
+    
+###### Dotnet
+- Download [.net6 SDK](https://dotnet.microsoft.com/download/dotnet/6.0)
+- Open the `.pkg` file you've downloaded and install it.
+- Run this command in Terminal. There might be output. If there is, disregard it. (copy-paste the entire block)
+```bash
+sudo mkdir /usr/local/bin
+
+sudo mkdir /usr/local/lib
+```
+- Run this command in Terminal. There won't be any output. (copy-paste the entire block):
+```bash
+sudo ln -s /usr/local/share/dotnet/dotnet /usr/local/bin
+
+sudo ln -s /usr/local/opt/openssl/lib/libcrypto.1.0.0.dylib /usr/local/lib/
+
+sudo ln -s /usr/local/opt/openssl/lib/libssl.1.0.0.dylib /usr/local/lib/
+```
 
 ##### Installation Instructions
 
-1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 2. Install prerequisites (type `1` and press enter)
 3. Download the bot (type `2` and press enter)
 4. Exit the installer in order to set up your `creds.yml` 
-5. Copy the creds.yml template `cp nadekobot/output/creds_example.yml nadekobot/output/creds.yml` 
+5. Copy the creds.yml template 
+    `cp nadekobot/output/creds_example.yml nadekobot/output/creds.yml` 
 6. Open `nadekobot/output/creds.yml` with your favorite text editor. We will use nano here
-   - `nano nadekobot/output/creds.yml`
+    - `nano nadekobot/output/creds.yml`
 7. [Enter your bot's token](#creds-guide)
-   - After you're done, you can close nano (and save the file) by inputting, in order 
+    - After you're done, you can close nano (and save the file) by inputting, in order 
       - `CTRL`+`X`
       - `Y`
       - `Enter`
@@ -21,12 +49,14 @@ Open Terminal (if you're on an installation with a window manager) and navigate
 ##### Update Instructions
 
 1. ⚠ Stop the bot
-2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 3. Update the bot (type `2` and press enter)
 4. Run the bot (type `3` and press enter)
 5. 🎉 
 
-### Linux Release
+## MacOS Manual Release installation instructions
+
+⚠ IF YOU ARE FOLLOWING THE GUIDE ABOVE, IGNORE THIS SECTION ⚠ 
 
 ##### Installation Instructions
 
@@ -34,48 +64,48 @@ Open Terminal (if you're on an installation with a window manager) and navigate
    - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
 2. Untar it 
    ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 1!
-   - `tar xf X.XX.X-linux-x64-build.tar`
+    - `tar xf X.XX.X-linux-x64-build.tar`
 3. Rename the `nadekobot-linux-x64` to `nadekobot` 
-   - `mv nadekobot-linux-x64 nadekobot`
+    - `mv nadekobot-linux-x64 nadekobot`
 4. Move into nadekobot directory and make NadekoBot executable
-   - `cd nadekobot && chmod +x NadekoBot`
+    - `cd nadekobot && chmod +x NadekoBot`
 5. Copy the creds.yml template 
-   - `cp creds_example.yml creds.yml` 
+    - `cp creds_example.yml creds.yml` 
 6. Open `creds.yml` with your favorite text editor. We will use nano here
-   - `nano nadekobot/output/creds.yml`
+    - `nano nadekobot/output/creds.yml`
 8. [Enter your bot's token](#creds-guide)
-   - After you're done, you can close nano (and save the file) by inputting, in order 
-      - `CTRL`+`X`
-      - `Y`
-      - `Enter`
+    - After you're done, you can close nano (and save the file) by inputting, in order 
+       - `CTRL`+`X`
+       - `Y`
+       - `Enter`
 9. Run the bot
-   - `./NadekoBot`
+    - `./NadekoBot`
 
 ##### Update Instructions
 
 1. Stop the bot
 2. Download the latest release from <https://gitlab.com/Kwoth/nadekobot/-/releases>
-   - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
+    - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
 3. Untar it 
    ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 2!
-   - `tar xf 2.99.8-linux-x64-build.tar`
+    - `tar xf 2.99.8-linux-x64-build.tar`
 4. Rename the old nadekobot directory to nadekobot-old (remove your old backup first if you have one, or back it up under a different name)
-   - `rm -rf nadekobot-old 2>/dev/null`
-   - `mv nadekobot nadekobot-old`
+    - `rm -rf nadekobot-old 2>/dev/null`
+    - `mv nadekobot nadekobot-old`
 5. Rename the new nadekobot directory to nadekobot
-   - `mv nadekobot-linux-x64 nadekobot`
+    - `mv nadekobot-linux-x64 nadekobot`
 6. Remove old strings and aliases to avoid overwriting the updated versions of those files  
    ⚠ If you've modified said files, back them up instead
-   - `rm nadekobot-old/data/aliases.yml`
-   - `rm -r nadekobot-old/data/strings`
+    - `rm nadekobot-old/data/aliases.yml`
+    - `rm -r nadekobot-old/data/strings`
 7. Copy old data
-   - `cp -RT nadekobot-old/data/ nadekobot/data/`
+    - `cp -RT nadekobot-old/data/ nadekobot/data/`
 8. Copy creds.yml
-   - `cp nadekobot-old/creds.yml nadekobot/`
+    - `cp nadekobot-old/creds.yml nadekobot/`
 9. Move into nadekobot directory and make the NadekoBot executable
-   - `cd nadekobot && chmod +x NadekoBot`
+    - `cd nadekobot && chmod +x NadekoBot`
 10. Run the bot 
-   - `./NadekoBot`
+    - `./NadekoBot`
 
 🎉 Enjoy
 
@@ -92,4 +122,4 @@ rm -r nadekobot-old/data/strings && \
 cp -RT nadekobot-old/data/ nadekobot/data/ && \
 cp nadekobot-old/creds.yml nadekobot/ && \
 cd nadekobot && chmod +x NadekoBot
-```
+```

docs/guides/windows-guide.md

@@ -1,9 +1,3 @@
-## Migration from 2.x 
-
-⚠ If you're already hosting NadekoBot, You **MUST** update to latest version of 2.x and **run your bot at least once** before switching over to v3.
-
-#### [Windows migration instructions](../migration-guide#windows)
-
 ## Setting Up NadekoBot on Windows With the Updater
 
 | Table of Contents|
@@ -12,16 +6,16 @@
 | [Setup](#setup)                                                                                                             |
 | [Starting the Bot](#starting-the-bot)                                                                                       |
 | [Updating Nadeko](#updating-nadeko)                                                                                         |
-| [Manually Installing the Prerequisites from the Updater](#if-the-updater-fails-to-install-the-prerequisites-for-any-reason) |
+| [Manually Installing the Prerequisites from the Updater](#music-prerequisites) |
 
-*Note: If you want to make changes to Nadeko's source code, please follow the [From Source][SourceGuide] guide instead.*
+*Note: If you want to make changes to Nadeko's source code, please follow the [From Source](#windows-from-source) guide instead.*
 
-*If you have Windows 7 or a 32-bit system, please refer to the [From Source][SourceGuide] guide.*
+*If you have Windows 7 or a 32-bit system, please refer to the [From Source](#windows-from-source)) guide.*
 
 #### Prerequisites
 
 - Windows 8 or later (64-bit)
-- [Create a Discord Bot application and invite the bot to your server](../../creds-guide.md)
+- [Create a Discord Bot application and invite the bot to your server](../creds-guide.md)
 
 **Optional**
 
@@ -32,12 +26,13 @@
 
 - Download and run the [NadekoBot v3 Updater][Updater].
 - Click on the + at the top left to create a new bot.
- ![NadekoBot Updater](https://i.imgur.com/KZV49uf.png "NadekoBot Updater")
+ ![NadekoBot Updater](https://i.imgur.com/FmR7F7o.png "NadekoBot Updater")
 - Give your bot a name and then click **`Go to setup`** at the lower right.
- ![Create a new bot](https://i.imgur.com/Xnp7iQL.png "Create a new bot")
+ ![Create a new bot](https://i.imgur.com/JxtRk9e.png "Create a new bot")
 - Click on **`DOWNLOAD`** at the lower right
- ![Bot Setup](https://i.imgur.com/6RMXNqw.png "Bot Setup")
+ ![Bot Setup](https://i.imgur.com/HqAl36p.png "Bot Setup")
 - Click on **`Install`** next to **`Redis`**.
+- Note: If Redis fails to install, install Redis manually here: [Redis Installer](https://github.com/MicrosoftArchive/redis/releases/tag/win-3.0.504) Download and run the **`.msi`** file.
 - If you will use the music module, click on **`Install`** next to **`FFMPEG`** and **`Youtube-DL`**.
 - If any dependencies fail to install, you can temporarily disable your Windows Defender/AV until you install them. If you don't want to, then read [the last section of this guide](#Manual-Prerequisite-Installation).
 - When installation is finished, click on **`CREDS`** to the left of **`RUN`** at the lower right.
@@ -47,6 +42,8 @@
 
 - Either click on **`RUN`** button in the updater or run the bot via its desktop shortcut.
 
+### If you get a "No owner channels created..." message. Please follow the creds guide again [**HERE**](../../creds-guide).
+
 #### Updating Nadeko
 
 - Make sure Nadeko is closed and not running  
@@ -68,10 +65,12 @@ You can still install them manually:
 
 ### Windows From Source
 
+⚠ IF YOU ARE FOLLOWING THE GUIDE ABOVE, IGNORE THIS SECTION ⚠ 
+
 ##### Prerequisites
 
 **Install these before proceeding or your bot will not work!**
-- [.net 5](https://dotnet.microsoft.com/download/dotnet/5.0)  - needed to compile and run the bot
+- [.net 6](https://dotnet.microsoft.com/download/dotnet/6.0)  - needed to compile and run the bot
 - [git](https://git-scm.com/downloads) - needed to clone the repository (you can also download the zip manually and extract it, but this guide assumes you're using git)
 - [redis](https://github.com/MicrosoftArchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.msi) - to cache things needed by some features and persist through restarts
 
@@ -79,42 +78,56 @@ You can still install them manually:
 
 Open PowerShell (press windows button on your keyboard and type powershell, it should show up; alternatively, right click the start menu and select Windows PowerShell), and navigate to the location where you want to install the bot (for example `cd ~/Desktop/`)  
 
-1. `git clone https://gitlab.com/kwoth/nadekobot -b v3 --depth 1`
+1. `git clone https://gitlab.com/kwoth/nadekobot -b v4 --depth 1`
+2. `cd nadekobot`
 3. `dotnet publish -c Release -o output/ src/NadekoBot/`
-4. `cd output && cp creds_example.yml creds.yml`
-5. Open `creds.yml` with your favorite text editor (Please don't use Notepad or WordPad. You can use Notepad++, VSCode, Atom, Sublime, or something similar)
-6. [Enter your bot's token](#creds-guide)
-7. Run the bot `dotnet NadekoBot.dll` 
-8. 🎉
+4. `cd output`
+5. `cp creds_example.yml creds.yml`
+6. Open `creds.yml` with your favorite text editor (Please don't use Notepad or WordPad. You can use Notepad++, VSCode, Atom, Sublime, or something similar)
+7. [Enter your bot's token](#creds-guide)
+8. Run the bot `dotnet NadekoBot.dll` 
+9. 🎉
 
 ##### Update Instructions
 
 Open PowerShell as described above and run the following commands:
 
-1. Navigate to your bot's folder, for example `cd ~/Desktop/nadekobot/src/NadekoBot`
-2. Pull the latest updates (this will fail if you have custom code changes).
-   - If you don't have custom code changes, just run `git pull`
-   - If you do have custom code changes, You have 3 options
-      - Undo all changes with `git checkout -- * && git pull`
-      - Stash changes and try to re-apply them `git stash && git pull && git stash apply`
-      - Commit your changes and resolve merge conflicts `git add . && git commit -m "My commit message" && git pull`
-3. Re-run the bot `dotnet run -c Release`
+1. Stop the bot
+  - ⚠️ Make sure you don't have your database, credentials or any other nadekobot folder open in some application, this might prevent some of the steps from executing succesfully
+2. Navigate to your bot's folder, example:
+    - `cd ~/Desktop/nadekobot`
+3. Pull the new version
+    - `git pull`
+    - ⚠️ If this fails, you may want to stash or remove your code changes if you don't know how to resolve merge conflicts
+4. **Backup** old output in case your data is overwritten
+    - `cp -r -fo output/ output-old`
+5. Build the bot again
+    - `dotnet publish -c Release -o output/ src/NadekoBot/`
+6. Remove old strings and aliases to avoid overwriting the updated versions of those files  
+    - ⚠ If you've modified said files, back them up instead
+    - `rm output-old/data/aliases.yml`
+    - `rm -r output-old/data/strings`
+7. Copy old data
+    - `cp -Recurse .\output-old\data\ .\output\ -Force`
+8. Copy creds.yml
+    - `cp output-old/creds.yml output/`
+9. Run the bot 
+    - `cd output`
+    - `dotnet NadekoBot.dll`
 
-⚠ You're expected to understand that your database will be in `bin/Release/<framework>/data/`, and if `<framework>` gets changed in the future, you will have to move your database manually.
+🎉 Enjoy
 
 #### Music prerequisites  
 In order to use music commands, you need ffmpeg and youtube-dl installed.
 - [ffmpeg-32bit] | [ffmpeg-64bit] - Download the **appropriate version** for your system (32 bit if you're running a 32 bit OS, or 64 if you're running a 64bit OS). Unzip it, and move `ffmpeg.exe` to a path that's in your PATH environment variable. If you don't know what that is, just move the `ffmpeg.exe` file to `NadekoBot/output`.
 - [youtube-dl] - Click to download the file, then move `youtube-dl.exe` to a path that's in your PATH environment variable. If you don't know what that is, just move the `youtube-dl.exe` file to `NadekoBot/system`.
 
-[Updater]: https://dl.nadeko.bot/v3
+[Updater]: https://dl.nadeko.bot/
 [Notepad++]: https://notepad-plus-plus.org/
 [.net]: https://dotnet.microsoft.com/download/dotnet/5.0
 [Redis]: https://github.com/MicrosoftArchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.msi
 [Visual C++ 2010 (x86)]: https://download.microsoft.com/download/1/6/5/165255E7-1014-4D0A-B094-B6A430A6BFFC/vcredist_x86.exe
 [Visual C++ 2017 (x64)]: https://aka.ms/vs/15/release/vc_redist.x64.exe
-[SourceGuide]: ../from-source
 [ffmpeg-32bit]: https://cdn.nadeko.bot/dl/ffmpeg-32.zip
 [ffmpeg-64bit]: https://cdn.nadeko.bot/dl/ffmpeg-64.zip
 [youtube-dl]: https://yt-dl.org/downloads/latest/youtube-dl.exe
-

docs/jsons-explained.md

@@ -8,8 +8,14 @@ This part is completely optional, **however it's necessary for music and a few o
         - Go to [Google Console][Google Console] and log in.
         - Create a new project (name does not matter).
         - Once the project is created, go into `Library`
-        - Under the `YouTube APIs` section, enable `YouTube Data API`
-        - On the left tab, access `Credentials`,
+        - Under the `YouTube APIs` section
+            - Select `YouTube Data API v3`,
+            - Click enable.
+        - Search for `Custom Search API`
+            - Select `Custom Search API`,
+            - Click enable.
+        - Open up the `Navigation menu` on the top right with the three lines.
+        - select `APIs & Services`, then select `Credentials`,
             - Click `Create Credentials` button,
             - Click on `API Key`
             - A new window will appear with your `Google API key`  
@@ -18,7 +24,7 @@ This part is completely optional, **however it's necessary for music and a few o
         - Open up `creds.yml` and look for `GoogleAPIKey`, paste your API key after the `:`.
         - It should look like this:
         ```yml
-        GoogleApiKey: "AIzaSyDSci1sdlWQOWNVj1vlXxxxxxbk0oWMEzM",
+        GoogleApiKey: AIzaSyDSci1sdlWQOWNVj1vlXxxxxxbk0oWMEzM
         ```
 - **MashapeKey**
     - Required for Hearthstone cards.
@@ -42,9 +48,8 @@ This part is completely optional, **however it's necessary for music and a few o
     - Select `Chat Bot` from the Category dropdown
     - Once created, clicking on your application will show a new Client ID field
     - Copy it to your creds.yml as shown below
-    - *(if you're adding it as the last key inside your creds.yml, remove the trailling comma from the example below)*
     ```yml
-        TwitchClientId: "516tr61tr1qweqwe86trg3g",
+        TwitchClientId: "516tr61tr1qweqwe86trg3g"
     ```
 - **LocationIqApiKey**
     - Optional. Used only for the `.time` command. https://locationiq.com api key (register and you will receive the token in the email). 
@@ -70,48 +75,98 @@ For Windows (Updater), add this to your `creds.yml`
 ```yml
 RestartCommand:
     Cmd: "NadekoBot.exe"
+    args: "{0}"
 ```
 
 For Windows (Source), Linux or OSX, add this to your `creds.yml`
 
 ```yml
-"RestartCommand": {
-    "Cmd": "dotnet",
-    "Args": "run -c Release"
-},
+RestartCommand:
+    Cmd: dotnet
+    Args: "NadekoBot.dll -- {0}"
 ```
 
 ---
 
 #### End Result
 
-**This is an example of how the `creds.yml` looks like with multiple owners, the restart command (optional) and all the API keys (also optional):**
+**This is an example of how the `creds.yml` looks like with multiple owners, the restart command (optional) and some of the API keys (also optional):**
 
 ```yml
-{
-  "Token": "MTc5MzcyXXX2MDI1ODY3MjY0.ChKs4g.I8J_R9XX0t-QY-0PzXXXiN0-7vo",
-  "OwnerIds": [
-        105635123466156544,
-        145521851676884992,
-        341420590009417729
-  ],
-  "GoogleApiKey": "AIzaSyDSci1sdlWQOWNVj1vlXxxxxxbk0oWMEzM",
-  "MashapeKey": "4UrKpcWXc2mshS8RKi00000y8Kf5p1Q8kI6jsn32bmd8oVWiY7",
-  "OsuApiKey": "4c8c8fdff8e1234581725db27fd140a7d93320d6",
-  "CleverbotApiKey": "",
-  "Db": null,
-  "TotalShards": 1,
-  "PatreonAccessToken": "",
-  "PatreonCampaignId": "334038",
-  "RestartCommand": {
-    "Cmd": "NadekoBot.exe"
-	},
-  "ShardRunCommand": "",
-  "ShardRunArguments": "",
-  "ShardRunPort": null,
-  "TwitchClientId": null,
-  "RedisOptions": null
-}
+# DO NOT CHANGE
+version: 1
+# Bot token. Do not share with anyone ever -> https://discordapp.com/developers/applications/
+token: 'MTE5Nzc3MDIxMzE5NTc3NjEw.VlhNCw.BuqJFyzdIUAK1PRf1eK1Cu89Jew'
+# List of Ids of the users who have bot owner permissions
+# **DO NOT ADD PEOPLE YOU DON'T TRUST**
+ownerIds: 
+    - 105635123466156544
+    - 145521851676884992
+    - 341420590009417729
+# The number of shards that the bot will running on.
+# Leave at 1 if you don't know what you're doing.
+totalShards: 1
+# Login to https://console.cloud.google.com, create a new project, go to APIs & Services -> Library -> YouTube Data API and enable it.
+# Then, go to APIs and Services -> Credentials and click Create credentials -> API key.
+# Used only for Youtube Data Api (at the moment).
+googleApiKey: 'AIzaSyDScfdfdfi1sdlWQOWxxxxxbk0oWMEzM'
+# Settings for voting system for discordbots. Meant for use on global Nadeko.
+votes:
+  url: ''
+  key: ''
+# Patreon auto reward system settings.
+# go to https://www.patreon.com/portal -> my clients -> create client
+patreon:
+# Access token. You have to manually update this 1st of each month by refreshing the token on https://patreon.com/portal
+  accessToken: ''
+  # Unused atm
+  refreshToken: ''
+  # Unused atm
+  clientSecret: ''
+  # Campaign ID of your patreon page. Go to your patreon page (make sure you're logged in) and type "prompt('Campaign ID', window.patreon.bootstrap.creator.data.id);" in the console. (ctrl + shift + i)
+  campaignId: ''
+# Api key for sending stats to DiscordBotList.
+botListToken: ''
+# Official cleverbot api key.
+cleverbotApiKey: ''
+# Redis connection string. Don't change if you don't know what you're doing.
+redisOptions: localhost:6379,syncTimeout=30000,responseTimeout=30000,allowAdmin=true,password=
+# Database options. Don't change if you don't know what you're doing. Leave null for default values
+db:
+# Database type. Only sqlite supported atm
+  type: sqlite
+  # Connection string. Will default to "Data Source=data/NadekoBot.db"
+  connectionString: Data Source=data/NadekoBot.db
+# Address and port of the coordinator endpoint. Leave empty for default.
+# Change only if you've changed the coordinator address or port.
+coordinatorUrl: http://localhost:3442
+# Api key obtained on https://rapidapi.com (go to MyApps -> Add New App -> Enter Name -> Application key)
+rapidApiKey: 4UrKpcWXcxxxxxxxxxxxxxxp1Q8kI6jsn32xxxoVWiY7
+# https://locationiq.com api key (register and you will receive the token in the email).
+# Used only for .time command.
+locationIqApiKey: 
+# https://timezonedb.com api key (register and you will receive the token in the email).
+# Used only for .time command
+timezoneDbApiKey: 
+# https://pro.coinmarketcap.com/account/ api key. There is a free plan for personal use.
+# Used for cryptocurrency related commands.
+coinmarketcapApiKey: 
+# Api key used for Osu related commands. Obtain this key at https://osu.ppy.sh/p/api
+osuApiKey: 4c8c8fdffdsfdsfsdfsfa33f3f3140a7d93320d6
+# Command and args which will be used to restart the bot.
+# Only used if bot is executed directly (NOT through the coordinator)
+# placeholders: 
+#     {0} -> shard id 
+#     {1} -> total shards
+# Linux default
+#     cmd: dotnet
+#     args: "NadekoBot.dll -- {0}"
+# Windows default
+#     cmd: "NadekoBot.exe"
+#     args: "{0}"
+restartCommand:
+  cmd: 
+  args: 
 ```
 
 ---
@@ -121,13 +176,13 @@ For Windows (Source), Linux or OSX, add this to your `creds.yml`
 Nadeko saves all settings and data in the database file `NadekoBot.db`, located in:
 
 - Windows (Updater): `system/data` (can be easily accessed through the `Data` button on the updater)
-- Windows (Source), Linux and OSX: `NadekoBot/src/NadekoBot/bin/Release/netcoreapp2.1/data/NadekoBot.db`
+- Windows (Source), Linux and OSX: `nadekobot/output/data/NadekoBot.db`
 
 In order to open it you will need [SQLite Browser](http://sqlitebrowser.org/).
 
 *NOTE: You don't have to worry if you don't have the `NadekoBot.db` file, it gets automatically created once you successfully run the bot for the first time.*
 
-**To make changes:**
+**To make changes to the database on windows:**
 
 - Shut your bot down.
 - Copy the `NadekoBot.db` file to someplace safe. (Back up)
@@ -146,20 +201,24 @@ In order to open it you will need [SQLite Browser](http://sqlitebrowser.org/).
 
 ## Sharding your bot
 
-- **ShardRunCommand**
-    - Command with which to run shards 1+
-    - Required if you're sharding your bot on windows using .exe, or in a custom way.
-    - This internally defaults to `dotnet`
-    - For example, if you want to shard your NadekoBot which you installed using windows installer, you would want to set it to something like this: `C:\Program Files\NadekoBot\system\NadekoBot.exe`
-- **ShardRunArguments**
-    - Arguments to the shard run command
-    - Required if you're sharding your bot on windows using .exe, or in a custom way.
-    - This internally defaults to `run -c Release --no-build -- {0} {1} {2}` which will be enough to run linux and other 'from source' setups
-    - {0} will be replaced by the `shard ID` of the shard being ran, {1} by the shard 0's process id, and {2} by the port shard communication is happening on
-    - If shard0 (main window) is closed, all other shards will close too
-    - For example, if you want to shard your NadekoBot which you installed using windows installer, you would want to set it to `{0} {1} {2}`
-- **ShardRunPort**
-    - Bot uses a random UDP port in [5000, 6000] range for communication between shards
+To run a sharded bot, you will want to run `src/NadekoBot.Coordinator` project.
+Shards communicate with the coordinator using gRPC
+To configure your Coordinator, you will need to edit the `src/NadekoBot.Coordinator/coord.yml` file
+
+```yml
+# total number of shards
+TotalShards: 3
+# How often do shards ping their state back to the coordinator
+RecheckIntervalMs: 5000
+# Command to run the shard
+ShardStartCommand: dotnet
+# Arguments to run the shard
+# {0} = shard id
+# {1} = total number of shards
+ShardStartArgs: ../../output/NadekoBot.dll -- {0} {1}
+# How long does it take for the shard to be forcefully restarted once it stops reporting its state
+UnresponsiveSec: 30
+```
 
 [Google Console]: https://console.developers.google.com
 [DiscordApp]: https://discordapp.com/developers/applications/me

exe_builder.iss

@@ -1,7 +1,7 @@
 #define sysfolder "system"
 #define version GetEnv("NADEKOBOT_INSTALL_VERSION")
 #define target "win7-x64"
-#define platform "net5.0"
+#define platform "net6.0"
 
 [Setup]
 AppName = {param:botname|NadekoBot}

mkdocs.yml

@@ -72,11 +72,9 @@ markdown_extensions:
 nav:
     - Home: index.md
     - Guides:
-        - ❗ Migration Guide: guides/migration-guide.md
         - Windows Guide: guides/windows-guide.md
         - Linux Guide: guides/linux-guide.md
         - OSX Guide: guides/osx-guide.md
-        - From Source: guides/from-source.md
         - Docker Guide (unsupported): guides/docker-guide.md
     - Commands:
         - Readme: commands-readme.md

src/NadekoBot.Coordinator/CoordStartup.cs

@@ -12,9 +12,7 @@ namespace NadekoBot.Coordinator
         public IConfiguration Configuration { get; }
         
         public CoordStartup(IConfiguration config)
-        {
-            Configuration = config;
-        }
+            => Configuration = config;
 
         public void ConfigureServices(IServiceCollection services)
         {

src/NadekoBot.Coordinator/LogSetup.cs

@@ -21,7 +21,7 @@ namespace NadekoBot.Services
                 .Enrich.WithProperty("LogSource", source)
                 .CreateLogger();
             
-            System.Console.OutputEncoding = Encoding.UTF8;
+            Console.OutputEncoding = Encoding.UTF8;
         }
 
         private static ConsoleTheme GetTheme()

src/NadekoBot.Coordinator/NadekoBot.Coordinator.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -9,9 +9,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore" Version="2.38.0" />
+    <PackageReference Include="Grpc.AspNetCore" Version="2.42.0" />
     <PackageReference Include="Serilog" Version="2.10.0" />
-    <PackageReference Include="Serilog.Sinks.Console" Version="4.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
     <PackageReference Include="YamlDotNet" Version="11.2.1" />
   </ItemGroup>
   

src/NadekoBot.Coordinator/Services/CoordinatorRunner.cs

@@ -6,7 +6,6 @@ using System.Linq;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using YamlDotNet.Serialization;
@@ -30,7 +29,7 @@ namespace NadekoBot.Coordinator
         private readonly Random _rng;
         private bool _gracefulImminent;
         
-        public CoordinatorRunner(IConfiguration configuration)
+        public CoordinatorRunner()
         {
             _serializer = new();
             _deserializer = new();
@@ -91,7 +90,7 @@ namespace NadekoBot.Coordinator
                         var shardIds = Enumerable.Range(0, 1) // shard 0 is always first
                             .Append((int)((117523346618318850 >> 22) % _config.TotalShards)) // then nadeko server shard
                             .Concat(Enumerable.Range(1, _config.TotalShards - 1)
-                                .OrderBy(x => _rng.Next())) // then all other shards in a random order
+                                .OrderBy(_ => _rng.Next())) // then all other shards in a random order
                             .Distinct()
                             .ToList();
                         
@@ -160,18 +159,24 @@ namespace NadekoBot.Coordinator
         private void StartShard(int shardId)
         {
             var status = _shardStatuses[shardId];
-            if (status.Process is {HasExited: false} p)
+            try
             {
-                try
+                if (status.Process is { HasExited: false } p)
                 {
-                    p.Kill(true);
+                    try
+                    {
+                        p.Kill(true);
+                    }
+                    catch
+                    {
+                    }
                 }
-                catch
-                {
-                }
-            }
 
-            status.Process?.Dispose();
+                status.Process?.Dispose();
+            }
+            catch
+            {
+            }
 
             var proc = StartShardProcess(shardId);
             _shardStatuses[shardId] = status with
@@ -185,8 +190,7 @@ namespace NadekoBot.Coordinator
         }
 
         private Process StartShardProcess(int shardId)
-        {
-            return Process.Start(new ProcessStartInfo()
+            => Process.Start(new ProcessStartInfo()
             {
                 FileName = _config.ShardStartCommand,
                 Arguments = string.Format(_config.ShardStartArgs,
@@ -199,7 +203,6 @@ namespace NadekoBot.Coordinator
                 // CreateNoWindow = true,
                 // UseShellExecute = false,
             });
-        }
 
         public bool Heartbeat(int shardId, int guildCount, ConnState state)
         {
@@ -233,7 +236,6 @@ namespace NadekoBot.Coordinator
         {
             lock (locker)
             {
-                ref var toSave = ref _config;
                 SaveConfig(new Config(
                     totalShards,
                     _config.RecheckIntervalMs,
@@ -278,7 +280,7 @@ namespace NadekoBot.Coordinator
                 for (var shardId = 0; shardId < _shardStatuses.Length; shardId++)
                 {
                     var status = _shardStatuses[shardId];
-                    if (status.Process is Process p)
+                    if (status.Process is { } p)
                     {
                         p.Kill();
                         p.Dispose();
@@ -308,7 +310,7 @@ namespace NadekoBot.Coordinator
                     })
                     .ToList()
             };
-            var jsonState = JsonSerializer.Serialize(coordState, new ()
+            var jsonState = JsonSerializer.Serialize(coordState, new JsonSerializerOptions()
             {
                 WriteIndented = true,
             });
@@ -340,7 +342,7 @@ namespace NadekoBot.Coordinator
 
                 if (savedState.StatusObjects.Count != _config.TotalShards)
                 {
-                    Log.Error("Unable to restore old state because shard count doesn't match.");
+                    Log.Error("Unable to restore old state because shard count doesn't match");
                     File.Move(GRACEFUL_STATE_PATH, GRACEFUL_STATE_BACKUP_PATH, overwrite: true);
                     return false;
                 }
@@ -351,7 +353,7 @@ namespace NadekoBot.Coordinator
                 {
                     var statusObj = savedState.StatusObjects[shardId];
                     Process p = null;
-                    if (statusObj.Pid is int pid)
+                    if (statusObj.Pid is { } pid)
                     {
                         try
                         {
@@ -359,7 +361,7 @@ namespace NadekoBot.Coordinator
                         }
                         catch (Exception ex)
                         {
-                            Log.Warning(ex, $"Process for shard {shardId} is not runnning.");
+                            Log.Warning(ex, "Process for shard {ShardId} is not runnning", shardId);
                         }
                     }
 
@@ -435,9 +437,7 @@ namespace NadekoBot.Coordinator
         }
 
         public string GetConfigText()
-        {
-            return File.ReadAllText(CONFIG_PATH);
-        }
+            => File.ReadAllText(CONFIG_PATH);
 
         public void SetConfigText(string text)
         {

src/NadekoBot.Coordinator/Services/CoordinatorService.cs

@@ -5,14 +5,12 @@ using Grpc.Core;
 
 namespace NadekoBot.Coordinator
 {
-    public sealed class CoordinatorService : NadekoBot.Coordinator.Coordinator.CoordinatorBase
+    public sealed class CoordinatorService : Coordinator.CoordinatorBase
     {
         private readonly CoordinatorRunner _runner;
 
         public CoordinatorService(CoordinatorRunner runner)
-        {
-            _runner = runner;
-        }
+            => _runner = runner;
 
         public override Task<HeartbeatReply> Heartbeat(HeartbeatRequest request, ServerCallContext context)
         {
@@ -113,11 +111,10 @@ namespace NadekoBot.Coordinator
             return new DieReply();
         }
 
-        public override async Task<SetConfigTextReply> SetConfigText(SetConfigTextRequest request, ServerCallContext context)
+        public override Task<SetConfigTextReply> SetConfigText(SetConfigTextRequest request, ServerCallContext context)
         {
-            await Task.Yield();
-            string error = string.Empty;
-            bool success = true;
+            var error = string.Empty;
+            var success = true;
             try
             {
                 _runner.SetConfigText(request.ConfigYml);
@@ -128,11 +125,11 @@ namespace NadekoBot.Coordinator
                 success = false;
             }
 
-            return new(new()
+            return Task.FromResult<SetConfigTextReply>(new(new()
             {
                 Success = success,
                 Error = error
-            });
+            }));
         }
 
         public override Task<GetConfigTextReply> GetConfigText(GetConfigTextRequest request, ServerCallContext context)

src/NadekoBot.Coordinator/Shared/JsonStatusObject.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace NadekoBot.Coordinator
+namespace NadekoBot.Coordinator
 {
     public class JsonStatusObject
     {

src/NadekoBot.Coordinator/coord.yml

@@ -1,5 +1,12 @@
+# total number of shards
 TotalShards: 3
+# How often do shards ping their state back to the coordinator
 RecheckIntervalMs: 5000
+# Command to run the shard
 ShardStartCommand: dotnet
+# Arguments to run the shard
+# {0} = shard id
+# {1} = total number of shards
 ShardStartArgs: run -p "..\NadekoBot\NadekoBot.csproj" --no-build -- {0} {1}
+# How long does it take for the shard to be forcefully restarted once it stops reporting its state
 UnresponsiveSec: 30

src/NadekoBot.Generators/Cloneable/CloneableGenerator.cs

@@ -0,0 +1,254 @@
+// Code temporarily yeeted from
+// https://github.com/mostmand/Cloneable/blob/master/Cloneable/CloneableGenerator.cs
+// because of NRT issue
+#nullable enable
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Cloneable
+{
+    [Generator]
+    public class CloneableGenerator : ISourceGenerator
+    {
+        private const string PREVENT_DEEP_COPY_KEY_STRING = "PreventDeepCopy";
+        private const string EXPLICIT_DECLARATION_KEY_STRING = "ExplicitDeclaration";
+
+        private const string CLONEABLE_NAMESPACE = "Cloneable";
+        private const string CLONEABLE_ATTRIBUTE_STRING = "CloneableAttribute";
+        private const string CLONE_ATTRIBUTE_STRING = "CloneAttribute";
+        private const string IGNORE_CLONE_ATTRIBUTE_STRING = "IgnoreCloneAttribute";
+
+        private const string CLONEABLE_ATTRIBUTE_TEXT = @"// <AutoGenerated/>
+using System;
+
+namespace " + CLONEABLE_NAMESPACE + @"
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = true, AllowMultiple = false)]
+    public sealed class " + CLONEABLE_ATTRIBUTE_STRING + @" : Attribute
+    {
+        public " + CLONEABLE_ATTRIBUTE_STRING + @"()
+        {
+        }
+
+        public bool " + EXPLICIT_DECLARATION_KEY_STRING + @" { get; set; }
+    }
+}
+";
+
+        private const string CLONE_PROPERTY_ATTRIBUTE_TEXT = @"// <AutoGenerated/>
+using System;
+
+namespace " + CLONEABLE_NAMESPACE + @"
+{
+    [AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
+    public sealed class " + CLONE_ATTRIBUTE_STRING + @" : Attribute
+    {
+        public " + CLONE_ATTRIBUTE_STRING + @"()
+        {
+        }
+
+        public bool " + PREVENT_DEEP_COPY_KEY_STRING + @" { get; set; }
+    }
+}
+";
+
+        private const string IGNORE_CLONE_PROPERTY_ATTRIBUTE_TEXT = @"// <AutoGenerated/>
+using System;
+
+namespace " + CLONEABLE_NAMESPACE + @"
+{
+    [AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
+    public sealed class " + IGNORE_CLONE_ATTRIBUTE_STRING + @" : Attribute
+    {
+        public " + IGNORE_CLONE_ATTRIBUTE_STRING + @"()
+        {
+        }
+    }
+}
+";
+
+        private INamedTypeSymbol? _cloneableAttribute;
+        private INamedTypeSymbol? _ignoreCloneAttribute;
+        private INamedTypeSymbol? _cloneAttribute;
+
+        public void Initialize(GeneratorInitializationContext context)
+            => context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
+
+        public void Execute(GeneratorExecutionContext context)
+        {
+            InjectCloneableAttributes(context);
+            GenerateCloneMethods(context);
+        }
+
+        private void GenerateCloneMethods(GeneratorExecutionContext context)
+        {
+            if (context.SyntaxReceiver is not SyntaxReceiver receiver)
+                return;
+
+            Compilation compilation = GetCompilation(context);
+
+            InitAttributes(compilation);
+
+            var classSymbols = GetClassSymbols(compilation, receiver);
+            foreach (var classSymbol in classSymbols)
+            {
+                if (!classSymbol.TryGetAttribute(_cloneableAttribute!, out var attributes))
+                    continue;
+
+                var attribute = attributes.Single();
+                var isExplicit = (bool?)attribute.NamedArguments.FirstOrDefault(e => e.Key.Equals(EXPLICIT_DECLARATION_KEY_STRING)).Value.Value ?? false;
+                context.AddSource($"{classSymbol.Name}_cloneable.g.cs", SourceText.From(CreateCloneableCode(classSymbol, isExplicit), Encoding.UTF8));
+            }
+        }
+
+        private void InitAttributes(Compilation compilation)
+        {
+            _cloneableAttribute = compilation.GetTypeByMetadataName($"{CLONEABLE_NAMESPACE}.{CLONEABLE_ATTRIBUTE_STRING}")!;
+            _cloneAttribute = compilation.GetTypeByMetadataName($"{CLONEABLE_NAMESPACE}.{CLONE_ATTRIBUTE_STRING}")!;
+            _ignoreCloneAttribute = compilation.GetTypeByMetadataName($"{CLONEABLE_NAMESPACE}.{IGNORE_CLONE_ATTRIBUTE_STRING}")!;
+        }
+
+        private static Compilation GetCompilation(GeneratorExecutionContext context)
+        {
+            var options = context.Compilation.SyntaxTrees.First().Options as CSharpParseOptions;
+
+            var compilation = context.Compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(SourceText.From(CLONEABLE_ATTRIBUTE_TEXT, Encoding.UTF8), options)).
+                AddSyntaxTrees(CSharpSyntaxTree.ParseText(SourceText.From(CLONE_PROPERTY_ATTRIBUTE_TEXT, Encoding.UTF8), options)).
+                AddSyntaxTrees(CSharpSyntaxTree.ParseText(SourceText.From(IGNORE_CLONE_PROPERTY_ATTRIBUTE_TEXT, Encoding.UTF8), options));
+            return compilation;
+        }
+
+        private string CreateCloneableCode(INamedTypeSymbol classSymbol, bool isExplicit)
+        {
+            string namespaceName = classSymbol.ContainingNamespace.ToDisplayString();
+            var fieldAssignmentsCode = GenerateFieldAssignmentsCode(classSymbol, isExplicit).ToList();
+            var fieldAssignmentsCodeSafe = fieldAssignmentsCode.Select(x =>
+            {
+                if (x.isCloneable)
+                    return x.line + "Safe(referenceChain)";
+                return x.line;
+            });
+            var fieldAssignmentsCodeFast = fieldAssignmentsCode.Select(x =>
+            {
+                if (x.isCloneable)
+                    return x.line + "()";
+                return x.line;
+            });
+
+            return $@"using System.Collections.Generic;
+
+namespace {namespaceName}
+{{
+    {GetAccessModifier(classSymbol)} partial class {classSymbol.Name}
+    {{
+        /// <summary>
+        /// Creates a copy of {classSymbol.Name} with NO circular reference checking. This method should be used if performance matters.
+        /// 
+        /// <exception cref=""StackOverflowException"">Will occur on any object that has circular references in the hierarchy.</exception>
+        /// </summary>
+        public {classSymbol.Name} Clone()
+        {{
+            return new {classSymbol.Name}
+            {{
+{string.Join(",\n", fieldAssignmentsCodeFast)}
+            }};
+        }}
+
+        /// <summary>
+        /// Creates a copy of {classSymbol.Name} with circular reference checking. If a circular reference was detected, only a reference of the leaf object is passed instead of cloning it.
+        /// </summary>
+        /// <param name=""referenceChain"">Should only be provided if specific objects should not be cloned but passed by reference instead.</param>
+        public {classSymbol.Name} CloneSafe(Stack<object> referenceChain = null)
+        {{
+            if(referenceChain?.Contains(this) == true) 
+                return this;
+            referenceChain ??= new Stack<object>();
+            referenceChain.Push(this);
+            var result = new {classSymbol.Name}
+            {{
+{string.Join($",\n", fieldAssignmentsCodeSafe)}
+            }};
+            referenceChain.Pop();
+            return result;
+        }}
+    }}
+}}";
+        }
+
+        private IEnumerable<(string line, bool isCloneable)> GenerateFieldAssignmentsCode(INamedTypeSymbol classSymbol, bool isExplicit )
+        {
+            var fieldNames = GetCloneableProperties(classSymbol, isExplicit);
+
+            var fieldAssignments = fieldNames.Select(field => IsFieldCloneable(field, classSymbol))
+                .OrderBy(x => x.isCloneable)
+                .Select(x => (GenerateAssignmentCode(x.item.Name, x.isCloneable), x.isCloneable));
+            return fieldAssignments;
+        }
+
+        private string GenerateAssignmentCode(string name, bool isCloneable)
+        {
+            if (isCloneable)
+            {
+                return $@"                {name} = this.{name}?.Clone";
+            }
+
+            return $@"                {name} = this.{name}";
+        }
+
+        private (IPropertySymbol item, bool isCloneable) IsFieldCloneable(IPropertySymbol x, INamedTypeSymbol classSymbol)
+        {
+            if (SymbolEqualityComparer.Default.Equals(x.Type, classSymbol))
+            {
+                return (x, false);
+            }
+
+            if (!x.Type.TryGetAttribute(_cloneableAttribute!, out var attributes))
+            {
+                return (x, false);
+            }
+
+            var preventDeepCopy = (bool?)attributes.Single().NamedArguments.FirstOrDefault(e => e.Key.Equals(PREVENT_DEEP_COPY_KEY_STRING)).Value.Value ?? false;
+            return (item: x, !preventDeepCopy);
+        }
+
+        private string GetAccessModifier(INamedTypeSymbol classSymbol)
+            => classSymbol.DeclaredAccessibility.ToString().ToLowerInvariant();
+
+        private IEnumerable<IPropertySymbol> GetCloneableProperties(ITypeSymbol classSymbol, bool isExplicit)
+        {
+            var targetSymbolMembers = classSymbol.GetMembers().OfType<IPropertySymbol>()
+                .Where(x => x.SetMethod is not null &&
+                            x.CanBeReferencedByName);
+            if (isExplicit)
+            {
+                return targetSymbolMembers.Where(x => x.HasAttribute(_cloneAttribute!));
+            }
+            else
+            {
+                return targetSymbolMembers.Where(x => !x.HasAttribute(_ignoreCloneAttribute!));
+            }
+        }
+
+        private static IEnumerable<INamedTypeSymbol> GetClassSymbols(Compilation compilation, SyntaxReceiver receiver)
+            => receiver.CandidateClasses.Select(clazz => GetClassSymbol(compilation, clazz));
+
+        private static INamedTypeSymbol GetClassSymbol(Compilation compilation, ClassDeclarationSyntax clazz)
+        {
+            var model = compilation.GetSemanticModel(clazz.SyntaxTree);
+            var classSymbol = model.GetDeclaredSymbol(clazz)!;
+            return classSymbol;
+        }
+
+        private static void InjectCloneableAttributes(GeneratorExecutionContext context)
+        {
+            context.AddSource(CLONEABLE_ATTRIBUTE_STRING, SourceText.From(CLONEABLE_ATTRIBUTE_TEXT, Encoding.UTF8));
+            context.AddSource(CLONE_ATTRIBUTE_STRING, SourceText.From(CLONE_PROPERTY_ATTRIBUTE_TEXT, Encoding.UTF8));
+            context.AddSource(IGNORE_CLONE_ATTRIBUTE_STRING, SourceText.From(IGNORE_CLONE_PROPERTY_ATTRIBUTE_TEXT, Encoding.UTF8));
+        }
+    }
+}

src/NadekoBot.Generators/Cloneable/SymbolExtensions.cs

@@ -0,0 +1,24 @@
+// Code temporarily yeeted from
+// https://github.com/mostmand/Cloneable/blob/master/Cloneable/CloneableGenerator.cs
+// because of NRT issue
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+
+namespace Cloneable
+{
+    internal static class SymbolExtensions
+    {
+        public static bool TryGetAttribute(this ISymbol symbol, INamedTypeSymbol attributeType,
+            out IEnumerable<AttributeData> attributes)
+        {
+            attributes = symbol.GetAttributes()
+                .Where(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attributeType));
+            return attributes.Any();
+        }
+
+        public static bool HasAttribute(this ISymbol symbol, INamedTypeSymbol attributeType)
+            => symbol.GetAttributes()
+                .Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attributeType));
+    }
+}

src/NadekoBot.Generators/Cloneable/SyntaxReceiver.cs

@@ -0,0 +1,27 @@
+// Code temporarily yeeted from
+// https://github.com/mostmand/Cloneable/blob/master/Cloneable/CloneableGenerator.cs
+// because of NRT issue
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Cloneable
+{
+    internal class SyntaxReceiver : ISyntaxReceiver
+    {
+        public IList<ClassDeclarationSyntax> CandidateClasses { get; } = new List<ClassDeclarationSyntax>();
+
+        /// <summary>
+        /// Called for every syntax node in the compilation, we can inspect the nodes and save any information useful for generation
+        /// </summary>
+        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+        {
+            // any field with at least one attribute is a candidate for being cloneable
+            if (syntaxNode is ClassDeclarationSyntax classDeclarationSyntax &&
+                classDeclarationSyntax.AttributeLists.Count > 0)
+            {
+                CandidateClasses.Add(classDeclarationSyntax);
+            }
+        }
+    }
+}

src/NadekoBot.Generators/Command/CommandAttributesGenerator.cs

@@ -0,0 +1,323 @@
+#nullable enable
+using System;
+using System.CodeDom.Compiler;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace NadekoBot.Generators.Command;
+
+[Generator]
+public class CommandAttributesGenerator : IIncrementalGenerator
+{
+    public const string ATTRIBUTE = @"// <AutoGenerated />
+
+namespace NadekoBot.Common;
+
+[System.AttributeUsage(System.AttributeTargets.Method)]
+public class CmdAttribute : System.Attribute
+{
+    
+}";
+
+    public class MethodModel
+    {
+        public string? Namespace { get; }
+        public IReadOnlyCollection<string> Classes { get; }
+        public string ReturnType { get; }
+        public string MethodName { get; }
+        public IEnumerable<string> Params { get; }
+
+        public MethodModel(string? ns, IReadOnlyCollection<string> classes, string returnType, string methodName, IEnumerable<string> @params)
+        {
+            Namespace = ns;
+            Classes = classes;
+            ReturnType = returnType;
+            MethodName = methodName;
+            Params = @params;
+        }
+    }
+
+    public class FileModel
+    {
+        public string? Namespace { get; }
+        public IReadOnlyCollection<string> ClassHierarchy { get; }
+        public IReadOnlyCollection<MethodModel> Methods { get; }
+
+        public FileModel(string? ns, IReadOnlyCollection<string> classHierarchy, IReadOnlyCollection<MethodModel> methods)
+        {
+            Namespace = ns;
+            ClassHierarchy = classHierarchy;
+            Methods = methods;
+        }
+    }
+
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+// #if DEBUG
+//         SpinWait.SpinUntil(() => Debugger.IsAttached);
+// #endif
+        context.RegisterPostInitializationOutput(static ctx => ctx.AddSource(
+            "CmdAttribute.g.cs",
+            SourceText.From(ATTRIBUTE, Encoding.UTF8)));
+
+        var methods = context.SyntaxProvider
+            .CreateSyntaxProvider(
+                static (node, _) => node is MethodDeclarationSyntax { AttributeLists.Count: > 0 },
+                static (ctx, cancel) => Transform(ctx, cancel))
+            .Where(static m => m is not null)
+            .Where(static m => m?.ChildTokens().Any(static x => x.IsKind(SyntaxKind.PublicKeyword)) ?? false);
+
+        var compilationMethods = context.CompilationProvider.Combine(methods.Collect());
+
+        context.RegisterSourceOutput(compilationMethods,
+            static (ctx, tuple) => RegisterAction(in ctx, tuple.Left, in tuple.Right));
+    }
+
+    private static void RegisterAction(in SourceProductionContext ctx,
+        Compilation comp,
+        in ImmutableArray<MethodDeclarationSyntax?> methods)
+    {
+        if (methods is { IsDefaultOrEmpty: true })
+            return;
+
+        var models = GetModels(comp, methods, ctx.CancellationToken);
+
+        foreach (var model in models)
+        {
+            var name = $"{model.Namespace}.{string.Join(".", model.ClassHierarchy)}.g.cs";
+            try
+            {
+                Debug.WriteLine($"Writing {name}");
+                var source = GetSourceText(model);
+                ctx.AddSource(name, SourceText.From(source, Encoding.UTF8));
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"Error writing source file {name}\n" + ex);
+            }
+        }
+    }
+
+    private static string GetSourceText(FileModel model)
+    {
+        using var sw = new StringWriter();
+        using var tw = new IndentedTextWriter(sw);
+        
+        tw.WriteLine("// <AutoGenerated />");
+        tw.WriteLine("#pragma warning disable CS1066");
+
+        if (model.Namespace is not null)
+        {
+            tw.WriteLine($"namespace {model.Namespace};");
+            tw.WriteLine();
+        }
+
+        foreach (var className in model.ClassHierarchy)
+        {
+            tw.WriteLine($"public partial class {className}");
+            tw.WriteLine("{");
+            tw.Indent ++;
+        }
+        
+        foreach (var method in model.Methods)
+        {
+            tw.WriteLine("[NadekoCommand]");
+            tw.WriteLine("[NadekoDescription]");
+            tw.WriteLine("[Aliases]");
+            tw.WriteLine($"public partial {method.ReturnType} {method.MethodName}({string.Join(", ", method.Params)});");
+        }
+        
+        foreach (var _ in model.ClassHierarchy)
+        {
+            tw.Indent --;
+            tw.WriteLine("}");
+        }
+        
+        tw.Flush();
+        return sw.ToString();
+    }
+
+    private static IReadOnlyCollection<FileModel> GetModels(Compilation compilation,
+        in ImmutableArray<MethodDeclarationSyntax?> inputMethods,
+        CancellationToken cancel)
+    {
+        var models = new List<FileModel>();
+
+        var methods = inputMethods
+            .Where(static x => x is not null)
+            .Distinct();
+        
+        var methodModels = methods
+            .Select(x => MethodDeclarationToMethodModel(compilation, x!));
+
+        var groups = methodModels
+            .GroupBy(static x => $"{x.Namespace}.{string.Join(".", x.Classes)}");
+        
+        foreach (var group in groups)
+        {
+            if (cancel.IsCancellationRequested)
+                return new Collection<FileModel>();
+
+            if (group is null)
+                continue;
+            
+            var elems = group.ToList();
+            if (elems.Count is 0)
+                continue;
+
+            var model = new FileModel(
+                methods: elems,
+                ns: elems[0].Namespace,
+                classHierarchy: elems[0].Classes
+            );
+            
+            models.Add(model);
+        }
+
+
+        return models;
+    }
+
+    private static MethodModel MethodDeclarationToMethodModel(Compilation comp, MethodDeclarationSyntax decl)
+    {
+        // SpinWait.SpinUntil(static () => Debugger.IsAttached);
+
+        var semanticModel = comp.GetSemanticModel(decl.SyntaxTree);
+        var methodModel = new MethodModel(
+            @params: decl.ParameterList.Parameters
+                .Where(p => p.Type is not null)
+                .Select(p =>
+                {
+                    var prefix = p.Modifiers.Any(static x => x.IsKind(SyntaxKind.ParamsKeyword))
+                        ? "params "
+                        : string.Empty;
+
+                    var type = semanticModel
+                        .GetTypeInfo(p.Type!)
+                        .Type
+                        ?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+
+
+                    var name = p.Identifier.Text;
+
+                    var suffix = string.Empty;
+                    if (p.Default is not null)
+                    {
+                        if (p.Default.Value is LiteralExpressionSyntax)
+                        {
+                            suffix = " = " + p.Default.Value;
+                        }
+                        else if (p.Default.Value is MemberAccessExpressionSyntax maes)
+                        {
+                            var maesSemModel = comp.GetSemanticModel(maes.SyntaxTree);
+                            var sym = maesSemModel.GetSymbolInfo(maes.Name);
+                            if (sym.Symbol is null)
+                            {
+                                suffix = " = " + p.Default.Value;
+                            }
+                            else
+                            {
+                                suffix = " = " + sym.Symbol.ToDisplayString();
+                            }
+                        }
+                    }
+
+                    return $"{prefix}{type} {name}{suffix}";
+                })
+                .ToList(),
+            methodName: decl.Identifier.Text,
+            returnType: decl.ReturnType.ToString(),
+            ns: GetNamespace(decl),
+            classes: GetClasses(decl)
+        );
+
+        return methodModel;
+    }
+
+    //https://github.com/andrewlock/NetEscapades.EnumGenerators/blob/main/src/NetEscapades.EnumGenerators/EnumGenerator.cs
+    static string? GetNamespace(MethodDeclarationSyntax declarationSyntax)
+    {
+        // determine the namespace the class is declared in, if any
+        string? nameSpace = null;
+        var parentOfInterest = declarationSyntax.Parent;
+        while (parentOfInterest is not null)
+        {
+            parentOfInterest = parentOfInterest.Parent;
+            
+            if (parentOfInterest is BaseNamespaceDeclarationSyntax ns)
+            {
+                nameSpace = ns.Name.ToString();
+                while (true)
+                {
+                    if (ns.Parent is not NamespaceDeclarationSyntax parent)
+                    {
+                        break;
+                    }
+
+                    ns = parent;
+                    nameSpace = $"{ns.Name}.{nameSpace}";
+                }
+
+                return nameSpace;
+            }
+            
+        }
+        
+        return nameSpace;
+    }
+    
+    static IReadOnlyCollection<string> GetClasses(MethodDeclarationSyntax declarationSyntax)
+    {
+        // determine the namespace the class is declared in, if any
+        var classes = new LinkedList<string>();
+        var parentOfInterest = declarationSyntax.Parent;
+        while (parentOfInterest is not null)
+        {
+            if (parentOfInterest is ClassDeclarationSyntax cds)
+            {
+                classes.AddFirst(cds.Identifier.ToString());
+            }
+
+            parentOfInterest = parentOfInterest.Parent;
+        }
+
+        Debug.WriteLine($"Method {declarationSyntax.Identifier.Text} has {classes.Count} classes");
+        
+        return classes;
+    }
+
+    private static MethodDeclarationSyntax? Transform(GeneratorSyntaxContext ctx, CancellationToken cancel)
+    {
+        var methodDecl = ctx.Node as MethodDeclarationSyntax;
+        if (methodDecl is null)
+            return default;
+
+        foreach (var attListSyntax in methodDecl.AttributeLists)
+        {
+            foreach (var attSyntax in attListSyntax.Attributes)
+            {
+                if (cancel.IsCancellationRequested)
+                    return default;
+
+                var symbol = ctx.SemanticModel.GetSymbolInfo(attSyntax).Symbol;
+                if (symbol is not IMethodSymbol attSymbol)
+                    continue;
+
+                if (attSymbol.ContainingType.ToDisplayString() == "NadekoBot.Common.CmdAttribute")
+                    return methodDecl;
+            }
+        }
+
+        return default;
+    }
+}

src/NadekoBot.Generators/LocalizedStringsGenerator.cs

@@ -1,26 +1,32 @@
-using System;
+#nullable enable
+using System;
 using System.CodeDom.Compiler;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Text.RegularExpressions;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Text;
 using Newtonsoft.Json;
 
 namespace NadekoBot.Generators
 {
-    internal class TranslationPair
+    internal readonly struct TranslationPair
     {
-        public string Name { get; set; }
-        public string Value { get; set; }
+        public string Name { get; }
+        public string Value { get; }
+
+        public TranslationPair(string name, string value)
+        {
+            Name = name;
+            Value = value;
+        }
     }
 
     [Generator]
     public class LocalizedStringsGenerator : ISourceGenerator
     {
-        private const string LocStrSource = @"namespace NadekoBot
+        private const string LOC_STR_SOURCE = @"namespace NadekoBot
 {
     public readonly struct LocStr
     {
@@ -49,9 +55,8 @@ namespace NadekoBot.Generators
             using (var stringWriter = new StringWriter())
             using (var sw = new IndentedTextWriter(stringWriter))
             {
-                sw.WriteLine("namespace NadekoBot");
-                sw.WriteLine("{");
-                sw.Indent++;
+                sw.WriteLine("namespace NadekoBot;");
+                sw.WriteLine();
 
                 sw.WriteLine("public static class strs");
                 sw.WriteLine("{");
@@ -84,32 +89,42 @@ namespace NadekoBot.Generators
 
                 sw.Indent--;
                 sw.WriteLine("}");
-                sw.Indent--;
-                sw.WriteLine("}");
 
 
                 sw.Flush();
-                context.AddSource("strs.cs", stringWriter.ToString());
+                context.AddSource("strs.g.cs", stringWriter.ToString());
             }
 
-            context.AddSource("LocStr.cs", LocStrSource);
+            context.AddSource("LocStr.g.cs", LOC_STR_SOURCE);
         }
 
-        private List<TranslationPair> GetFields(string dataText)
+        private List<TranslationPair> GetFields(string? dataText)
         {
             if (string.IsNullOrWhiteSpace(dataText))
-                throw new ArgumentNullException(nameof(dataText));
+                return new();
 
-            var data = JsonConvert.DeserializeObject<Dictionary<string, string>>(dataText);
+            Dictionary<string, string> data;
+            try
+            {
+                var output = JsonConvert.DeserializeObject<Dictionary<string, string>>(dataText!);
+                if (output is null)
+                    return new();
+
+                data = output;
+            }
+            catch
+            {
+                Debug.WriteLine("Failed parsing responses file.");
+                return new();
+            }
 
             var list = new List<TranslationPair>();
             foreach (var entry in data)
             {
-                list.Add(new TranslationPair()
-                {
-                    Name = entry.Key,
-                    Value = entry.Value
-                });
+                list.Add(new(
+                    entry.Key,
+                    entry.Value
+                ));
             }
 
             return list;

src/NadekoBot.Generators/NadekoBot.Generators.csproj

@@ -1,13 +1,15 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFramework>netstandard2.0</TargetFramework>
+        <LangVersion>latest</LangVersion>
         <IncludeBuildOutput>false</IncludeBuildOutput>
+        <IsRoslynComponent>true</IsRoslynComponent>
     </PropertyGroup>
     
     <ItemGroup>
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
-        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" PrivateAssets="all" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />
+        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" PrivateAssets="all" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.1" PrivateAssets="all" GeneratePathProperty="true" />
     </ItemGroup>
     

src/NadekoBot.Tests/BotStringsTests.cs

@@ -2,12 +2,10 @@
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
-using AngleSharp.Common;
 using Discord.Commands;
 using NadekoBot.Common.Attributes;
 using NadekoBot.Services;
 using NadekoBot.Modules;
-using YamlDotNet.Serialization;
 
 namespace NadekoBot.Tests
 {
@@ -16,6 +14,7 @@ namespace NadekoBot.Tests
         private const string responsesPath = "../../../../NadekoBot/data/strings/responses";
         private const string commandsPath = "../../../../NadekoBot/data/strings/commands";
         private const string aliasesPath = "../../../../NadekoBot/data/aliases.yml";
+        
         [Test]
         public void AllCommandNamesHaveStrings()
         {
@@ -27,15 +26,13 @@ namespace NadekoBot.Tests
             var culture = new CultureInfo("en-US");
 
             var isSuccess = true;
-            foreach (var entry in CommandNameLoadHelper.LoadCommandNames(aliasesPath))
+            foreach (var (methodName, _) in CommandNameLoadHelper.LoadAliases(aliasesPath))
             {
-                var commandName = entry.Value[0];
-
-                var cmdStrings = strings.GetCommandStrings(culture.Name, commandName);
+                var cmdStrings = strings.GetCommandStrings(culture.Name, methodName);
                 if (cmdStrings is null)
                 {
                     isSuccess = false;
-                    TestContext.Out.WriteLine($"{commandName} doesn't exist in commands.en-US.yml");
+                    TestContext.Out.WriteLine($"{methodName} doesn't exist in commands.en-US.yml");
                 }
             }
 
@@ -43,7 +40,7 @@ namespace NadekoBot.Tests
         }
 
         private static string[] GetCommandMethodNames()
-            => typeof(NadekoBot.Bot).Assembly
+            => typeof(Bot).Assembly
                 .GetExportedTypes()
                 .Where(type => type.IsClass && !type.IsAbstract)
                 .Where(type => typeof(NadekoModule).IsAssignableFrom(type) // if its a top level module
@@ -57,7 +54,7 @@ namespace NadekoBot.Tests
         [Test]
         public void AllCommandMethodsHaveNames()
         {
-            var allAliases = CommandNameLoadHelper.LoadCommandNames(
+            var allAliases = CommandNameLoadHelper.LoadAliases(
                 aliasesPath);
 
             var methodNames = GetCommandMethodNames();
@@ -65,7 +62,7 @@ namespace NadekoBot.Tests
             var isSuccess = true;
             foreach (var methodName in methodNames)
             {
-                if (!allAliases.TryGetValue(methodName, out var _))
+                if (!allAliases.TryGetValue(methodName, out _))
                 {
                     TestContext.Error.WriteLine($"{methodName} is missing an alias.");
                     isSuccess = false;
@@ -78,7 +75,7 @@ namespace NadekoBot.Tests
         [Test]
         public void NoObsoleteAliases()
         {
-            var allAliases = CommandNameLoadHelper.LoadCommandNames(aliasesPath);
+            var allAliases = CommandNameLoadHelper.LoadAliases(aliasesPath);
 
             var methodNames = GetCommandMethodNames()
                 .ToHashSet();
@@ -96,7 +93,10 @@ namespace NadekoBot.Tests
                 }
             }
             
-            Assert.IsTrue(isSuccess);
+            if(isSuccess)
+                Assert.Pass();
+            else
+                Assert.Warn("There are some unused entries in data/aliases.yml");
         }
         
         // [Test]

src/NadekoBot.Tests/GroupGreetTests.cs

@@ -1,7 +1,6 @@
-using System.Collections;
-using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using NadekoBot.Extensions;
 using NadekoBot.Services;
 using NUnit.Framework;
 
@@ -13,9 +12,7 @@ namespace NadekoBot.Tests
 
         [SetUp]
         public void Setup()
-        {
-            _grouper = new GreetGrouper<int>();
-        }
+            => _grouper = new GreetGrouper<int>();
 
         [Test]
         public void CreateTest()
@@ -62,8 +59,8 @@ namespace NadekoBot.Tests
             _grouper.CreateOrAdd(0, 5);
             
             // add 15 items
-            await Task.WhenAll(Enumerable.Range(10, 15)
-                .Select(x => Task.Run(() => _grouper.CreateOrAdd(0, x))));
+            await Enumerable.Range(10, 15)
+                .Select(x => Task.Run(() => _grouper.CreateOrAdd(0, x))).WhenAll();
             
             // get 5 at most
             _grouper.ClearGroup(0, 5, out var items);

src/NadekoBot.Tests/IndexedCollectionTests.cs

@@ -62,7 +62,10 @@ namespace NadekoBot.Tests
             collection.Clear();
 
             Assert.IsTrue(collection.Count == 0, "Collection has not been cleared.");
-            Assert.Throws<ArgumentOutOfRangeException>(() => collection.Contains(collection[0]), "Collection has not been cleared.");
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                _ = collection[0];
+            }, "Collection has not been cleared.");
         }
 
         [Test]
@@ -115,7 +118,7 @@ namespace NadekoBot.Tests
         [Test]
         public void ContainsTest()
         {
-            var subCol = new ShopEntry[]
+            var subCol = new[]
             {
                 new ShopEntry() { Id = 111 },
                 new ShopEntry() { Id = 222 },

src/NadekoBot.Tests/KwumTests.cs

@@ -1,5 +1,4 @@
-using System.Linq;
-using NadekoBot.Common;
+using NadekoBot.Common;
 using NUnit.Framework;
 
 namespace NadekoBot.Tests

src/NadekoBot.Tests/NadekoBot.Tests.csproj

@@ -1,15 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net5.0</TargetFramework>
-        <LangVersion>9.0</LangVersion>
+        <TargetFramework>net6.0</TargetFramework>
+        <LangVersion>10.0</LangVersion>
+        <EnablePreviewFeatures>True</EnablePreviewFeatures>
         <IsPackable>false</IsPackable>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="NUnit" Version="3.13.2" />
-        <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     </ItemGroup>
 
     <ItemGroup>

src/NadekoBot.Tests/Random.cs

@@ -9,10 +9,8 @@ namespace NadekoBot.Tests
     {
         [SetUp]
         public void Setup()
-        {
-            Console.OutputEncoding = Encoding.UTF8;
-        }
-        
+            => Console.OutputEncoding = Encoding.UTF8;
+
         [Test]
         public void Utf8CodepointsToEmoji()
         {

src/NadekoBot.VotesApi/.dockerignore

@@ -0,0 +1,25 @@
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/.idea
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

src/NadekoBot.VotesApi/.gitignore

@@ -0,0 +1 @@
+store/

src/NadekoBot.VotesApi/Common/AuthHandler.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Security.Claims;
+using System.Text.Encodings.Web;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace NadekoBot.VotesApi
+{
+    public class AuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>
+    {
+        public const string SchemeName = "AUTHORIZATION_SCHEME";
+        public const string DiscordsClaim = "DISCORDS_CLAIM";
+        public const string TopggClaim = "TOPGG_CLAIM";
+
+        private readonly IConfiguration _conf;
+
+        public AuthHandler(IOptionsMonitor<AuthenticationSchemeOptions> options,
+            ILoggerFactory logger,
+            UrlEncoder encoder,
+            ISystemClock clock,
+            IConfiguration conf)
+            : base(options, logger, encoder, clock)
+            => _conf = conf;
+
+        protected override Task<AuthenticateResult> HandleAuthenticateAsync()
+        {
+            var claims = new List<Claim>();
+
+            if (_conf[ConfKeys.DISCORDS_KEY].Trim() == Request.Headers["Authorization"].ToString().Trim())
+                claims.Add(new(DiscordsClaim, "true"));
+
+            if (_conf[ConfKeys.TOPGG_KEY] == Request.Headers["Authorization"].ToString().Trim())
+                claims.Add(new Claim(TopggClaim, "true"));
+
+            return Task.FromResult(AuthenticateResult.Success(new(new(new ClaimsIdentity(claims)), SchemeName)));
+        }
+    }
+}

src/NadekoBot.VotesApi/Common/ConfKeys.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot.VotesApi
+{
+    public static class ConfKeys
+    {
+        public const string DISCORDS_KEY = "DiscordsKey";
+        public const string TOPGG_KEY = "TopGGKey";
+    }
+}

src/NadekoBot.VotesApi/Common/DiscordsVoteWebhookModel.cs

@@ -0,0 +1,26 @@
+namespace NadekoBot.VotesApi
+{
+    public class DiscordsVoteWebhookModel
+    {
+        /// <summary>
+        /// The ID of the user who voted
+        /// </summary>
+        public string User { get; set; }
+
+        /// <summary>
+        /// The ID of the bot which recieved the vote
+        /// </summary>
+        public string Bot { get; set; }
+
+        /// <summary>
+        /// Contains totalVotes, votesMonth, votes24, hasVoted - a list of IDs of users who have voted this month, and
+        /// Voted24 - a list of IDs of users who have voted today
+        /// </summary>
+        public string Votes { get; set; }
+
+        /// <summary>
+        /// The type of event, whether it is a vote event or test event
+        /// </summary>
+        public string Type { get; set; }
+    }
+}

src/NadekoBot.VotesApi/Common/Policies.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot.VotesApi
+{
+    public static class Policies
+    {
+        public const string DiscordsAuth = "DiscordsAuth";
+        public const string TopggAuth = "TopggAuth";
+    }
+}

src/NadekoBot.VotesApi/Common/TopggVoteWebhookModel.cs

@@ -0,0 +1,30 @@
+namespace NadekoBot.VotesApi
+{
+    public class TopggVoteWebhookModel
+    {
+        /// <summary>
+        /// Discord ID of the bot that received a vote.
+        /// </summary>
+        public string Bot { get; set; }
+        
+        /// <summary>
+        /// Discord ID of the user who voted.
+        /// </summary>
+        public string User { get; set; }
+        
+        /// <summary>
+        /// The type of the vote (should always be "upvote" except when using the test button it's "test").
+        /// </summary>
+        public string Type { get; set; }
+        
+        /// <summary>
+        /// Whether the weekend multiplier is in effect, meaning users votes count as two.
+        /// </summary>
+        public bool Weekend { get; set; }
+        
+        /// <summary>
+        /// Query string params found on the /bot/:ID/vote page. Example: ?a=1&amp;b=2.
+        /// </summary>
+        public string Query { get; set; }
+    }
+}

src/NadekoBot.VotesApi/Controllers/DiscordsController.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class DiscordsController : ControllerBase
+    {
+        private readonly ILogger<DiscordsController> _logger;
+        private readonly IVotesCache _cache;
+
+        public DiscordsController(ILogger<DiscordsController> logger, IVotesCache cache)
+        {
+            _logger = logger;
+            _cache = cache;
+        }
+
+        [HttpGet("new")]
+        [Authorize(Policy = Policies.DiscordsAuth)]
+        public async Task<IEnumerable<Vote>> New()
+        {
+            var votes = await _cache.GetNewDiscordsVotesAsync();
+            if(votes.Count > 0)
+                _logger.LogInformation("Sending {NewDiscordsVotes} new discords votes", votes.Count);
+            return votes;
+        }
+    }
+}

src/NadekoBot.VotesApi/Controllers/TopGgController.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class TopGgController : ControllerBase
+    {
+        private readonly ILogger<TopGgController> _logger;
+        private readonly IVotesCache _cache;
+
+        public TopGgController(ILogger<TopGgController> logger, IVotesCache cache)
+        {
+            _logger = logger;
+            _cache = cache;
+        }
+
+        [HttpGet("new")]
+        [Authorize(Policy = Policies.TopggAuth)]
+        public async Task<IEnumerable<Vote>> New()
+        {
+            var votes = await _cache.GetNewTopGgVotesAsync();
+            if(votes.Count > 0)
+                _logger.LogInformation("Sending {NewTopggVotes} new topgg votes", votes.Count);
+            
+            return votes;
+        }
+    }
+}

src/NadekoBot.VotesApi/Controllers/WebhookController.cs

@@ -0,0 +1,48 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi.Controllers
+{
+    [ApiController]
+    public class WebhookController : ControllerBase
+    {
+        private readonly ILogger<WebhookController> _logger;
+        private readonly IVotesCache _votesCache;
+
+        public WebhookController(ILogger<WebhookController> logger, IVotesCache votesCache)
+        {
+            _logger = logger;
+            _votesCache = votesCache;
+        }
+        
+        [HttpPost("/discordswebhook")]
+        [Authorize(Policy = Policies.DiscordsAuth)]
+        public async Task<IActionResult> DiscordsWebhook([FromBody]DiscordsVoteWebhookModel data)
+        {
+
+            _logger.LogInformation("User {UserId} has voted for Bot {BotId} on {Platform}",
+                data.User,
+                data.Bot,
+                "discords.com");
+
+            await _votesCache.AddNewDiscordsVote(data.User);
+            return Ok();
+        }
+
+        [HttpPost("/topggwebhook")]
+        [Authorize(Policy = Policies.TopggAuth)]
+        public async Task<IActionResult> TopggWebhook([FromBody] TopggVoteWebhookModel data)
+        {
+            _logger.LogInformation("User {UserId} has voted for Bot {BotId} on {Platform}",
+                data.User,
+                data.Bot,
+                "top.gg");
+
+            await _votesCache.AddNewTopggVote(data.User);
+            return Ok();
+        }
+    }
+}

src/NadekoBot.VotesApi/Dockerfile

@@ -0,0 +1,20 @@
+FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
+WORKDIR /src
+COPY ["src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj", "NadekoBot.VotesApi/"]
+RUN dotnet restore "src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj"
+COPY . .
+WORKDIR "/src/NadekoBot.VotesApi"
+RUN dotnet build "NadekoBot.VotesApi.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "NadekoBot.VotesApi.csproj" -c Release -o /app/publish
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "NadekoBot.VotesApi.dll"]

src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <TargetFramework>net6.0</TargetFramework>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="MorseCode.ITask" Version="2.0.3" />
+        <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
+    </ItemGroup>
+
+</Project>

src/NadekoBot.VotesApi/Program.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+using NadekoBot.VotesApi;
+
+CreateHostBuilder(args).Build().Run();
+
+static IHostBuilder CreateHostBuilder(string[] args) =>
+    Host.CreateDefaultBuilder(args)
+        .ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup<Startup>(); });

src/NadekoBot.VotesApi/Properties/launchSettings.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:16451",
+      "sslPort": 44323
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "NadekoBot.VotesApi": {
+      "commandName": "Project",
+      "dotnetRunMessages": "true",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:5001;http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

src/NadekoBot.VotesApi/README.md

@@ -0,0 +1,46 @@
+## Votes Api
+
+This api is used if you want your bot to be able to reward users who vote for it on discords.com or top.gg   
+
+#### [GET] `/discords/new`
+    Get the discords votes received after previous call to this endpoint.
+    Input full url of this endpoint in your creds.yml file under Discords url field.
+    For example "https://api.my.cool.bot/discords/new"
+#### [GET] `/topgg/new`
+    Get the topgg votes received after previous call to this endpoint.
+    Input full url of this endpoint in your creds.yml file under Topgg url field.
+    For example "https://api.my.cool.bot/topgg/new"
+
+#### [POST] `/discordswebhook`
+    Input this endpoint as the webhook on discords.com bot edit page
+    model: https://docs.botsfordiscord.com/methods/receiving-votes
+    For example "https://api.my.cool.bot/topggwebhook"
+#### [POST] `/topggwebhook`
+    Input this endpoint as the webhook https://top.gg/bot/:your-bot-id/webhooks (replace :your-bot-id with your bot's id)
+    model: https://docs.top.gg/resources/webhooks/#schema
+    For example "https://api.my.cool.bot/discordswebhook"
+
+Input your super-secret header value in appsettings.json's DiscordsKey and TopGGKey fields
+They must match your DiscordsKey and TopGG key respectively, as well as your secrets in the discords.com and top.gg webhook setup pages
+
+Full Example:
+
+⚠ Change TopggKey and DiscordsKey to a secure long string  
+⚠ You can use https://www.random.org/strings/?num=1&len=20&digits=on&upperalpha=on&loweralpha=on&unique=on&format=html&rnd=new to generate it
+
+`creds.yml`
+```yml
+votes:
+    TopggServiceUrl: "https://api.my.cool.bot/topgg"
+    TopggKey: "my_topgg_key"
+    DiscordsServiceUrl: "https://api.my.cool.bot/discords"
+    DiscordsKey: "my_discords_key"
+```
+
+`appsettings.json`
+```json
+...
+  "DiscordsKey": "my_discords_key",
+  "TopGGKey": "my_topgg_key",
+...
+```

src/NadekoBot.VotesApi/Services/FileVotesCache.cs

@@ -0,0 +1,100 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using MorseCode.ITask;
+
+namespace NadekoBot.VotesApi.Services
+{
+    public class FileVotesCache : IVotesCache
+    {
+        // private const string STATS_FILE = "store/stats.json";
+        private const string TOPGG_FILE = "store/topgg.json";
+        private const string DISCORDS_FILE = "store/discords.json";
+
+        private readonly SemaphoreSlim _locker = new SemaphoreSlim(1, 1);
+
+        public FileVotesCache()
+        {
+            if (!Directory.Exists("store"))
+                Directory.CreateDirectory("store");
+            
+            if(!File.Exists(TOPGG_FILE))
+                File.WriteAllText(TOPGG_FILE, "[]");
+            
+            if(!File.Exists(DISCORDS_FILE))
+                File.WriteAllText(DISCORDS_FILE, "[]");
+        }
+
+        public ITask AddNewTopggVote(string userId)
+            => AddNewVote(TOPGG_FILE, userId);
+
+        public ITask AddNewDiscordsVote(string userId)
+            => AddNewVote(DISCORDS_FILE, userId);
+
+        private async ITask AddNewVote(string file, string userId)
+        {
+            await _locker.WaitAsync();
+            try
+            {
+                var votes = await GetVotesAsync(file);
+                votes.Add(userId);
+                await File.WriteAllTextAsync(file , JsonSerializer.Serialize(votes));
+            }
+            finally
+            {
+                _locker.Release();
+            }
+        }
+
+        public async ITask<IList<Vote>> GetNewTopGgVotesAsync()
+        {
+            var votes = await EvictTopggVotes();
+            return votes;
+        }
+
+        public async ITask<IList<Vote>> GetNewDiscordsVotesAsync()
+        {
+            var votes = await EvictDiscordsVotes();
+            return votes;
+        }
+
+        private ITask<List<Vote>> EvictTopggVotes()
+            => EvictVotes(TOPGG_FILE);
+
+        private ITask<List<Vote>> EvictDiscordsVotes()
+            => EvictVotes(DISCORDS_FILE);
+
+        private async ITask<List<Vote>> EvictVotes(string file)
+        {
+            await _locker.WaitAsync();
+            try
+            {
+
+                var ids = await GetVotesAsync(file);
+                await File.WriteAllTextAsync(file, "[]");
+                
+                return ids?
+                    .Select(x => (Ok: ulong.TryParse(x, out var r), Id: r))
+                    .Where(x => x.Ok)
+                    .Select(x => new Vote
+                    {
+                        UserId = x.Id
+                    })
+                    .ToList();
+            }
+            finally
+            {
+                _locker.Release();
+            }
+        }
+
+        private async ITask<IList<string>> GetVotesAsync(string file)
+        {
+            await using var fs = File.Open(file, FileMode.Open);
+            var votes = await JsonSerializer.DeserializeAsync<List<string>>(fs);
+            return votes;
+        }
+    }
+}

src/NadekoBot.VotesApi/Services/IVotesCache.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using MorseCode.ITask;
+
+namespace NadekoBot.VotesApi.Services
+{
+    public interface IVotesCache
+    {
+        ITask<IList<Vote>> GetNewTopGgVotesAsync();
+        ITask<IList<Vote>> GetNewDiscordsVotesAsync();
+        ITask AddNewTopggVote(string userId);
+        ITask AddNewDiscordsVote(string userId);
+    }
+}

src/NadekoBot.VotesApi/Startup.cs

@@ -0,0 +1,68 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.OpenApi.Models;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi
+{
+    public class Startup
+    {
+        public IConfiguration Configuration { get; }
+        
+        public Startup(IConfiguration configuration)
+            => Configuration = configuration;
+
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddControllers();
+            services.AddSingleton<IVotesCache, FileVotesCache>();
+            services.AddSwaggerGen(static c =>
+            {
+                c.SwaggerDoc("v1", new OpenApiInfo { Title = "NadekoBot.VotesApi", Version = "v1" });
+            });
+
+            services
+                .AddAuthentication(opts =>
+                {
+                    opts.DefaultScheme = AuthHandler.SchemeName;
+                    opts.AddScheme<AuthHandler>(AuthHandler.SchemeName, AuthHandler.SchemeName);
+                });
+            
+            services
+                .AddAuthorization(static opts =>
+                {
+                    opts.DefaultPolicy = new AuthorizationPolicyBuilder(AuthHandler.SchemeName)
+                        .RequireAssertion(static _ => false)
+                        .Build();
+                    opts.AddPolicy(Policies.DiscordsAuth, static policy => policy.RequireClaim(AuthHandler.DiscordsClaim));
+                    opts.AddPolicy(Policies.TopggAuth, static policy => policy.RequireClaim(AuthHandler.TopggClaim));
+                });
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+                app.UseSwagger();
+                app.UseSwaggerUI(static c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "NadekoBot.VotesApi v1"));
+            }
+
+            app.UseHttpsRedirection();
+
+            app.UseRouting();
+
+            app.UseAuthentication();
+            app.UseAuthorization();
+
+            app.UseEndpoints(static endpoints => { endpoints.MapControllers(); });
+        }
+    }
+}

src/NadekoBot.VotesApi/WeatherForecast.cs

@@ -0,0 +1,7 @@
+namespace NadekoBot.VotesApi
+{
+    public class Vote
+    {
+        public ulong UserId { get; set; }
+    }
+}

src/NadekoBot.VotesApi/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}

src/NadekoBot.VotesApi/appsettings.json

@@ -0,0 +1,12 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "DiscordsKey": "my_discords_key",
+  "TopGGKey": "my_topgg_key",
+  "AllowedHosts": "*"
+}

src/NadekoBot/.editorconfig

@@ -0,0 +1,359 @@
+root = true
+# Remove the line below if you want to inherit .editorconfig settings from higher directories
+
+[obj/**]
+generated_code = true
+
+# C# files
+[*.cs]
+
+
+#### Core EditorConfig Options ####
+
+# Indentation and spacing
+indent_size = 4
+indent_style = space
+tab_width = 4
+
+# New line preferences
+end_of_line = crlf
+insert_final_newline = false
+
+#### .NET Coding Conventions ####
+
+# Organize usings
+dotnet_separate_import_directive_groups = false
+dotnet_sort_system_directives_first = false
+
+# this. and Me. preferences
+dotnet_style_qualification_for_event = false
+dotnet_style_qualification_for_field = false
+dotnet_style_qualification_for_method = false
+dotnet_style_qualification_for_property = false
+
+# Language keywords vs BCL types preferences
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+
+# Parentheses preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning
+
+# Modifier preferences
+dotnet_style_require_accessibility_modifiers = always:error
+
+# Expression-level preferences
+dotnet_style_coalesce_expression = true
+dotnet_style_collection_initializer = true
+dotnet_style_explicit_tuple_names = true
+dotnet_style_namespace_match_folder = true
+dotnet_style_null_propagation = true
+dotnet_style_object_initializer = true
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+dotnet_style_prefer_auto_properties = true:warning
+dotnet_style_prefer_compound_assignment = true
+dotnet_style_prefer_conditional_expression_over_assignment = false:suggestion
+dotnet_style_prefer_conditional_expression_over_return = false:suggestion
+dotnet_style_prefer_inferred_anonymous_type_member_names = true
+dotnet_style_prefer_inferred_tuple_names = true
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:error
+dotnet_style_prefer_simplified_boolean_expressions = true
+dotnet_style_prefer_simplified_interpolation = true
+
+# Field preferences
+dotnet_style_readonly_field = true:suggestion
+
+# Parameter preferences
+dotnet_code_quality_unused_parameters = all:warning
+
+#### C# Coding Conventions ####
+
+# var preferences
+csharp_style_var_elsewhere = true
+csharp_style_var_for_built_in_types = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+
+# Expression-bodied members
+csharp_style_expression_bodied_accessors = true:suggestion
+csharp_style_expression_bodied_constructors = when_on_single_line:suggestion
+csharp_style_expression_bodied_indexers = true:suggestion
+csharp_style_expression_bodied_lambdas = true:suggestion
+csharp_style_expression_bodied_local_functions = true:suggestion
+csharp_style_expression_bodied_methods = when_on_single_line:suggestion
+csharp_style_expression_bodied_operators = when_on_single_line:suggestion
+csharp_style_expression_bodied_properties = true:suggestion
+
+# Pattern matching preferences
+csharp_style_pattern_matching_over_as_with_null_check = true:error
+csharp_style_pattern_matching_over_is_with_cast_check = true:error
+csharp_style_prefer_not_pattern = true:error
+csharp_style_prefer_pattern_matching = true:suggestion
+csharp_style_prefer_switch_expression = true
+
+# Null-checking preferences
+csharp_style_conditional_delegate_call = true:error
+
+# Modifier preferences
+csharp_prefer_static_local_function = true
+csharp_preferred_modifier_order = public, private, protected, internal, static, extern, new, virtual, abstract, sealed, override, readonly, unsafe, volatile, async
+
+# Code-block preferences
+csharp_prefer_braces = when_multiline:warning
+csharp_prefer_simple_using_statement = true
+
+# Expression-level preferences
+csharp_prefer_simple_default_expression = true
+csharp_style_deconstructed_variable_declaration = true
+csharp_style_implicit_object_creation_when_type_is_apparent = true:error
+csharp_style_inlined_variable_declaration = true:warning
+csharp_style_pattern_local_over_anonymous_function = true
+csharp_style_prefer_index_operator = true
+csharp_style_prefer_range_operator = true
+csharp_style_throw_expression = true:error
+csharp_style_unused_value_assignment_preference = discard_variable:warning
+csharp_style_unused_value_expression_statement_preference = discard_variable
+
+# 'using' directive preferences
+csharp_using_directive_placement = outside_namespace:error
+
+# Enforce file-scoped namespaces
+csharp_style_namespace_declarations = file_scoped:error
+
+# New line preferences
+csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true
+csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false
+csharp_style_allow_embedded_statements_on_same_line_experimental = false
+
+#### C# Formatting Rules ####
+
+# New line preferences
+csharp_new_line_before_catch = true
+csharp_new_line_before_else = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_open_brace = all
+csharp_new_line_between_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_case_contents_when_block = true
+csharp_indent_labels = one_less_than_current
+csharp_indent_switch_labels = true
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+
+# Wrapping preferences
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = false
+
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.private_readonly_field.symbols = private_readonly_field
+dotnet_naming_rule.private_readonly_field.style = begins_with_underscore
+dotnet_naming_rule.private_readonly_field.severity = warning
+
+dotnet_naming_rule.private_field.symbols = private_field
+dotnet_naming_rule.private_field.style = camel_case
+dotnet_naming_rule.private_field.severity = warning
+
+dotnet_naming_rule.const_fields.symbols = const_fields
+dotnet_naming_rule.const_fields.style = all_upper
+dotnet_naming_rule.const_fields.severity = warning
+
+# dotnet_naming_rule.class_should_be_pascal_case.severity = error
+# dotnet_naming_rule.class_should_be_pascal_case.symbols = class
+# dotnet_naming_rule.class_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.struct_should_be_pascal_case.severity = error
+dotnet_naming_rule.struct_should_be_pascal_case.symbols = struct
+dotnet_naming_rule.struct_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = error
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+# dotnet_naming_rule.types_should_be_pascal_case.severity = error
+# dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+# dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+# dotnet_naming_rule.enum_should_be_pascal_case.severity = error
+# dotnet_naming_rule.enum_should_be_pascal_case.symbols = enum
+# dotnet_naming_rule.enum_should_be_pascal_case.style = pascal_case
+
+# dotnet_naming_rule.property_should_be_pascal_case.severity = error
+# dotnet_naming_rule.property_should_be_pascal_case.symbols = property
+# dotnet_naming_rule.property_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.method_should_be_pascal_case.severity = error
+dotnet_naming_rule.method_should_be_pascal_case.symbols = method
+dotnet_naming_rule.method_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.async_method_should_be_ends_with_async.severity = error
+dotnet_naming_rule.async_method_should_be_ends_with_async.symbols = async_method
+dotnet_naming_rule.async_method_should_be_ends_with_async.style = ends_with_async
+
+# dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = error
+# dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+# dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.local_variable_should_be_camel_case.severity = error
+dotnet_naming_rule.local_variable_should_be_camel_case.symbols = local_variable
+dotnet_naming_rule.local_variable_should_be_camel_case.style = camel_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.const_fields.required_modifiers = const
+dotnet_naming_symbols.const_fields.applicable_kinds = field
+
+dotnet_naming_symbols.class.applicable_kinds = class
+dotnet_naming_symbols.class.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.class.required_modifiers =
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers =
+
+dotnet_naming_symbols.struct.applicable_kinds = struct
+dotnet_naming_symbols.struct.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.struct.required_modifiers =
+
+dotnet_naming_symbols.enum.applicable_kinds = enum
+dotnet_naming_symbols.enum.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.enum.required_modifiers =
+
+dotnet_naming_symbols.method.applicable_kinds = method
+dotnet_naming_symbols.method.applicable_accessibilities = public
+dotnet_naming_symbols.method.required_modifiers =
+
+dotnet_naming_symbols.property.applicable_kinds = property
+dotnet_naming_symbols.property.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.property.required_modifiers =
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers =
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers =
+
+dotnet_naming_symbols.private_readonly_field.applicable_kinds = field
+dotnet_naming_symbols.private_readonly_field.applicable_accessibilities = private, protected
+dotnet_naming_symbols.private_readonly_field.required_modifiers = readonly
+
+dotnet_naming_symbols.private_field.applicable_kinds = field
+dotnet_naming_symbols.private_field.applicable_accessibilities = private, protected
+dotnet_naming_symbols.private_field.required_modifiers =
+
+dotnet_naming_symbols.async_method.applicable_kinds = method, local_function
+dotnet_naming_symbols.async_method.applicable_accessibilities = *
+dotnet_naming_symbols.async_method.required_modifiers = async
+
+dotnet_naming_symbols.local_variable.applicable_kinds = parameter, local
+dotnet_naming_symbols.local_variable.applicable_accessibilities = local
+dotnet_naming_symbols.local_variable.required_modifiers =
+
+# Naming styles
+
+
+dotnet_naming_style.all_upper.capitalization = all_upper
+
+dotnet_naming_style.pascal_case.required_prefix =
+dotnet_naming_style.pascal_case.required_suffix =
+dotnet_naming_style.pascal_case.word_separator =
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix =
+dotnet_naming_style.begins_with_i.word_separator =
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.begins_with_underscore.required_prefix = _
+dotnet_naming_style.begins_with_underscore.required_suffix =
+dotnet_naming_style.begins_with_underscore.word_separator =
+dotnet_naming_style.begins_with_underscore.capitalization = camel_case
+
+dotnet_naming_style.ends_with_async.required_prefix =
+# dotnet_naming_style.ends_with_async.required_suffix = Async
+dotnet_naming_style.ends_with_async.word_separator =
+dotnet_naming_style.ends_with_async.capitalization = pascal_case
+
+dotnet_naming_style.camel_case.required_prefix =
+dotnet_naming_style.camel_case.required_suffix =
+dotnet_naming_style.camel_case.word_separator =
+dotnet_naming_style.camel_case.capitalization = camel_case
+
+# CA1822: Mark members as static
+dotnet_diagnostic.ca1822.severity = suggestion
+
+# IDE0004: Cast is redundant
+dotnet_diagnostic.ide0004.severity = warning
+
+# IDE0058: Expression value is never used
+dotnet_diagnostic.ide0058.severity = none
+
+# # IDE0011: Add braces to 'if'/'else' statement
+# dotnet_diagnostic.ide0011.severity = none
+
+resharper_wrap_after_invocation_lpar = false
+resharper_wrap_before_invocation_rpar = false
+
+# ReSharper properties
+resharper_align_multiline_calls_chain = true
+resharper_csharp_wrap_after_declaration_lpar = true
+resharper_csharp_wrap_after_invocation_lpar = false
+resharper_csharp_wrap_before_binary_opsign = true
+resharper_csharp_wrap_before_invocation_rpar = false
+resharper_csharp_wrap_parameters_style = chop_if_long
+resharper_force_chop_compound_if_expression = false
+resharper_keep_existing_linebreaks = true
+resharper_keep_user_linebreaks = true
+resharper_max_formal_parameters_on_line = 3
+resharper_place_simple_embedded_statement_on_same_line = false
+resharper_wrap_chained_binary_expressions = chop_if_long
+resharper_wrap_chained_binary_patterns = chop_if_long
+resharper_wrap_chained_method_calls = chop_if_long
+resharper_wrap_object_and_collection_initializer_style = chop_always
+
+resharper_csharp_wrap_before_first_type_parameter_constraint = true
+resharper_csharp_place_type_constraints_on_same_line = false
+resharper_csharp_wrap_before_extends_colon = true
+resharper_csharp_place_constructor_initializer_on_same_line = false
+resharper_force_attribute_style = separate
+resharper_csharp_braces_for_ifelse = required_for_multiline_statement
+resharper_csharp_braces_for_foreach = required_for_multiline
+resharper_csharp_braces_for_while = required_for_multiline
+resharper_csharp_braces_for_for = required_for_multiline
+resharper_arrange_redundant_parentheses_highlighting = hint
+
+# IDE0011: Add braces
+dotnet_diagnostic.IDE0011.severity = warning

src/NadekoBot/Bot.cs

@@ -1,356 +1,383 @@
-using Discord;
-using Discord.Commands;
-using Discord.WebSocket;
+#nullable disable
 using Microsoft.Extensions.DependencyInjection;
-using NadekoBot.Common;
-using NadekoBot.Services;
+using NadekoBot.Common.Configs;
+using NadekoBot.Common.ModuleBehaviors;
+using NadekoBot.Db;
+using NadekoBot.Modules.Administration;
 using NadekoBot.Services.Database.Models;
-using NadekoBot.Extensions;
-using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Linq;
-using System.Net.Http;
 using System.Reflection;
-using System.Threading.Tasks;
-using Discord.Net;
-using NadekoBot.Common.ModuleBehaviors;
-using NadekoBot.Common.Configs;
-using NadekoBot.Db;
-using NadekoBot.Modules.Administration.Services;
-using Serilog;
+using RunMode = Discord.Commands.RunMode;
 
-namespace NadekoBot
+namespace NadekoBot;
+
+public sealed class Bot
 {
-    public sealed class Bot
+    public event Func<GuildConfig, Task> JoinedGuild = delegate { return Task.CompletedTask; };
+
+    public DiscordSocketClient Client { get; }
+    public ImmutableArray<GuildConfig> AllGuildConfigs { get; private set; }
+
+    private IServiceProvider Services { get; set; }
+
+    public string Mention { get; private set; }
+    public bool IsReady { get; private set; }
+    public int ShardId { get; set; }
+
+    private readonly IBotCredentials _creds;
+    private readonly CommandService _commandService;
+    private readonly DbService _db;
+
+    private readonly IBotCredsProvider _credsProvider;
+    // private readonly InteractionService _interactionService;
+
+    public Bot(int shardId, int? totalShards)
     {
-        private readonly IBotCredentials _creds;
-        private readonly CommandService _commandService;
-        private readonly DbService _db;
-        private readonly BotCredsProvider _credsProvider;
-        
-        public event Func<GuildConfig, Task> JoinedGuild = delegate { return Task.CompletedTask; };
-        
-        public DiscordSocketClient Client { get; }
-        public ImmutableArray<GuildConfig> AllGuildConfigs { get; private set; }
+        if (shardId < 0)
+            throw new ArgumentOutOfRangeException(nameof(shardId));
 
-        private IServiceProvider Services { get; set; }
-        
-        public string Mention { get; private set; }
-        public bool IsReady { get; private set; }
+        ShardId = shardId;
+        _credsProvider = new BotCredsProvider(totalShards);
+        _creds = _credsProvider.GetCreds();
 
-        public Bot(int shardId, int? totalShards)
-        {
-            if (shardId < 0)
-                throw new ArgumentOutOfRangeException(nameof(shardId));
+        _db = new(_creds);
 
-            _credsProvider = new BotCredsProvider(totalShards);
-            _creds = _credsProvider.GetCreds();
-            
-            _db = new DbService(_creds);
+        if (shardId == 0)
+            _db.Setup();
 
-            if (shardId == 0)
-            {
-                _db.Setup();
-            }
-
-            Client = new DiscordSocketClient(new DiscordSocketConfig
-            {
-                MessageCacheSize = 50,
-                LogLevel = LogSeverity.Warning,
-                ConnectionTimeout = int.MaxValue,
-                TotalShards = _creds.TotalShards,
-                ShardId = shardId,
-                AlwaysDownloadUsers = false,
-                ExclusiveBulkDelete = true,
-            });
-
-            _commandService = new CommandService(new CommandServiceConfig()
-            {
-                CaseSensitiveCommands = false,
-                DefaultRunMode = RunMode.Sync,
-            });
-
-#if GLOBAL_NADEKO || DEBUG
-            Client.Log += Client_Log;
-#endif
-        }
-
-        public List<ulong> GetCurrentGuildIds()
-        {
-            return Client.Guilds.Select(x => x.Id).ToList();
-        }
-
-        private void AddServices()
-        {
-            var startingGuildIdList = GetCurrentGuildIds();
-            var sw = Stopwatch.StartNew();
-            var _bot = Client.CurrentUser;
-
-            using (var uow = _db.GetDbContext())
-            {
-                uow.EnsureUserCreated(_bot.Id, _bot.Username, _bot.Discriminator, _bot.AvatarId);
-                AllGuildConfigs = uow.GuildConfigs.GetAllGuildConfigs(startingGuildIdList).ToImmutableArray();
-            }
-            
-            var svcs = new ServiceCollection()
-                .AddTransient<IBotCredentials>(_ => _creds) // bot creds
-                .AddSingleton(_credsProvider)
-                .AddSingleton(_db) // database
-                .AddRedis(_creds.RedisOptions) // redis
-                .AddSingleton(Client) // discord socket client
-                .AddSingleton(_commandService)
-                .AddSingleton(this)
-                .AddSingleton<IDataCache, RedisCache>()
-                .AddSingleton<ISeria, JsonSeria>()
-                .AddSingleton<IPubSub, RedisPubSub>()
-                .AddSingleton<IConfigSeria, YamlSeria>()
-                .AddBotStringsServices()
-                .AddConfigServices()
-                .AddConfigMigrators()
-                .AddMemoryCache()
-                // music
-                .AddMusic()
-                // admin
+        var messageCacheSize =
 #if GLOBAL_NADEKO
-                .AddSingleton<ILogCommandService, DummyLogCommandService>()
+            0;
 #else
-                .AddSingleton<ILogCommandService, LogCommandService>()
+            50;
 #endif
-                ;
 
-            svcs.AddHttpClient();
-            svcs.AddHttpClient("memelist").ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
+        if(!_creds.UsePrivilegedIntents)
+            Log.Warning("You are not using privileged intents. Some features will not work properly");
+        
+        Client = new(new()
+        {
+            MessageCacheSize = messageCacheSize,
+            LogLevel = LogSeverity.Warning,
+            ConnectionTimeout = int.MaxValue,
+            TotalShards = _creds.TotalShards,
+            ShardId = shardId,
+            AlwaysDownloadUsers = false,
+            AlwaysResolveStickers = false,
+            AlwaysDownloadDefaultStickers = false,
+            GatewayIntents = _creds.UsePrivilegedIntents
+                ? GatewayIntents.All
+                : GatewayIntents.AllUnprivileged,
+            LogGatewayIntentWarnings = false,
+        });
+
+        _commandService = new(new()
+        {
+            CaseSensitiveCommands = false,
+            DefaultRunMode = RunMode.Sync
+        });
+
+        // _interactionService = new(Client.Rest);
+
+        Client.Log += Client_Log;
+    }
+
+
+    public List<ulong> GetCurrentGuildIds()
+        => Client.Guilds.Select(x => x.Id).ToList();
+
+    private void AddServices()
+    {
+        var startingGuildIdList = GetCurrentGuildIds();
+        var sw = Stopwatch.StartNew();
+        var bot = Client.CurrentUser;
+
+        using (var uow = _db.GetDbContext())
+        {
+            uow.EnsureUserCreated(bot.Id, bot.Username, bot.Discriminator, bot.AvatarId);
+            AllGuildConfigs = uow.GuildConfigs.GetAllGuildConfigs(startingGuildIdList).ToImmutableArray();
+        }
+
+        var svcs = new ServiceCollection().AddTransient(_ => _credsProvider.GetCreds()) // bot creds
+                                          .AddSingleton(_credsProvider)
+                                          .AddSingleton(_db) // database
+                                          .AddRedis(_creds.RedisOptions) // redis
+                                          .AddSingleton(Client) // discord socket client
+                                          .AddSingleton(_commandService)
+                                          // .AddSingleton(_interactionService)
+                                          .AddSingleton(this)
+                                          .AddSingleton<ISeria, JsonSeria>()
+                                          .AddSingleton<IPubSub, RedisPubSub>()
+                                          .AddSingleton<IConfigSeria, YamlSeria>()
+                                          .AddBotStringsServices(_creds.TotalShards)
+                                          .AddConfigServices()
+                                          .AddConfigMigrators()
+                                          .AddMemoryCache()
+                                          // music
+                                          .AddMusic();
+        // admin
+#if GLOBAL_NADEKO
+        svcs.AddSingleton<ILogCommandService, DummyLogCommandService>();
+#else
+        svcs.AddSingleton<ILogCommandService, LogCommandService>();
+#endif
+
+        svcs.AddHttpClient();
+        svcs.AddHttpClient("memelist")
+            .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
             {
                 AllowAutoRedirect = false
             });
 
-            if (Environment.GetEnvironmentVariable("NADEKOBOT_IS_COORDINATED") != "1")
-            {
-                svcs.AddSingleton<ICoordinator, SingleProcessCoordinator>();
-            }
-            else
-            {
-                svcs.AddSingleton<ICoordinator, RemoteGrpcCoordinator>()
-                    .AddSingleton<IReadyExecutor>(x => (IReadyExecutor)x.GetRequiredService<ICoordinator>());
-            }
+        if (Environment.GetEnvironmentVariable("NADEKOBOT_IS_COORDINATED") != "1")
+            svcs.AddSingleton<ICoordinator, SingleProcessCoordinator>();
+        else
+        {
+            svcs.AddSingleton<RemoteGrpcCoordinator>()
+                .AddSingleton<ICoordinator>(x => x.GetRequiredService<RemoteGrpcCoordinator>())
+                .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RemoteGrpcCoordinator>());
+        }
 
-            svcs.Scan(scan => scan
-                .FromAssemblyOf<IReadyExecutor>()
-                .AddClasses(classes => classes.AssignableToAny(
-                    // services
-                    typeof(INService),
-                    
-                    // behaviours
-                    typeof(IEarlyBehavior),
-                    typeof(ILateBlocker),
-                    typeof(IInputTransformer),
-                    typeof(ILateExecutor))
+        svcs.AddSingleton<RedisLocalDataCache>()
+            .AddSingleton<ILocalDataCache>(x => x.GetRequiredService<RedisLocalDataCache>())
+            .AddSingleton<RedisImagesCache>()
+            .AddSingleton<IImageCache>(x => x.GetRequiredService<RedisImagesCache>())
+            .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RedisImagesCache>())
+            .AddSingleton<IDataCache, RedisCache>();
+
+        svcs.Scan(scan => scan.FromAssemblyOf<IReadyExecutor>()
+                              .AddClasses(classes => classes.AssignableToAny(
+                                      // services
+                                      typeof(INService),
+
+                                      // behaviours
+                                      typeof(IEarlyBehavior),
+                                      typeof(ILateBlocker),
+                                      typeof(IInputTransformer),
+                                      typeof(ILateExecutor))
 #if GLOBAL_NADEKO
                     .WithoutAttribute<NoPublicBotAttribute>()
 #endif
-                )
-                .AsSelfWithInterfaces()
-                .WithSingletonLifetime()
-            );
+                              )
+                              .AsSelfWithInterfaces()
+                              .WithSingletonLifetime());
 
-            //initialize Services
-            Services = svcs.BuildServiceProvider();
-            var exec = Services.GetRequiredService<IBehaviourExecutor>();
-            exec.Initialize();
+        //initialize Services
+        Services = svcs.BuildServiceProvider();
+        var exec = Services.GetRequiredService<IBehaviourExecutor>();
+        exec.Initialize();
 
-            if (Client.ShardId == 0)
-            {
-                ApplyConfigMigrations();
-            }
-            
-            _ = LoadTypeReaders(typeof(Bot).Assembly);
+        if (Client.ShardId == 0)
+            ApplyConfigMigrations();
 
-            sw.Stop();
-            Log.Information($"All services loaded in {sw.Elapsed.TotalSeconds:F2}s");
-        }
+        _ = LoadTypeReaders(typeof(Bot).Assembly);
 
-        private void ApplyConfigMigrations()
-        {
-            // execute all migrators
-            var migrators = Services.GetServices<IConfigMigrator>();
-            foreach (var migrator in migrators)
-            {
-                migrator.EnsureMigrated();
-            }
-        }
-
-        private IEnumerable<object> LoadTypeReaders(Assembly assembly)
-        {
-            Type[] allTypes;
-            try
-            {
-                allTypes = assembly.GetTypes();
-            }
-            catch (ReflectionTypeLoadException ex)
-            {
-                Log.Warning(ex.LoaderExceptions[0], "Error getting types");
-                return Enumerable.Empty<object>();
-            }
-            var filteredTypes = allTypes
-                .Where(x => x.IsSubclassOf(typeof(TypeReader))
-                    && x.BaseType.GetGenericArguments().Length > 0
-                    && !x.IsAbstract);
-
-            var toReturn = new List<object>();
-            foreach (var ft in filteredTypes)
-            {
-                var x = (TypeReader)ActivatorUtilities.CreateInstance(Services, ft);
-                var baseType = ft.BaseType;
-                var typeArgs = baseType.GetGenericArguments();
-                _commandService.AddTypeReader(typeArgs[0], x);
-                toReturn.Add(x);
-            }
-
-            return toReturn;
-        }
-
-        private async Task LoginAsync(string token)
-        {
-            var clientReady = new TaskCompletionSource<bool>();
-
-            Task SetClientReady()
-            {
-                var _ = Task.Run(async () =>
-                {
-                    clientReady.TrySetResult(true);
-                    try
-                    {
-                        foreach (var chan in (await Client.GetDMChannelsAsync().ConfigureAwait(false)))
-                        {
-                            await chan.CloseAsync().ConfigureAwait(false);
-                        }
-                    }
-                    catch
-                    {
-                        // ignored
-                    }
-                });
-                return Task.CompletedTask;
-            }
-
-            //connect
-            Log.Information("Shard {ShardId} logging in ...", Client.ShardId);
-            try
-            {
-                await Client.LoginAsync(TokenType.Bot, token).ConfigureAwait(false);
-                await Client.StartAsync().ConfigureAwait(false);
-            }
-            catch (HttpException ex)
-            {
-                LoginErrorHandler.Handle(ex);
-                Helpers.ReadErrorAndExit(3);
-            }
-            catch (Exception ex)
-            {
-                LoginErrorHandler.Handle(ex);
-                Helpers.ReadErrorAndExit(4);
-            }
-
-            Client.Ready += SetClientReady;
-            await clientReady.Task.ConfigureAwait(false);
-            Client.Ready -= SetClientReady;
-            
-            Client.JoinedGuild += Client_JoinedGuild;
-            Client.LeftGuild += Client_LeftGuild;
-            
-            Log.Information("Shard {0} logged in.", Client.ShardId);
-        }
-
-        private Task Client_LeftGuild(SocketGuild arg)
-        {
-            Log.Information("Left server: {0} [{1}]", arg?.Name, arg?.Id);
-            return Task.CompletedTask;
-        }
-
-        private Task Client_JoinedGuild(SocketGuild arg)
-        {
-            Log.Information($"Joined server: {0} [{1}]", arg.Name, arg.Id);
-            var _ = Task.Run(async () =>
-            {
-                GuildConfig gc;
-                using (var uow = _db.GetDbContext())
-                {
-                    gc = uow.GuildConfigsForId(arg.Id);
-                }
-                await JoinedGuild.Invoke(gc).ConfigureAwait(false);
-            });
-            return Task.CompletedTask;
-        }
-
-        public async Task RunAsync()
-        {
-            var sw = Stopwatch.StartNew();
-
-            await LoginAsync(_creds.Token).ConfigureAwait(false);
-
-            Mention = Client.CurrentUser.Mention;
-            Log.Information("Shard {ShardId} loading services...", Client.ShardId);
-            try
-            {
-                AddServices();
-            }
-            catch (Exception ex)
-            {
-                Log.Error(ex, "Error adding services");
-                Helpers.ReadErrorAndExit(9);
-            }
-
-            sw.Stop();
-            Log.Information("Shard {ShardId} connected in {Elapsed:F2}s", Client.ShardId, sw.Elapsed.TotalSeconds);
-            var commandHandler = Services.GetRequiredService<CommandHandler>();
-
-            // start handling messages received in commandhandler
-            await commandHandler.StartHandling().ConfigureAwait(false);
-
-            await _commandService.AddModulesAsync(typeof(Bot).Assembly, Services);
-            
-            IsReady = true;
-            _ = Task.Run(ExecuteReadySubscriptions);
-            Log.Information("Shard {ShardId} ready", Client.ShardId);
-        }
-
-        private Task ExecuteReadySubscriptions()
-        {
-            var readyExecutors = Services.GetServices<IReadyExecutor>();
-            var tasks = readyExecutors.Select(async toExec => 
-            {
-                try
-                {
-                    await toExec.OnReadyAsync();
-                }
-                catch (Exception ex)
-                {
-                    Log.Error(ex,
-                        "Failed running OnReadyAsync method on {Type} type: {Message}",
-                        toExec.GetType().Name,
-                        ex.Message);
-                }
-            });
-
-            return Task.WhenAll(tasks);
-        }
-
-        private Task Client_Log(LogMessage arg)
-        {
-            if (arg.Exception != null)
-                Log.Warning(arg.Exception, arg.Source + " | " + arg.Message);
-            else
-                Log.Warning(arg.Source + " | " + arg.Message);
-
-            return Task.CompletedTask;
-        }
-
-        public async Task RunAndBlockAsync()
-        {
-            await RunAsync().ConfigureAwait(false);
-            await Task.Delay(-1).ConfigureAwait(false);
-        }
+        sw.Stop();
+        Log.Information( "All services loaded in {ServiceLoadTime:F2}s", sw.Elapsed.TotalSeconds);
     }
-}
+
+    private void ApplyConfigMigrations()
+    {
+        // execute all migrators
+        var migrators = Services.GetServices<IConfigMigrator>();
+        foreach (var migrator in migrators)
+            migrator.EnsureMigrated();
+    }
+
+    private IEnumerable<object> LoadTypeReaders(Assembly assembly)
+    {
+        Type[] allTypes;
+        try
+        {
+            allTypes = assembly.GetTypes();
+        }
+        catch (ReflectionTypeLoadException ex)
+        {
+            Log.Warning(ex.LoaderExceptions[0], "Error getting types");
+            return Enumerable.Empty<object>();
+        }
+
+        var filteredTypes = allTypes.Where(x => x.IsSubclassOf(typeof(TypeReader))
+                                                && x.BaseType?.GetGenericArguments().Length > 0
+                                                && !x.IsAbstract);
+
+        var toReturn = new List<object>();
+        foreach (var ft in filteredTypes)
+        {
+            var x = (TypeReader)ActivatorUtilities.CreateInstance(Services, ft);
+            var baseType = ft.BaseType;
+            if (baseType is null)
+                continue;
+            var typeArgs = baseType.GetGenericArguments();
+            _commandService.AddTypeReader(typeArgs[0], x);
+            toReturn.Add(x);
+        }
+
+        return toReturn;
+    }
+
+    private async Task LoginAsync(string token)
+    {
+        var clientReady = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        async Task SetClientReady()
+        {
+            clientReady.TrySetResult(true);
+            try
+            {
+                foreach (var chan in await Client.GetDMChannelsAsync())
+                    await chan.CloseAsync();
+            }
+            catch
+            {
+                // ignored
+            }
+        }
+
+        //connect
+        Log.Information("Shard {ShardId} logging in ...", Client.ShardId);
+        try
+        {
+            Client.Ready += SetClientReady;
+
+            await Client.LoginAsync(TokenType.Bot, token);
+            await Client.StartAsync();
+        }
+        catch (HttpException ex)
+        {
+            LoginErrorHandler.Handle(ex);
+            Helpers.ReadErrorAndExit(3);
+        }
+        catch (Exception ex)
+        {
+            LoginErrorHandler.Handle(ex);
+            Helpers.ReadErrorAndExit(4);
+        }
+        
+        await clientReady.Task.ConfigureAwait(false);
+        Client.Ready -= SetClientReady;
+        
+        Client.JoinedGuild += Client_JoinedGuild;
+        Client.LeftGuild += Client_LeftGuild;
+
+        Log.Information("Shard {ShardId} logged in", Client.ShardId);
+    }
+
+    private Task Client_LeftGuild(SocketGuild arg)
+    {
+        Log.Information("Left server: {GuildName} [{GuildId}]", arg?.Name, arg?.Id);
+        return Task.CompletedTask;
+    }
+
+    private Task Client_JoinedGuild(SocketGuild arg)
+    {
+        Log.Information("Joined server: {GuildName} [{GuildId}]", arg.Name, arg.Id);
+        _ = Task.Run(async () =>
+        {
+            GuildConfig gc;
+            await using (var uow = _db.GetDbContext())
+            {
+                gc = uow.GuildConfigsForId(arg.Id, null);
+            }
+
+            await JoinedGuild.Invoke(gc);
+        });
+        return Task.CompletedTask;
+    }
+
+    public async Task RunAsync()
+    {
+        var sw = Stopwatch.StartNew();
+
+        await LoginAsync(_creds.Token);
+
+        Mention = Client.CurrentUser.Mention;
+        Log.Information("Shard {ShardId} loading services...", Client.ShardId);
+        try
+        {
+            AddServices();
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Error adding services");
+            Helpers.ReadErrorAndExit(9);
+        }
+
+        sw.Stop();
+        Log.Information("Shard {ShardId} connected in {Elapsed:F2}s", Client.ShardId, sw.Elapsed.TotalSeconds);
+        var commandHandler = Services.GetRequiredService<CommandHandler>();
+
+        // start handling messages received in commandhandler
+        await commandHandler.StartHandling();
+
+        await _commandService.AddModulesAsync(typeof(Bot).Assembly, Services);
+        // await _interactionService.AddModulesAsync(typeof(Bot).Assembly, Services);
+        IsReady = true;
+        _ = Task.Run(ExecuteReadySubscriptions);
+        Log.Information("Shard {ShardId} ready", Client.ShardId);
+    }
+
+    private Task ExecuteReadySubscriptions()
+    {
+        var readyExecutors = Services.GetServices<IReadyExecutor>();
+        var tasks = readyExecutors.Select(async toExec =>
+        {
+            try
+            {
+                await toExec.OnReadyAsync();
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex,
+                    "Failed running OnReadyAsync method on {Type} type: {Message}",
+                    toExec.GetType().Name,
+                    ex.Message);
+            }
+        });
+
+        return tasks.WhenAll();
+    }
+
+    private Task Client_Log(LogMessage arg)
+    {
+        if (arg.Message?.Contains("unknown dispatch", StringComparison.InvariantCultureIgnoreCase) ?? false)
+            return Task.CompletedTask;
+
+        if (arg.Exception is { InnerException: WebSocketClosedException { CloseCode: 4014 } })
+        {
+            Log.Error(@"
+Login failed.
+
+*** Please enable privileged intents ***
+
+Certain Nadeko features require Discord's privileged gateway intents.
+These include greeting and goodbye messages, as well as creating the Owner message channels for DM forwarding.
+
+How to enable privileged intents:
+1. Head over to the Discord Developer Portal https://discord.com/developers/applications/
+2. Select your Application.
+3. Click on `Bot` in the left side navigation panel, and scroll down to the intents section.
+4. Enable all intents.
+5. Restart your bot.
+
+Read this only if your bot is in 100 or more servers:
+
+You'll need to apply to use the intents with Discord, but for small selfhosts, all that is required is enabling the intents in the developer portal.
+Yes, this is a new thing from Discord, as of October 2020. No, there's nothing we can do about it. Yes, we're aware it worked before.
+While waiting for your bot to be accepted, you can change the 'usePrivilegedIntents' inside your creds.yml to 'false', although this will break many of the nadeko's features");
+        }
+        else if (arg.Exception is not null)
+            Log.Warning(arg.Exception, "{ErrorSource} | {ErrorMessage}", arg.Source, arg.Message);
+        else
+            Log.Warning("{ErrorSource} | {ErrorMessage}", arg.Source, arg.Message);
+
+        return Task.CompletedTask;
+    }
+
+    public async Task RunAndBlockAsync()
+    {
+        await RunAsync();
+        await Task.Delay(-1);
+    }
+}

src/NadekoBot/Common/AddRemove.cs

@@ -0,0 +1,10 @@
+#nullable disable
+namespace NadekoBot.Common;
+
+public enum AddRemove
+{
+    Add = int.MinValue,
+    Remove = int.MinValue + 1,
+    Rem = int.MinValue + 1,
+    Rm = int.MinValue + 1
+}

src/NadekoBot/Common/AsyncLazy.cs

@@ -1,20 +1,20 @@
-using System;
+#nullable disable
 using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
 
-namespace NadekoBot.Common
+namespace NadekoBot.Common;
+
+public class AsyncLazy<T> : Lazy<Task<T>>
 {
-    public class AsyncLazy<T> : Lazy<Task<T>>
+    public AsyncLazy(Func<T> valueFactory)
+        : base(() => Task.Run(valueFactory))
     {
-        public AsyncLazy(Func<T> valueFactory) :
-            base(() => Task.Run(valueFactory))
-        { }
-
-        public AsyncLazy(Func<Task<T>> taskFactory) :
-            base(() => Task.Run(taskFactory))
-        { }
-
-        public TaskAwaiter<T> GetAwaiter() { return Value.GetAwaiter(); }
     }
 
-}
+    public AsyncLazy(Func<Task<T>> taskFactory)
+        : base(() => Task.Run(taskFactory))
+    {
+    }
+
+    public TaskAwaiter<T> GetAwaiter()
+        => Value.GetAwaiter();
+}

src/NadekoBot/Common/Attributes/Aliases.cs

@@ -1,18 +1,12 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using System.Runtime.CompilerServices;
-using Discord.Commands;
-using NadekoBot.Services;
-namespace NadekoBot.Common.Attributes
+
+namespace NadekoBot.Common.Attributes;
+
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class AliasesAttribute : AliasAttribute
 {
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class AliasesAttribute : AliasAttribute
+    public AliasesAttribute([CallerMemberName] string memberName = "")
+        : base(CommandNameLoadHelper.GetAliasesFor(memberName))
     {
-        public AliasesAttribute([CallerMemberName] string memberName = "")
-            : base(CommandNameLoadHelper.GetAliasesFor(memberName))
-        {
-        }
     }
-}
+}

src/NadekoBot/Common/Attributes/BotPerm.cs

@@ -1,15 +0,0 @@
-using Discord.Commands;
-
-namespace Discord
-{
-    public class BotPermAttribute : RequireBotPermissionAttribute
-    {
-        public BotPermAttribute(GuildPerm permission) : base((GuildPermission)permission)
-        {
-        }
-
-        public BotPermAttribute(ChannelPerm permission) : base((ChannelPermission)permission)
-        {
-        }
-    }
-}

src/NadekoBot/Common/Attributes/CommandNameLoadHelper.cs

@@ -1,36 +1,31 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
+using YamlDotNet.Serialization;
 
-namespace NadekoBot.Common.Attributes
+namespace NadekoBot.Common.Attributes;
+
+public static class CommandNameLoadHelper
 {
-    public static class CommandNameLoadHelper
+    private static readonly IDeserializer _deserializer = new Deserializer();
+
+    private static readonly Lazy<Dictionary<string, string[]>> _lazyCommandAliases
+        = new(() => LoadAliases());
+
+    public static Dictionary<string, string[]> LoadAliases(string aliasesFilePath = "data/aliases.yml")
     {
-        
-        private static YamlDotNet.Serialization.IDeserializer _deserializer
-            = new YamlDotNet.Serialization.Deserializer();
-        
-        public static Lazy<Dictionary<string, string[]>> LazyCommandAliases
-            = new Lazy<Dictionary<string, string[]>>(() => LoadCommandNames()); 
-        public static Dictionary<string, string[]> LoadCommandNames(string aliasesFilePath = "data/aliases.yml")
-        {
-            var text = File.ReadAllText(aliasesFilePath);
-            return _deserializer.Deserialize<Dictionary<string, string[]>>(text);
-        }
+        var text = File.ReadAllText(aliasesFilePath);
+        return _deserializer.Deserialize<Dictionary<string, string[]>>(text);
+    }
 
-        public static string[] GetAliasesFor(string methodName)
-            => LazyCommandAliases.Value.TryGetValue(methodName.ToLowerInvariant(), out var aliases) && aliases.Length > 1
-                ? aliases.Skip(1).ToArray()
-                : Array.Empty<string>();
+    public static string[] GetAliasesFor(string methodName)
+        => _lazyCommandAliases.Value.TryGetValue(methodName.ToLowerInvariant(), out var aliases) && aliases.Length > 1
+            ? aliases.Skip(1).ToArray()
+            : Array.Empty<string>();
 
-        public static string GetCommandNameFor(string methodName)
-        {
-            methodName = methodName.ToLowerInvariant();
-            var toReturn = LazyCommandAliases.Value.TryGetValue(methodName, out var aliases) && aliases.Length > 0
-                ? aliases[0]
-                : methodName;
-            return toReturn;
-        }
+    public static string GetCommandNameFor(string methodName)
+    {
+        methodName = methodName.ToLowerInvariant();
+        var toReturn = _lazyCommandAliases.Value.TryGetValue(methodName, out var aliases) && aliases.Length > 0
+            ? aliases[0]
+            : methodName;
+        return toReturn;
     }
 }

src/NadekoBot/Common/Attributes/Description.cs

@@ -1,16 +0,0 @@
-using System;
-using System.Runtime.CompilerServices;
-using Discord.Commands;
-using NadekoBot.Services;
-
-namespace NadekoBot.Common.Attributes
-{
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class DescriptionAttribute : SummaryAttribute
-    {
-        // Localization.LoadCommand(memberName.ToLowerInvariant()).Desc
-        public DescriptionAttribute(string text = "") : base(text)
-        {
-        }
-    }
-}

src/NadekoBot/Common/Attributes/LeftoverAttribute.cs

@@ -1,9 +0,0 @@
-namespace Discord.Commands
-{
-    public class LeftoverAttribute : RemainderAttribute
-    {
-        public LeftoverAttribute()
-        {
-        }
-    }
-}

src/NadekoBot/Common/Attributes/NadekoCommand.cs

@@ -1,19 +1,13 @@
-using System;
 using System.Runtime.CompilerServices;
-using Discord.Commands;
-using NadekoBot.Services;
 
-namespace NadekoBot.Common.Attributes
+namespace NadekoBot.Common.Attributes;
+
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class NadekoCommandAttribute : CommandAttribute
 {
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class NadekoCommandAttribute : CommandAttribute
-    {
-        public NadekoCommandAttribute([CallerMemberName] string memberName="") 
-            : base(CommandNameLoadHelper.GetCommandNameFor(memberName))
-        {
-            this.MethodName = memberName.ToLowerInvariant();
-        }
+    public string MethodName { get; }
 
-        public string MethodName { get; }
-    }
-}
+    public NadekoCommandAttribute([CallerMemberName] string memberName = "")
+        : base(CommandNameLoadHelper.GetCommandNameFor(memberName))
+        => MethodName = memberName.ToLowerInvariant();
+}

src/NadekoBot/Common/Attributes/NadekoModuleAttribute.cs

@@ -1,14 +1,30 @@
-using System;
-using Discord.Commands;
+using System.Runtime.CompilerServices;
 
-namespace NadekoBot.Common.Attributes
+namespace NadekoBot.Common.Attributes;
+
+[AttributeUsage(AttributeTargets.Class)]
+internal sealed class NadekoModuleAttribute : GroupAttribute
 {
-    [AttributeUsage(AttributeTargets.Class)]
-    sealed class NadekoModuleAttribute : GroupAttribute
+    public NadekoModuleAttribute(string moduleName)
+        : base(moduleName)
     {
-        public NadekoModuleAttribute(string moduleName) : base(moduleName)
-        {
-        }
     }
 }
 
+[AttributeUsage(AttributeTargets.Method)]
+internal sealed class NadekoDescriptionAttribute : SummaryAttribute
+{
+    public NadekoDescriptionAttribute([CallerMemberName] string name = "")
+        : base(name.ToLowerInvariant())
+    {
+    }
+}
+
+[AttributeUsage(AttributeTargets.Method)]
+internal sealed class NadekoUsageAttribute : RemarksAttribute
+{
+    public NadekoUsageAttribute([CallerMemberName] string name = "")
+        : base(name.ToLowerInvariant())
+    {
+    }
+}

src/NadekoBot/Common/Attributes/NadekoOptions.cs

@@ -1,15 +1,10 @@
-using System;
+namespace NadekoBot.Common.Attributes;
 
-namespace NadekoBot.Common.Attributes
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class NadekoOptionsAttribute : Attribute
 {
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class NadekoOptionsAttribute : Attribute
-    {
-        public Type OptionType { get; set; }
+    public Type OptionType { get; set; }
 
-        public NadekoOptionsAttribute(Type t)
-        {
-            this.OptionType = t;
-        }
-    }
-}
+    public NadekoOptionsAttribute(Type t)
+        => OptionType = t;
+}

src/NadekoBot/Common/Attributes/OwnerOnlyAttribute.cs

@@ -1,20 +1,19 @@
-using System;
-using System.Threading.Tasks;
-using Discord.Commands;
 using Microsoft.Extensions.DependencyInjection;
-using NadekoBot.Extensions;
-using NadekoBot.Services;
 
-namespace NadekoBot.Common.Attributes
+namespace NadekoBot.Common.Attributes;
+
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
+public sealed class OwnerOnlyAttribute : PreconditionAttribute
 {
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
-    public sealed class OwnerOnlyAttribute : PreconditionAttribute
+    public override Task<PreconditionResult> CheckPermissionsAsync(
+        ICommandContext context,
+        CommandInfo command,
+        IServiceProvider services)
     {
-        public override Task<PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo executingCommand, IServiceProvider services)
-        {
-            var creds = services.GetRequiredService<BotCredsProvider>().GetCreds();
+        var creds = services.GetRequiredService<IBotCredsProvider>().GetCreds();
 
-            return Task.FromResult((creds.IsOwner(context.User) || context.Client.CurrentUser.Id == context.User.Id ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("Not owner")));
-        }
+        return Task.FromResult(creds.IsOwner(context.User) || context.Client.CurrentUser.Id == context.User.Id
+            ? PreconditionResult.FromSuccess()
+            : PreconditionResult.FromError("Not owner"));
     }
 }

src/NadekoBot/Common/Attributes/Ratelimit.cs

@@ -1,38 +1,36 @@
-using Discord.Commands;
-using NadekoBot.Services;
-using System;
-using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace NadekoBot.Common.Attributes
+namespace NadekoBot.Common.Attributes;
+
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class RatelimitAttribute : PreconditionAttribute
 {
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class RatelimitAttribute : PreconditionAttribute
+    public int Seconds { get; }
+
+    public RatelimitAttribute(int seconds)
     {
-        public int Seconds { get; }
+        if (seconds <= 0)
+            throw new ArgumentOutOfRangeException(nameof(seconds));
 
-        public RatelimitAttribute(int seconds)
-        {
-            if (seconds <= 0)
-                throw new ArgumentOutOfRangeException(nameof(seconds));
-
-            Seconds = seconds;
-        }
-
-        public override Task<PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services)
-        {
-            if (Seconds == 0)
-                return Task.FromResult(PreconditionResult.FromSuccess());
-
-            var cache = services.GetRequiredService<IDataCache>();
-            var rem = cache.TryAddRatelimit(context.User.Id, command.Name, Seconds);
-
-            if(rem is null)
-                return Task.FromResult(PreconditionResult.FromSuccess());
-
-            var msgContent = $"You can use this command again in {rem.Value.TotalSeconds:F1}s.";
-
-            return Task.FromResult(PreconditionResult.FromError(msgContent));
-        }
+        Seconds = seconds;
     }
-}
+
+    public override Task<PreconditionResult> CheckPermissionsAsync(
+        ICommandContext context,
+        CommandInfo command,
+        IServiceProvider services)
+    {
+        if (Seconds == 0)
+            return Task.FromResult(PreconditionResult.FromSuccess());
+
+        var cache = services.GetRequiredService<IDataCache>();
+        var rem = cache.TryAddRatelimit(context.User.Id, command.Name, Seconds);
+
+        if (rem is null)
+            return Task.FromResult(PreconditionResult.FromSuccess());
+
+        var msgContent = $"You can use this command again in {rem.Value.TotalSeconds:F1}s.";
+
+        return Task.FromResult(PreconditionResult.FromError(msgContent));
+    }
+}

src/NadekoBot/Common/Attributes/Usage.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Runtime.CompilerServices;
-using Discord.Commands;
-using NadekoBot.Services;
-using Newtonsoft.Json;
-
-namespace NadekoBot.Common.Attributes
-{
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class UsageAttribute : RemarksAttribute
-    {
-        // public static string GetUsage(string memberName)
-        // {
-        //     var usage = Localization.LoadCommand(memberName.ToLowerInvariant()).Usage;
-        //     return JsonConvert.SerializeObject(usage);
-        // }
-        public UsageAttribute(string text = "") : base(text)
-        {
-        }
-    }
-}

src/NadekoBot/Common/Attributes/UserPerm.cs

@@ -1,33 +1,30 @@
-using System;
-using System.Threading.Tasks;
-using Discord.Commands;
 using Microsoft.Extensions.DependencyInjection;
 using NadekoBot.Modules.Administration.Services;
 
-namespace Discord
+namespace Discord;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class UserPermAttribute : RequireUserPermissionAttribute
 {
-    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
-    public class UserPermAttribute : PreconditionAttribute
+    public UserPermAttribute(GuildPerm permission)
+        : base(permission)
     {
-        public RequireUserPermissionAttribute UserPermissionAttribute { get; }
-
-        public UserPermAttribute(GuildPerm permission)
-        {
-            UserPermissionAttribute = new RequireUserPermissionAttribute((GuildPermission)permission);
-        }
-
-        public UserPermAttribute(ChannelPerm permission)
-        {
-            UserPermissionAttribute = new RequireUserPermissionAttribute((ChannelPermission)permission);
-        }
-
-        public override Task<PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services)
-        {
-            var permService = services.GetRequiredService<DiscordPermOverrideService>();
-            if (permService.TryGetOverrides(context.Guild?.Id ?? 0, command.Name.ToUpperInvariant(), out var _))
-                return Task.FromResult(PreconditionResult.FromSuccess());
-            
-            return UserPermissionAttribute.CheckPermissionsAsync(context, command, services);
-        }
     }
-}
+
+    public UserPermAttribute(ChannelPerm permission)
+        : base(permission)
+    {
+    }
+
+    public override Task<PreconditionResult> CheckPermissionsAsync(
+        ICommandContext context,
+        CommandInfo command,
+        IServiceProvider services)
+    {
+        var permService = services.GetRequiredService<DiscordPermOverrideService>();
+        if (permService.TryGetOverrides(context.Guild?.Id ?? 0, command.Name.ToUpperInvariant(), out _))
+            return Task.FromResult(PreconditionResult.FromSuccess());
+
+        return base.CheckPermissionsAsync(context, command, services);
+    }
+}

src/NadekoBot/Common/BotConfigEditType.cs

@@ -1,26 +0,0 @@
-namespace NadekoBot.Common
-{
-    public enum BotConfigEditType
-    {
-        /// <summary>
-        /// The amount of currency awarded to the winner of the trivia game.
-        /// Default is 0.
-        /// </summary>
-        TriviaCurrencyReward,
-        /// <summary>
-        /// Users can't start trivia games which have smaller win requirement than specified by this setting.
-        /// Default is 0.
-        /// </summary>
-        MinimumTriviaWinReq,
-        /// <summary>
-        /// The amount of XP the user receives when they send a message (which is not too short).
-        /// Default is 3.
-        /// </summary>
-        XpPerMessage,
-        /// <summary>
-        /// This value represents how often the user can receive XP from sending messages.
-        /// Default is 5.
-        /// </summary>
-        XpMinutesTimeout,
-    }
-}

src/NadekoBot/Common/CmdStrings.cs

@@ -1,20 +1,17 @@
-using Newtonsoft.Json;
+#nullable disable
+using Newtonsoft.Json;
 
-namespace NadekoBot.Common
+namespace NadekoBot.Common;
+
+public class CmdStrings
 {
-    public class CmdStrings
-    {
-        public string[] Usages { get; }
-        public string Description { get; }
+    public string[] Usages { get; }
+    public string Description { get; }
 
-        [JsonConstructor]
-        public CmdStrings(
-            [JsonProperty("args")]string[] usages,
-            [JsonProperty("desc")]string description
-        )
-        {
-            Usages = usages;
-            Description = description;
-        }
+    [JsonConstructor]
+    public CmdStrings([JsonProperty("args")] string[] usages, [JsonProperty("desc")] string description)
+    {
+        Usages = usages;
+        Description = description;
     }
 }

src/NadekoBot/Common/Collections/DisposableImutableList.cs

@@ -1,77 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace NadekoBot.Common.Collections
-{
-    public static class DisposableReadOnlyListExtensions
-    {
-        public static IDisposableReadOnlyList<T> AsDisposable<T>(this IReadOnlyList<T> arr) where T : IDisposable
-            => new DisposableReadOnlyList<T>(arr);
-
-        public static IDisposableReadOnlyList<KeyValuePair<TKey, TValue>> AsDisposable<TKey, TValue>(this IReadOnlyList<KeyValuePair<TKey, TValue>> arr) where TValue : IDisposable
-            => new DisposableReadOnlyList<TKey, TValue>(arr);
-    }
-
-    public interface IDisposableReadOnlyList<T> : IReadOnlyList<T>, IDisposable
-    {
-    }
-
-    public sealed class DisposableReadOnlyList<T> : IDisposableReadOnlyList<T>
-        where T : IDisposable
-    {
-        private readonly IReadOnlyList<T> _arr;
-
-        public int Count => _arr.Count;
-
-        public T this[int index] => _arr[index];
-
-        public DisposableReadOnlyList(IReadOnlyList<T> arr)
-        {
-            this._arr = arr;
-        }
-
-        public IEnumerator<T> GetEnumerator()
-            => _arr.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator()
-            => _arr.GetEnumerator();
-
-        public void Dispose()
-        {
-            foreach (var item in _arr)
-            {
-                item.Dispose();
-            }
-        }
-    }
-
-    public sealed class DisposableReadOnlyList<T, U> : IDisposableReadOnlyList<KeyValuePair<T, U>>
-        where U : IDisposable
-    {
-        private readonly IReadOnlyList<KeyValuePair<T, U>> _arr;
-
-        public int Count => _arr.Count;
-
-        KeyValuePair<T, U> IReadOnlyList<KeyValuePair<T, U>>.this[int index] => _arr[index];
-
-        public DisposableReadOnlyList(IReadOnlyList<KeyValuePair<T, U>> arr)
-        {
-            this._arr = arr;
-        }
-
-        public IEnumerator<KeyValuePair<T, U>> GetEnumerator() =>
-            _arr.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator() =>
-            _arr.GetEnumerator();
-
-        public void Dispose()
-        {
-            foreach (var item in _arr)
-            {
-                item.Value.Dispose();
-            }
-        }
-    }
-}

src/NadekoBot/Common/Collections/IndexedCollection.cs

@@ -1,141 +1,145 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
+#nullable disable
 using NadekoBot.Services.Database.Models;
+using System.Collections;
 
-namespace NadekoBot.Common.Collections
+namespace NadekoBot.Common.Collections;
+
+public class IndexedCollection<T> : IList<T>
+    where T : class, IIndexed
 {
-    public class IndexedCollection<T> : IList<T> where T : class, IIndexed
+    public List<T> Source { get; }
+
+    public int Count
+        => Source.Count;
+
+    public bool IsReadOnly
+        => false;
+
+    public virtual T this[int index]
     {
-        public List<T> Source { get; }
-        private readonly object _locker = new object();
-
-        public int Count => Source.Count;
-        public bool IsReadOnly => false;
-        public int IndexOf(T item) => item.Index;
-
-        public IndexedCollection()
-        {
-            Source = new List<T>();
-        }
-        
-        public IndexedCollection(IEnumerable<T> source)
+        get => Source[index];
+        set
         {
             lock (_locker)
             {
-                Source = source.OrderBy(x => x.Index).ToList();
-                UpdateIndexes();
+                value.Index = index;
+                Source[index] = value;
             }
         }
+    }
 
-        public void UpdateIndexes()
+    private readonly object _locker = new();
+
+    public IndexedCollection()
+        => Source = new();
+
+    public IndexedCollection(IEnumerable<T> source)
+    {
+        lock (_locker)
         {
-            lock (_locker)
+            Source = source.OrderBy(x => x.Index).ToList();
+            UpdateIndexes();
+        }
+    }
+
+    public int IndexOf(T item)
+        => item?.Index ?? -1;
+
+    public IEnumerator<T> GetEnumerator()
+        => Source.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator()
+        => Source.GetEnumerator();
+
+    public void Add(T item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+
+        lock (_locker)
+        {
+            item.Index = Source.Count;
+            Source.Add(item);
+        }
+    }
+
+    public virtual void Clear()
+    {
+        lock (_locker)
+        {
+            Source.Clear();
+        }
+    }
+
+    public bool Contains(T item)
+    {
+        lock (_locker)
+        {
+            return Source.Contains(item);
+        }
+    }
+
+    public void CopyTo(T[] array, int arrayIndex)
+    {
+        lock (_locker)
+        {
+            Source.CopyTo(array, arrayIndex);
+        }
+    }
+
+    public virtual bool Remove(T item)
+    {
+        lock (_locker)
+        {
+            if (Source.Remove(item))
             {
                 for (var i = 0; i < Source.Count; i++)
                 {
                     if (Source[i].Index != i)
                         Source[i].Index = i;
                 }
+
+                return true;
             }
         }
 
-        public static implicit operator List<T>(IndexedCollection<T> x) =>
-            x.Source;
+        return false;
+    }
 
-        public List<T> ToList() => Source.ToList();
-
-        public IEnumerator<T> GetEnumerator() =>
-            Source.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator() =>
-            Source.GetEnumerator();
-
-        public void Add(T item)
+    public virtual void Insert(int index, T item)
+    {
+        lock (_locker)
         {
-            lock (_locker)
-            {
-                item.Index = Source.Count;
-                Source.Add(item);
-            }
+            Source.Insert(index, item);
+            for (var i = index; i < Source.Count; i++)
+                Source[i].Index = i;
         }
+    }
 
-        public virtual void Clear()
+    public virtual void RemoveAt(int index)
+    {
+        lock (_locker)
         {
-            lock (_locker)
-            {
-                Source.Clear();
-            }
+            Source.RemoveAt(index);
+            for (var i = index; i < Source.Count; i++)
+                Source[i].Index = i;
         }
+    }
 
-        public bool Contains(T item)
+    public void UpdateIndexes()
+    {
+        lock (_locker)
         {
-            lock (_locker)
+            for (var i = 0; i < Source.Count; i++)
             {
-                return Source.Contains(item);
-            }
-        }
-
-        public void CopyTo(T[] array, int arrayIndex)
-        {
-            lock (_locker)
-            {
-                Source.CopyTo(array, arrayIndex);
-            }
-        }
-
-        public virtual bool Remove(T item)
-        {
-            bool removed;
-            lock (_locker)
-            {
-                if (removed = Source.Remove(item))
-                {
-                    for (int i = 0; i < Source.Count; i++)
-                    {
-                        if (Source[i].Index != i)
-                            Source[i].Index = i;
-                    }
-                }
-            }
-            return removed;
-        }
-
-        public virtual void Insert(int index, T item)
-        {
-            lock (_locker)
-            {
-                Source.Insert(index, item);
-                for (int i = index; i < Source.Count; i++)
-                {
+                if (Source[i].Index != i)
                     Source[i].Index = i;
-                }
-            }
-        }
-
-        public virtual void RemoveAt(int index)
-        {
-            lock (_locker)
-            {
-                Source.RemoveAt(index);
-                for (int i = index; i < Source.Count; i++)
-                {
-                    Source[i].Index = i;
-                }
-            }
-        }
-
-        public virtual T this[int index]
-        {
-            get { return Source[index]; }
-            set
-            {
-                lock (_locker)
-                {
-                    value.Index = index;
-                    Source[index] = value;
-                }
             }
         }
     }
-}
+
+    public static implicit operator List<T>(IndexedCollection<T> x)
+        => x.Source;
+
+    public List<T> ToList()
+        => Source.ToList();
+}

src/NadekoBot/Common/CommandData.cs

@@ -1,9 +1,9 @@
-namespace NadekoBot.Common
+#nullable disable
+namespace NadekoBot.Common;
+
+public class CommandData
 {
-    public class CommandData
-    {
-        public string Cmd { get; set; }
-        public string Desc { get; set; }
-        public string[] Usage { get; set; }
-    }
-}
+    public string Cmd { get; set; }
+    public string Desc { get; set; }
+    public string[] Usage { get; set; }
+}

src/NadekoBot/Common/Configs/BotConfig.cs

@@ -1,64 +1,71 @@
-using System.Collections.Generic;
-using System.Globalization;
+#nullable disable
 using Cloneable;
 using NadekoBot.Common.Yml;
 using SixLabors.ImageSharp.PixelFormats;
+using System.Globalization;
 using YamlDotNet.Core;
 using YamlDotNet.Serialization;
 
-namespace NadekoBot.Common.Configs
-{
-    [Cloneable]
-    public sealed partial class BotConfig : ICloneable<BotConfig>
-    {
-        [Comment(@"DO NOT CHANGE")]
-        public int Version { get; set; }
+namespace NadekoBot.Common.Configs;
 
-        [Comment(@"Most commands, when executed, have a small colored line
+[Cloneable]
+public sealed partial class BotConfig : ICloneable<BotConfig>
+{
+    [Comment(@"DO NOT CHANGE")]
+    public int Version { get; set; } = 2;
+
+    [Comment(@"Most commands, when executed, have a small colored line
 next to the response. The color depends whether the command
 is completed, errored or in progress (pending)
 Color settings below are for the color of those lines.
 To get color's hex, you can go here https://htmlcolorcodes.com/
 and copy the hex code fo your selected color (marked as #)")]
-        public ColorConfig Color { get; set; }
-        
-        [Comment("Default bot language. It has to be in the list of supported languages (.langli)")]
-        public CultureInfo DefaultLocale { get; set; }
-        
-        [Comment(@"Style in which executed commands will show up in the console.
+    public ColorConfig Color { get; set; }
+
+    [Comment("Default bot language. It has to be in the list of supported languages (.langli)")]
+    public CultureInfo DefaultLocale { get; set; }
+
+    [Comment(@"Style in which executed commands will show up in the console.
 Allowed values: Simple, Normal, None")]
-        public ConsoleOutputType ConsoleOutputType { get; set; }
+    public ConsoleOutputType ConsoleOutputType { get; set; }
 
 //         [Comment(@"For what kind of updates will the bot check.
 // Allowed values: Release, Commit, None")]
 //         public UpdateCheckType CheckForUpdates { get; set; }
 
-        // [Comment(@"How often will the bot check for updates, in hours")]
-        // public int CheckUpdateInterval { get; set; }
+    // [Comment(@"How often will the bot check for updates, in hours")]
+    // public int CheckUpdateInterval { get; set; }
 
-        [Comment(@"Do you want any messages sent by users in Bot's DM to be forwarded to the owner(s)?")]
-        public bool ForwardMessages { get; set; }
+    [Comment(@"Do you want any messages sent by users in Bot's DM to be forwarded to the owner(s)?")]
+    public bool ForwardMessages { get; set; }
 
-        [Comment(@"Do you want the message to be forwarded only to the first owner specified in the list of owners (in creds.yml),
+    [Comment(
+        @"Do you want the message to be forwarded only to the first owner specified in the list of owners (in creds.yml),
 or all owners? (this might cause the bot to lag if there's a lot of owners specified)")]
-        public bool ForwardToAllOwners { get; set; }
+    public bool ForwardToAllOwners { get; set; }
 
-        [Comment(@"When a user DMs the bot with a message which is not a command
+    [Comment(@"When a user DMs the bot with a message which is not a command
 they will receive this message. Leave empty for no response. The string which will be sent whenever someone DMs the bot.
 Supports embeds. How it looks: https://puu.sh/B0BLV.png")]
-        [YamlMember(ScalarStyle = ScalarStyle.Literal)]
-        public string DmHelpText { get; set; }
+    [YamlMember(ScalarStyle = ScalarStyle.Literal)]
+    public string DmHelpText { get; set; }
 
-        [Comment(@"This is the response for the .h command")]
-        [YamlMember(ScalarStyle = ScalarStyle.Literal)]
-        public string HelpText { get; set; }
-        [Comment(@"List of modules and commands completely blocked on the bot")]
-        public BlockedConfig Blocked { get; set; }
+    [Comment(@"Only users who send a DM to the bot containing one of the specified words will get a DmHelpText response.
+Case insensitive.
+Leave empty to reply with DmHelpText to every DM.")]
+    public List<string> DmHelpTextKeywords { get; set; }
 
-        [Comment(@"Which string will be used to recognize the commands")]
-        public string Prefix { get; set; }
-        
-        [Comment(@"Toggles whether your bot will group greet/bye messages into a single message every 5 seconds.
+    [Comment(@"This is the response for the .h command")]
+    [YamlMember(ScalarStyle = ScalarStyle.Literal)]
+    public string HelpText { get; set; }
+
+    [Comment(@"List of modules and commands completely blocked on the bot")]
+    public BlockedConfig Blocked { get; set; }
+
+    [Comment(@"Which string will be used to recognize the commands")]
+    public string Prefix { get; set; }
+
+    [Comment(@"Toggles whether your bot will group greet/bye messages into a single message every 5 seconds.
 1st user who joins will get greeted immediately
 If more users join within the next 5 seconds, they will be greeted in groups of 5.
 This will cause %user.mention% and other placeholders to be replaced with multiple users. 
@@ -67,37 +74,23 @@ it will become invalid, as it will resolve to a list of avatars of grouped users
 note: This setting is primarily used if you're afraid of raids, or you're running medium/large bots where some
       servers might get hundreds of people join at once. This is used to prevent the bot from getting ratelimited,
       and (slightly) reduce the greet spam in those servers.")]
-        public bool GroupGreets { get; set; }
-        
-        [Comment(@"Whether the bot will rotate through all specified statuses.
-This setting can be changed via .rots command.
+    public bool GroupGreets { get; set; }
+
+    [Comment(@"Whether the bot will rotate through all specified statuses.
+This setting can be changed via .ropl command.
 See RotatingStatuses submodule in Administration.")]
-        public bool RotateStatuses { get; set; }
+    public bool RotateStatuses { get; set; }
 
-//         [Comment(@"Whether the prefix will be a suffix, or prefix.
-// For example, if your prefix is ! you will run a command called 'cash' by typing either
-// '!cash @Someone' if your prefixIsSuffix: false or
-// 'cash @Someone!' if your prefixIsSuffix: true")]
-//         public bool PrefixIsSuffix { get; set; }
-
-        // public string Prefixed(string text) => PrefixIsSuffix
-        //     ? text + Prefix
-        //     : Prefix + text;
-
-        public string Prefixed(string text)
-            => Prefix + text;
-
-        public BotConfig()
-        {
-            Version = 1;
-            var color = new ColorConfig();
-            Color = color;
-            DefaultLocale = new CultureInfo("en-US");
-            ConsoleOutputType = ConsoleOutputType.Normal;
-            ForwardMessages = false;
-            ForwardToAllOwners = false;
-            DmHelpText = @"{""description"": ""Type `%prefix%h` for help.""}";
-            HelpText = @"{
+    public BotConfig()
+    {
+        var color = new ColorConfig();
+        Color = color;
+        DefaultLocale = new("en-US");
+        ConsoleOutputType = ConsoleOutputType.Normal;
+        ForwardMessages = false;
+        ForwardToAllOwners = false;
+        DmHelpText = @"{""description"": ""Type `%prefix%h` for help.""}";
+        HelpText = @"{
   ""title"": ""To invite me to your server, use this link"",
   ""description"": ""https://discordapp.com/oauth2/authorize?client_id={0}&scope=bot&permissions=66186303"",
   ""color"": 53380,
@@ -122,51 +115,71 @@ See RotatingStatuses submodule in Administration.")]
     }
   ]
 }";
-            var blocked = new BlockedConfig();
-            Blocked = blocked;
-            Prefix = ".";
-            RotateStatuses = false;
-            GroupGreets = false;
-        }
-    }
-
-    [Cloneable]
-    public sealed partial class BlockedConfig
-    {
-        public HashSet<string> Commands { get; set; }
-        public HashSet<string> Modules { get; set; }
-
-        public BlockedConfig()
+        var blocked = new BlockedConfig();
+        Blocked = blocked;
+        Prefix = ".";
+        RotateStatuses = false;
+        GroupGreets = false;
+        DmHelpTextKeywords = new()
         {
-            Modules = new HashSet<string>();
-            Commands = new HashSet<string>();
-        }
+            "help",
+            "commands",
+            "cmds",
+            "module",
+            "can you do"
+        };
     }
 
-    [Cloneable]
-    public partial class ColorConfig
-    {
-        [Comment(@"Color used for embed responses when command successfully executes")]
-        public Rgba32 Ok { get; set; }
-        
-        [Comment(@"Color used for embed responses when command has an error")]
-        public Rgba32 Error { get; set; }
-        
-        [Comment(@"Color used for embed responses while command is doing work or is in progress")]
-        public Rgba32 Pending { get; set; }
+//         [Comment(@"Whether the prefix will be a suffix, or prefix.
+// For example, if your prefix is ! you will run a command called 'cash' by typing either
+// '!cash @Someone' if your prefixIsSuffix: false or
+// 'cash @Someone!' if your prefixIsSuffix: true")]
+//         public bool PrefixIsSuffix { get; set; }
 
-        public ColorConfig()
-        {
-            Ok = Rgba32.ParseHex("00e584");
-            Error = Rgba32.ParseHex("ee281f");
-            Pending = Rgba32.ParseHex("faa61a");
-        }
-    }
-    
-    public enum ConsoleOutputType
+    // public string Prefixed(string text) => PrefixIsSuffix
+    //     ? text + Prefix
+    //     : Prefix + text;
+
+    public string Prefixed(string text)
+        => Prefix + text;
+}
+
+[Cloneable]
+public sealed partial class BlockedConfig
+{
+    public HashSet<string> Commands { get; set; }
+    public HashSet<string> Modules { get; set; }
+
+    public BlockedConfig()
     {
-        Normal = 0,
-        Simple = 1,
-        None = 2,
+        Modules = new();
+        Commands = new();
     }
+}
+
+[Cloneable]
+public partial class ColorConfig
+{
+    [Comment(@"Color used for embed responses when command successfully executes")]
+    public Rgba32 Ok { get; set; }
+
+    [Comment(@"Color used for embed responses when command has an error")]
+    public Rgba32 Error { get; set; }
+
+    [Comment(@"Color used for embed responses while command is doing work or is in progress")]
+    public Rgba32 Pending { get; set; }
+
+    public ColorConfig()
+    {
+        Ok = Rgba32.ParseHex("00e584");
+        Error = Rgba32.ParseHex("ee281f");
+        Pending = Rgba32.ParseHex("faa61a");
+    }
+}
+
+public enum ConsoleOutputType
+{
+    Normal = 0,
+    Simple = 1,
+    None = 2
 }

src/NadekoBot/Common/Configs/IConfigSeria.cs

@@ -1,18 +1,18 @@
-namespace NadekoBot.Common.Configs
+namespace NadekoBot.Common.Configs;
+
+/// <summary>
+///     Base interface for available config serializers
+/// </summary>
+public interface IConfigSeria
 {
     /// <summary>
-    /// Base interface for available config serializers
+    ///     Serialize the object to string
     /// </summary>
-    public interface IConfigSeria
-    {
-        /// <summary>
-        /// Serialize the object to string 
-        /// </summary>
-        public string Serialize<T>(T obj);
-        
-        /// <summary>
-        /// Deserialize string data into an object of the specified type
-        /// </summary>
-        public T Deserialize<T>(string data);
-    }
+    public string Serialize<T>(T obj)
+        where T : notnull;
+
+    /// <summary>
+    ///     Deserialize string data into an object of the specified type
+    /// </summary>
+    public T Deserialize<T>(string data);
 }

src/NadekoBot/Common/Creds.cs

@@ -1,107 +1,90 @@
-using System.Collections.Generic;
+#nullable disable
 using NadekoBot.Common.Yml;
-using YamlDotNet.Serialization;
 
-namespace NadekoBot.Common
+namespace NadekoBot.Common;
+
+public sealed class Creds : IBotCredentials
 {
-    public sealed class Creds : IBotCredentials
-    {
-        public Creds()
-        {
-            Version = 1;
-            Token = string.Empty;
-            OwnerIds = new List<ulong>();
-            TotalShards = 1;
-            GoogleApiKey = string.Empty;
-            Votes = new(string.Empty, string.Empty);
-            Patreon = new(string.Empty, string.Empty, string.Empty, string.Empty);
-            BotListToken = string.Empty;
-            CleverbotApiKey = string.Empty;
-            RedisOptions = "localhost:6379,syncTimeout=30000,responseTimeout=30000,allowAdmin=true,password=";
-            Db = new()
-            {
-                Type = "sqlite",
-                ConnectionString = "Data Source=data/NadekoBot.db"
-            };
+    [Comment(@"DO NOT CHANGE")]
+    public int Version { get; set; }
 
-            CoordinatorUrl = "http://localhost:3442";
+    [Comment(@"Bot token. Do not share with anyone ever -> https://discordapp.com/developers/applications/")]
+    public string Token { get; set; }
 
-            RestartCommand = new()
-            {
-            };
-        }
-
-        [Comment(@"DO NOT CHANGE")]
-        public int Version { get; set; }
-        
-        [Comment(@"Bot token. Do not share with anyone ever -> https://discordapp.com/developers/applications/")]
-        public string Token { get; set; }
-
-        [Comment(@"List of Ids of the users who have bot owner permissions
+    [Comment(@"List of Ids of the users who have bot owner permissions
 **DO NOT ADD PEOPLE YOU DON'T TRUST**")]
-        public ICollection<ulong> OwnerIds { get; set; }
-        
-        [Comment(@"The number of shards that the bot will running on.
+    public ICollection<ulong> OwnerIds { get; set; }
+    
+    [Comment("Keep this on 'true' unless you're sure your bot shouldn't use privileged intents or you're waiting to be accepted")]
+    public bool UsePrivilegedIntents { get; set; }
+
+    [Comment(@"The number of shards that the bot will running on.
 Leave at 1 if you don't know what you're doing.")]
-        public int TotalShards { get; set; }
-        
-        [Comment(@"Login to https://console.cloud.google.com, create a new project, go to APIs & Services -> Library -> YouTube Data API and enable it.
+    public int TotalShards { get; set; }
+
+    [Comment(   
+        @"Login to https://console.cloud.google.com, create a new project, go to APIs & Services -> Library -> YouTube Data API and enable it.
 Then, go to APIs and Services -> Credentials and click Create credentials -> API key.
 Used only for Youtube Data Api (at the moment).")]
-        public string GoogleApiKey { get; set; }
-        
-        [Comment(@"Settings for voting system for discordbots. Meant for use on global Nadeko.")]
-        public VotesSettings Votes { get; set; }
-        
-        [Comment(@"Patreon auto reward system settings.
+    public string GoogleApiKey { get; set; }
+
+    [Comment(@"Settings for voting system for discordbots. Meant for use on global Nadeko.")]
+    public VotesSettings Votes { get; set; }
+
+    [Comment(@"Patreon auto reward system settings.
 go to https://www.patreon.com/portal -> my clients -> create client")]
-        public PatreonSettings Patreon { get; set; }
-        
-        [Comment(@"Api key for sending stats to DiscordBotList.")]
-        public string BotListToken { get; set; }
-        
-        [Comment(@"Official cleverbot api key.")]
-        public string CleverbotApiKey { get; set; }
-        
-        [Comment(@"Redis connection string. Don't change if you don't know what you're doing.")]
-        public string RedisOptions { get; set; }
-        
-        [Comment(@"Database options. Don't change if you don't know what you're doing. Leave null for default values")]
-        public DbOptions Db { get; set; }
+    public PatreonSettings Patreon { get; set; }
 
-        [Comment(@"Address and port of the coordinator endpoint. Leave empty for default.
+    [Comment(@"Api key for sending stats to DiscordBotList.")]
+    public string BotListToken { get; set; }
+
+    [Comment(@"Official cleverbot api key.")]
+    public string CleverbotApiKey { get; set; }
+
+    [Comment(@"Redis connection string. Don't change if you don't know what you're doing.")]
+    public string RedisOptions { get; set; }
+
+    [Comment(@"Database options. Don't change if you don't know what you're doing. Leave null for default values")]
+    public DbOptions Db { get; set; }
+
+    [Comment(@"Address and port of the coordinator endpoint. Leave empty for default.
 Change only if you've changed the coordinator address or port.")]
-        public string CoordinatorUrl { get; set; }
-        
-        [YamlIgnore]
-        public string PatreonCampaignId => Patreon?.CampaignId;
-        [YamlIgnore]
-        public string PatreonAccessToken => Patreon?.AccessToken;
+    public string CoordinatorUrl { get; set; }
 
-        [YamlIgnore]
-        public string VotesUrl => Votes?.Url;
-        [YamlIgnore]
-        public string VotesToken => Votes.Key;
-        
-        [Comment(@"Api key obtained on https://rapidapi.com (go to MyApps -> Add New App -> Enter Name -> Application key)")]
-        public string RapidApiKey { get; set; }
+    [Comment(
+        @"Api key obtained on https://rapidapi.com (go to MyApps -> Add New App -> Enter Name -> Application key)")]
+    public string RapidApiKey { get; set; }
 
-        [Comment(@"https://locationiq.com api key (register and you will receive the token in the email).
+    [Comment(@"https://locationiq.com api key (register and you will receive the token in the email).
 Used only for .time command.")]
-        public string LocationIqApiKey { get; set; }
+    public string LocationIqApiKey { get; set; }
 
-        [Comment(@"https://timezonedb.com api key (register and you will receive the token in the email).
+    [Comment(@"https://timezonedb.com api key (register and you will receive the token in the email).
 Used only for .time command")]
-        public string TimezoneDbApiKey { get; set; }
+    public string TimezoneDbApiKey { get; set; }
 
-        [Comment(@"https://pro.coinmarketcap.com/account/ api key. There is a free plan for personal use.
+    [Comment(@"https://pro.coinmarketcap.com/account/ api key. There is a free plan for personal use.
 Used for cryptocurrency related commands.")]
-        public string CoinmarketcapApiKey { get; set; }
-        
-        [Comment(@"Api key used for Osu related commands. Obtain this key at https://osu.ppy.sh/p/api")]
-        public string OsuApiKey { get; set; }
+    public string CoinmarketcapApiKey { get; set; }
+    
+//     [Comment(@"https://polygon.io/dashboard/api-keys api key. Free plan allows for 5 queries per minute.
+// Used for stocks related commands.")]
+//     public string PolygonIoApiKey { get; set; }
 
-        [Comment(@"Command and args which will be used to restart the bot.
+    [Comment(@"Api key used for Osu related commands. Obtain this key at https://osu.ppy.sh/p/api")]
+    public string OsuApiKey { get; set; }
+
+    [Comment(@"Optional Trovo client id.
+You should use this if Trovo stream notifications stopped working or you're getting ratelimit errors.")]
+    public string TrovoClientId { get; set; }
+
+    [Comment(@"Obtain by creating an application at https://dev.twitch.tv/console/apps")]
+    public string TwitchClientId { get; set; }
+
+    [Comment(@"Obtain by creating an application at https://dev.twitch.tv/console/apps")]
+    public string TwitchClientSecret { get; set; }
+
+    [Comment(@"Command and args which will be used to restart the bot.
 Only used if bot is executed directly (NOT through the coordinator)
 placeholders: 
     {0} -> shard id 
@@ -112,95 +95,104 @@ Linux default
 Windows default
     cmd: NadekoBot.exe
     args: {0}")]
-        public RestartConfig RestartCommand { get; set; }
+    public RestartConfig RestartCommand { get; set; }
 
-
-        public class DbOptions
+    public Creds()
+    {
+        Version = 4;
+        Token = string.Empty;
+        UsePrivilegedIntents = true;
+        OwnerIds = new List<ulong>();
+        TotalShards = 1;
+        GoogleApiKey = string.Empty;
+        Votes = new(string.Empty, string.Empty, string.Empty, string.Empty);
+        Patreon = new(string.Empty, string.Empty, string.Empty, string.Empty);
+        BotListToken = string.Empty;
+        CleverbotApiKey = string.Empty;
+        RedisOptions = "localhost:6379,syncTimeout=30000,responseTimeout=30000,allowAdmin=true,password=";
+        Db = new()
         {
-            [Comment(@"Database type. Only sqlite supported atm")]
-            public string Type { get; set; }
-            [Comment(@"Connection string. Will default to ""Data Source=data/NadekoBot.db""")]
-            public string ConnectionString { get; set; }
-         }
+            Type = "sqlite",
+            ConnectionString = "Data Source=data/NadekoBot.db"
+        };
 
-        // todo fixup patreon
-        public sealed record PatreonSettings
+        CoordinatorUrl = "http://localhost:3442";
+
+        RestartCommand = new();
+    }
+
+
+    public class DbOptions
+    {
+        [Comment(@"Database type. Only sqlite supported atm")]
+        public string Type { get; set; }
+
+        [Comment(@"Connection string. Will default to ""Data Source=data/NadekoBot.db""")]
+        public string ConnectionString { get; set; }
+    }
+
+    public sealed record PatreonSettings
+    {
+        public string ClientId { get; set; }
+        public string AccessToken { get; set; }
+        public string RefreshToken { get; set; }
+        public string ClientSecret { get; set; }
+
+        [Comment(
+            @"Campaign ID of your patreon page. Go to your patreon page (make sure you're logged in) and type ""prompt('Campaign ID', window.patreon.bootstrap.creator.data.id);"" in the console. (ctrl + shift + i)")]
+        public string CampaignId { get; set; }
+
+        public PatreonSettings(
+            string accessToken,
+            string refreshToken,
+            string clientSecret,
+            string campaignId)
         {
-            [Comment(@"Access token. You have to manually update this 1st of each month by refreshing the token on https://patreon.com/portal")]
-            public string AccessToken { get; set; }
-            [Comment(@"Unused atm")]
-            public string RefreshToken { get; set; }
-            [Comment(@"Unused atm")]
-            public string ClientSecret { get; set; }
-
-            [Comment(@"Campaign ID of your patreon page. Go to your patreon page (make sure you're logged in) and type ""prompt('Campaign ID', window.patreon.bootstrap.creator.data.id);"" in the console. (ctrl + shift + i)")]
-            public string CampaignId { get; set; }
-
-            public PatreonSettings(string accessToken, string refreshToken, string clientSecret, string campaignId)
-            {
-                AccessToken = accessToken;
-                RefreshToken = refreshToken;
-                ClientSecret = clientSecret;
-                CampaignId = campaignId;
-            }
+            AccessToken = accessToken;
+            RefreshToken = refreshToken;
+            ClientSecret = clientSecret;
+            CampaignId = campaignId;
         }
 
-        public sealed record VotesSettings
+        public PatreonSettings()
         {
-            [Comment(@"")]
-            public string Url { get; set; }
-            [Comment(@"")]
-            public string Key { get; set; }
-
-            public VotesSettings(string url, string key)
-            {
-                Url = url;
-                Key = key;
-            }
-        }
-
-        public class Old
-        {
-            public string Token { get; set; } = string.Empty;
-            public ulong[] OwnerIds { get; set; } = new ulong[1];
-            public string LoLApiKey { get; set; } = string.Empty;
-            public string GoogleApiKey { get; set; } = string.Empty;
-            public string MashapeKey { get; set; } = string.Empty;
-            public string OsuApiKey { get; set; } = string.Empty;
-            public string SoundCloudClientId { get; set; } = string.Empty;
-            public string CleverbotApiKey { get; set; } = string.Empty;
-            public string CarbonKey { get; set; } = string.Empty;
-            public int TotalShards { get; set; } = 1;
-            public string PatreonAccessToken { get; set; } = string.Empty;
-            public string PatreonCampaignId { get; set; } = "334038";
-            public RestartConfig RestartCommand { get; set; } = null;
-
-            public string ShardRunCommand { get; set; } = string.Empty;
-            public string ShardRunArguments { get; set; } = string.Empty;
-            public int? ShardRunPort { get; set; } = null;
-            public string MiningProxyUrl { get; set; } = string.Empty;
-            public string MiningProxyCreds { get; set; } = string.Empty;
-
-            public string BotListToken { get; set; } = string.Empty;
-            public string TwitchClientId { get; set; } = string.Empty;
-            public string VotesToken { get; set; } = string.Empty;
-            public string VotesUrl { get; set; } = string.Empty;
-            public string RedisOptions { get; set; } = string.Empty;
-            public string LocationIqApiKey { get; set; } = string.Empty;
-            public string TimezoneDbApiKey { get; set; } = string.Empty;
-            public string CoinmarketcapApiKey { get; set; } = string.Empty;
-
-            public class RestartConfig
-            {
-                public RestartConfig(string cmd, string args)
-                {
-                    this.Cmd = cmd;
-                    this.Args = args;
-                }
-
-                public string Cmd { get; set; }
-                public string Args { get; set; }
-            }
         }
     }
-}
+
+    public sealed record VotesSettings
+    {
+        [Comment(@"top.gg votes service url
+This is the url of your instance of the NadekoBot.Votes api
+Example: https://votes.my.cool.bot.com")]
+        public string TopggServiceUrl { get; set; }
+
+        [Comment(@"Authorization header value sent to the TopGG service url with each request
+This should be equivalent to the TopggKey in your NadekoBot.Votes api appsettings.json file")]
+        public string TopggKey { get; set; }
+
+        [Comment(@"discords.com votes service url
+This is the url of your instance of the NadekoBot.Votes api
+Example: https://votes.my.cool.bot.com")]
+        public string DiscordsServiceUrl { get; set; }
+
+        [Comment(@"Authorization header value sent to the Discords service url with each request
+This should be equivalent to the DiscordsKey in your NadekoBot.Votes api appsettings.json file")]
+        public string DiscordsKey { get; set; }
+
+        public VotesSettings()
+        {
+        }
+
+        public VotesSettings(
+            string topggServiceUrl,
+            string topggKey,
+            string discordsServiceUrl,
+            string discordsKey)
+        {
+            TopggServiceUrl = topggServiceUrl;
+            TopggKey = topggKey;
+            DiscordsServiceUrl = discordsServiceUrl;
+            DiscordsKey = discordsKey;
+        }
+    }
+}

src/NadekoBot/Common/DownloadTracker.cs

@@ -1,43 +1,38 @@
-using NadekoBot.Services;
-using System;
-using System.Collections.Concurrent;
-using System.Threading;
-using System.Threading.Tasks;
-using Discord;
+#nullable disable
+namespace NadekoBot.Common;
 
-namespace NadekoBot.Common
+public class DownloadTracker : INService
 {
-    public class DownloadTracker : INService
+    private ConcurrentDictionary<ulong, DateTime> LastDownloads { get; } = new();
+    private readonly SemaphoreSlim _downloadUsersSemaphore = new(1, 1);
+
+    /// <summary>
+    ///     Ensures all users on the specified guild were downloaded within the last hour.
+    /// </summary>
+    /// <param name="guild">Guild to check and potentially download users from</param>
+    /// <returns>Task representing download state</returns>
+    public async Task EnsureUsersDownloadedAsync(IGuild guild)
     {
-        private ConcurrentDictionary<ulong, DateTime> LastDownloads { get; } = new ConcurrentDictionary<ulong, DateTime>();
-        private SemaphoreSlim downloadUsersSemaphore = new SemaphoreSlim(1, 1);
-
-        /// <summary>
-        /// Ensures all users on the specified guild were downloaded within the last hour. 
-        /// </summary>
-        /// <param name="guild">Guild to check and potentially download users from</param>
-        /// <returns>Task representing download state</returns>
-        public async Task EnsureUsersDownloadedAsync(IGuild guild)
+#if GLOBAL_NADEKO
+        return;
+#endif
+        await _downloadUsersSemaphore.WaitAsync();
+        try
         {
-            await downloadUsersSemaphore.WaitAsync();
-            try
-            {
-                var now = DateTime.UtcNow;
+            var now = DateTime.UtcNow;
 
-                // download once per hour at most
-                var added = LastDownloads.AddOrUpdate(
-                    guild.Id,
-                    now,
-                    (key, old) => (now - old) > TimeSpan.FromHours(1) ? now : old);
+            // download once per hour at most
+            var added = LastDownloads.AddOrUpdate(guild.Id,
+                now,
+                (_, old) => now - old > TimeSpan.FromHours(1) ? now : old);
 
-                // means that this entry was just added - download the users
-                if (added == now)
-                    await guild.DownloadUsersAsync();
-            }
-            finally
-            {
-                downloadUsersSemaphore.Release();
-            }
+            // means that this entry was just added - download the users
+            if (added == now)
+                await guild.DownloadUsersAsync();
+        }
+        finally
+        {
+            _downloadUsersSemaphore.Release();
         }
     }
-}
+}

src/NadekoBot/Common/Extensions/IBotCredentialsExtensions.cs

@@ -1,11 +0,0 @@
-using Discord;
-using NadekoBot.Common;
-
-namespace NadekoBot.Extensions
-{
-    public static class BotCredentialsExtensions
-    {
-        public static bool IsOwner(this IBotCredentials creds, IUser user)
-            => creds.OwnerIds.Contains(user.Id);
-    }
-}

src/NadekoBot/Common/Extensions/ServiceCollectionExtensions.cs

@@ -1,77 +0,0 @@
-using System;
-using System.Linq;
-using System.Reflection;
-using Microsoft.Extensions.DependencyInjection;
-using NadekoBot.Common;
-using NadekoBot.Modules.Music;
-using NadekoBot.Services;
-using NadekoBot.Modules.Administration.Services;
-using NadekoBot.Modules.Music.Resolvers;
-using NadekoBot.Modules.Music.Services;
-using StackExchange.Redis;
-
-namespace NadekoBot.Extensions
-{
-    public static class ServiceCollectionExtensions
-    {
-        public static IServiceCollection AddBotStringsServices(this IServiceCollection services)
-            => services
-                .AddSingleton<IStringsSource, LocalFileStringsSource>()
-                .AddSingleton<IBotStringsProvider, LocalBotStringsProvider>()
-                .AddSingleton<IBotStrings, BotStrings>();
-
-        public static IServiceCollection AddConfigServices(this IServiceCollection services)
-        {
-            var baseType = typeof(ConfigServiceBase<>);
-
-            foreach (var type in Assembly.GetCallingAssembly().ExportedTypes.Where(x => x.IsSealed))
-            {
-                if (type.BaseType?.IsGenericType == true && type.BaseType.GetGenericTypeDefinition() == baseType)
-                {
-                    services.AddSingleton(type);
-                    services.AddSingleton(x => (IConfigService)x.GetRequiredService(type));
-                }
-            }
-
-            return services;
-        }
-
-        public static IServiceCollection AddConfigMigrators(this IServiceCollection services)
-            => services.AddSealedSubclassesOf(typeof(IConfigMigrator));
-
-        public static IServiceCollection AddMusic(this IServiceCollection services)
-            => services
-                .AddSingleton<IMusicService, MusicService>()
-                .AddSingleton<ITrackResolveProvider, TrackResolveProvider>()
-                .AddSingleton<IYoutubeResolver, YtdlYoutubeResolver>()
-                .AddSingleton<ISoundcloudResolver, SoundcloudResolver>()
-                .AddSingleton<ILocalTrackResolver, LocalTrackResolver>()
-                .AddSingleton<IRadioResolver, RadioResolver>()
-                .AddSingleton<ITrackCacher, RedisTrackCacher>()
-                .AddSingleton<YtLoader>()
-                .AddSingleton<IPlaceholderProvider>(svc => svc.GetRequiredService<IMusicService>());
-        
-        // consider using scrutor, because slightly different versions
-        // of this might be needed in several different places
-        public static IServiceCollection AddSealedSubclassesOf(this IServiceCollection services, Type baseType)
-        {
-            var subTypes = Assembly.GetCallingAssembly()
-                .ExportedTypes
-                .Where(type => type.IsSealed && baseType.IsAssignableFrom(type));
-
-            foreach (var subType in subTypes)
-            {
-                services.AddSingleton(baseType, subType);
-            }
-
-            return services;
-        }
-
-        public static IServiceCollection AddRedis(this IServiceCollection services, string redisOptions)
-        {
-            var conf = ConfigurationOptions.Parse(redisOptions);
-            services.AddSingleton(ConnectionMultiplexer.Connect(conf));
-            return services;
-        }
-    }
-}

src/NadekoBot/Common/GuildPerm.cs

@@ -1,255 +0,0 @@
-using System;
-
-namespace Discord
-{
-    // just a copy paste from discord.net in order to rename it, for compatibility iwth v3 which is gonna use custom lib
-
-
-    // Summary:
-    //     Defines the available permissions for a channel.
-    [Flags]
-    public enum GuildPerm : ulong
-    {
-        //
-        // Summary:
-        //     Allows creation of instant invites.
-        CreateInstantInvite = 1,
-        //
-        // Summary:
-        //     Allows kicking members.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        KickMembers = 2,
-        //
-        // Summary:
-        //     Allows banning members.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        BanMembers = 4,
-        //
-        // Summary:
-        //     Allows all permissions and bypasses channel permission overwrites.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        Administrator = 8,
-        //
-        // Summary:
-        //     Allows management and editing of channels.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        ManageChannels = 16,
-        //
-        // Summary:
-        //     Allows management and editing of the guild.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        ManageGuild = 32,
-        //
-        // Summary:
-        //     Allows for the addition of reactions to messages.
-        AddReactions = 64,
-        //
-        // Summary:
-        //     Allows for viewing of audit logs.
-        ViewAuditLog = 128,
-        PrioritySpeaker = 256,
-        ReadMessages = 1024,
-        ViewChannel = 1024,
-        SendMessages = 2048,
-        //
-        // Summary:
-        //     Allows for sending of text-to-speech messages.
-        SendTTSMessages = 4096,
-        //
-        // Summary:
-        //     Allows for deletion of other users messages.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        ManageMessages = 8192,
-        //
-        // Summary:
-        //     Allows links sent by users with this permission will be auto-embedded.
-        EmbedLinks = 16384,
-        //
-        // Summary:
-        //     Allows for uploading images and files.
-        AttachFiles = 32768,
-        //
-        // Summary:
-        //     Allows for reading of message history.
-        ReadMessageHistory = 65536,
-        //
-        // Summary:
-        //     Allows for using the @everyone tag to notify all users in a channel, and the
-        //     @here tag to notify all online users in a channel.
-        MentionEveryone = 131072,
-        //
-        // Summary:
-        //     Allows the usage of custom emojis from other servers.
-        UseExternalEmojis = 262144,
-        //
-        // Summary:
-        //     Allows for joining of a voice channel.
-        Connect = 1048576,
-        //
-        // Summary:
-        //     Allows for speaking in a voice channel.
-        Speak = 2097152,
-        //
-        // Summary:
-        //     Allows for muting members in a voice channel.
-        MuteMembers = 4194304,
-        //
-        // Summary:
-        //     Allows for deafening of members in a voice channel.
-        DeafenMembers = 8388608,
-        //
-        // Summary:
-        //     Allows for moving of members between voice channels.
-        MoveMembers = 16777216,
-        //
-        // Summary:
-        //     Allows for using voice-activity-detection in a voice channel.
-        UseVAD = 33554432,
-        //
-        // Summary:
-        //     Allows for modification of own nickname.
-        ChangeNickname = 67108864,
-        //
-        // Summary:
-        //     Allows for modification of other users nicknames.
-        ManageNicknames = 134217728,
-        //
-        // Summary:
-        //     Allows management and editing of roles.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        ManageRoles = 268435456,
-        //
-        // Summary:
-        //     Allows management and editing of webhooks.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        ManageWebhooks = 536870912,
-        //
-        // Summary:
-        //     Allows management and editing of emojis.
-        //
-        // Remarks:
-        //     This permission requires the owner account to use two-factor authentication when
-        //     used on a guild that has server-wide 2FA enabled.
-        ManageEmojis = 1073741824
-    }
-
-    //
-    // Summary:
-    //     Defines the available permissions for a channel.
-    [Flags]
-    public enum ChannelPerm : ulong
-    {
-        //
-        // Summary:
-        //     Allows creation of instant invites.
-        CreateInstantInvite = 1,
-        //
-        // Summary:
-        //     Allows management and editing of channels.
-        ManageChannel = 16,
-        //
-        // Summary:
-        //     Allows for the addition of reactions to messages.
-        AddReactions = 64,
-        PrioritySpeaker = 256,
-        //
-        // Summary:
-        //     Allows for reading of messages. This flag is obsolete, use Discord.ChannelPermission.ViewChannel
-        //     instead.
-        ReadMessages = 1024,
-        //
-        // Summary:
-        //     Allows guild members to view a channel, which includes reading messages in text
-        //     channels.
-        ViewChannel = 1024,
-        //
-        // Summary:
-        //     Allows for sending messages in a channel.
-        SendMessages = 2048,
-        //
-        // Summary:
-        //     Allows for sending of text-to-speech messages.
-        SendTTSMessages = 4096,
-        //
-        // Summary:
-        //     Allows for deletion of other users messages.
-        ManageMessages = 8192,
-        //
-        // Summary:
-        //     Allows links sent by users with this permission will be auto-embedded.
-        EmbedLinks = 16384,
-        //
-        // Summary:
-        //     Allows for uploading images and files.
-        AttachFiles = 32768,
-        //
-        // Summary:
-        //     Allows for reading of message history.
-        ReadMessageHistory = 65536,
-        //
-        // Summary:
-        //     Allows for using the @everyone tag to notify all users in a channel, and the
-        //     @here tag to notify all online users in a channel.
-        MentionEveryone = 131072,
-        //
-        // Summary:
-        //     Allows the usage of custom emojis from other servers.
-        UseExternalEmojis = 262144,
-        //
-        // Summary:
-        //     Allows for joining of a voice channel.
-        Connect = 1048576,
-        //
-        // Summary:
-        //     Allows for speaking in a voice channel.
-        Speak = 2097152,
-        //
-        // Summary:
-        //     Allows for muting members in a voice channel.
-        MuteMembers = 4194304,
-        //
-        // Summary:
-        //     Allows for deafening of members in a voice channel.
-        DeafenMembers = 8388608,
-        //
-        // Summary:
-        //     Allows for moving of members between voice channels.
-        MoveMembers = 16777216,
-        //
-        // Summary:
-        //     Allows for using voice-activity-detection in a voice channel.
-        UseVAD = 33554432,
-        //
-        // Summary:
-        //     Allows management and editing of roles.
-        ManageRoles = 268435456,
-        //
-        // Summary:
-        //     Allows management and editing of webhooks.
-        ManageWebhooks = 536870912
-    }
-}

src/NadekoBot/Common/Helpers.cs

@@ -1,15 +1,13 @@
-using System;
+#nullable disable
+namespace NadekoBot.Common;
 
-namespace NadekoBot.Common
+public static class Helpers
 {
-    public static class Helpers
+    public static void ReadErrorAndExit(int exitCode)
     {
-        public static void ReadErrorAndExit(int exitCode)
-        {
-            if (!Console.IsInputRedirected)
-                Console.ReadKey();
-            
-            Environment.Exit(exitCode);
-        }
+        if (!Console.IsInputRedirected)
+            Console.ReadKey();
+
+        Environment.Exit(exitCode);
     }
 }

src/NadekoBot/Common/IBotCredentials.cs

@@ -1,38 +1,34 @@
-using System.Collections.Generic;
-using Discord;
-using System.Collections.Immutable;
-using System.Linq;
-using NadekoBot.Common;
+#nullable disable
+namespace NadekoBot;
 
-namespace NadekoBot
+public interface IBotCredentials
 {
-    public interface IBotCredentials
-    {
-        string Token { get; }
-        string GoogleApiKey { get; }
-        ICollection<ulong> OwnerIds { get; }
-        string RapidApiKey { get; }
-        string PatreonAccessToken { get; }
+    string Token { get; }
+    string GoogleApiKey { get; }
+    ICollection<ulong> OwnerIds { get; }
+    bool UsePrivilegedIntents { get; }
+    string RapidApiKey { get; }
 
-        Creds.DbOptions Db { get; }
-        string OsuApiKey { get; }
-        int TotalShards { get; }
-        string PatreonCampaignId { get; }
-        string CleverbotApiKey { get; }
-        RestartConfig RestartCommand { get; }
-        string VotesUrl { get; }
-        string VotesToken { get; }
-        string BotListToken { get; }
-        string RedisOptions { get; }
-        string LocationIqApiKey { get; }
-        string TimezoneDbApiKey { get; }
-        string CoinmarketcapApiKey { get; }
-        string CoordinatorUrl { get; set; }
-    }
-    
-    public class RestartConfig
-    {
-        public string Cmd { get; set; }
-        public string Args { get; set; }
-    }
+    Creds.DbOptions Db { get; }
+    string OsuApiKey { get; }
+    int TotalShards { get; }
+    Creds.PatreonSettings Patreon { get; }
+    string CleverbotApiKey { get; }
+    RestartConfig RestartCommand { get; }
+    Creds.VotesSettings Votes { get; }
+    string BotListToken { get; }
+    string RedisOptions { get; }
+    string LocationIqApiKey { get; }
+    string TimezoneDbApiKey { get; }
+    string CoinmarketcapApiKey { get; }
+    string TrovoClientId { get; }
+    string CoordinatorUrl { get; set; }
+    string TwitchClientId { get; set; }
+    string TwitchClientSecret { get; set; }
 }
+
+public class RestartConfig
+{
+    public string Cmd { get; set; }
+    public string Args { get; set; }
+}

src/NadekoBot/Common/ICloneable.cs

@@ -1,7 +1,8 @@
-namespace NadekoBot.Common
+#nullable disable
+namespace NadekoBot.Common;
+
+public interface ICloneable<T>
+    where T : new()
 {
-    public interface ICloneable<T> where T : new()
-    {
-        public T Clone();
-    }
+    public T Clone();
 }

src/NadekoBot/Common/IEmbedBuilder.cs

@@ -1,25 +1,23 @@
-using Discord;
+#nullable disable
+namespace NadekoBot;
 
-namespace NadekoBot
+public interface IEmbedBuilder
 {
-    public interface IEmbedBuilder
-    {
-        IEmbedBuilder WithDescription(string desc);
-        IEmbedBuilder WithTitle(string title);
-        IEmbedBuilder AddField(string title, object value, bool isInline = false);
-        IEmbedBuilder WithFooter(string text, string iconUrl = null);
-        IEmbedBuilder WithAuthor(string name, string iconUrl = null, string url = null);
-        IEmbedBuilder WithColor(EmbedColor color);
-        Embed Build();
-        IEmbedBuilder WithUrl(string url);
-        IEmbedBuilder WithImageUrl(string url);
-        IEmbedBuilder WithThumbnailUrl(string url);
-    }
+    IEmbedBuilder WithDescription(string desc);
+    IEmbedBuilder WithTitle(string title);
+    IEmbedBuilder AddField(string title, object value, bool isInline = false);
+    IEmbedBuilder WithFooter(string text, string iconUrl = null);
+    IEmbedBuilder WithAuthor(string name, string iconUrl = null, string url = null);
+    IEmbedBuilder WithColor(EmbedColor color);
+    Embed Build();
+    IEmbedBuilder WithUrl(string url);
+    IEmbedBuilder WithImageUrl(string url);
+    IEmbedBuilder WithThumbnailUrl(string url);
+}
 
-    public enum EmbedColor
-    {
-        Ok,
-        Pending,
-        Error,
-    }
+public enum EmbedColor
+{
+    Ok,
+    Pending,
+    Error
 }

src/NadekoBot/Common/ILogCommandService.cs

@@ -0,0 +1,31 @@
+using NadekoBot.Services.Database.Models;
+
+namespace NadekoBot.Common;
+
+public interface ILogCommandService
+{
+    void AddDeleteIgnore(ulong xId);
+    Task LogServer(ulong guildId, ulong channelId, bool actionValue);
+    bool LogIgnore(ulong guildId, ulong itemId, IgnoredItemType itemType);
+    LogSetting? GetGuildLogSettings(ulong guildId);
+    bool Log(ulong guildId, ulong? channelId, LogType type);
+}
+
+public enum LogType
+{
+    Other,
+    MessageUpdated,
+    MessageDeleted,
+    UserJoined,
+    UserLeft,
+    UserBanned,
+    UserUnbanned,
+    UserUpdated,
+    ChannelCreated,
+    ChannelDestroyed,
+    ChannelUpdated,
+    UserPresence,
+    VoicePresence,
+    VoicePresenceTts,
+    UserMuted
+}

src/NadekoBot/Common/INadekoCommandOptions.cs

@@ -1,7 +1,7 @@
-namespace NadekoBot.Common
+#nullable disable
+namespace NadekoBot.Common;
+
+public interface INadekoCommandOptions
 {
-    public interface INadekoCommandOptions
-    {
-        void NormalizeOptions();
-    }
-}
+    void NormalizeOptions();
+}

src/NadekoBot/Common/IPlaceholderProvider.cs

@@ -1,10 +1,7 @@
-using System;
-using System.Collections.Generic;
+#nullable disable
+namespace NadekoBot.Common;
 
-namespace NadekoBot.Common
+public interface IPlaceholderProvider
 {
-    public interface IPlaceholderProvider
-    {
-        public IEnumerable<(string Name, Func<string> Func)> GetPlaceholders();
-    }
+    public IEnumerable<(string Name, Func<string> Func)> GetPlaceholders();
 }

src/NadekoBot/Common/ImageUrls.cs

@@ -1,49 +1,49 @@
-using System;
+#nullable disable
+using NadekoBot.Common.Yml;
 
-namespace NadekoBot.Common
+namespace NadekoBot.Common;
+
+public class ImageUrls
 {
-    public class ImageUrls
+    [Comment("DO NOT CHANGE")]
+    public int Version { get; set; } = 3;
+
+    public CoinData Coins { get; set; }
+    public Uri[] Currency { get; set; }
+    public Uri[] Dice { get; set; }
+    public RategirlData Rategirl { get; set; }
+    public XpData Xp { get; set; }
+
+    //new
+    public RipData Rip { get; set; }
+    public SlotData Slots { get; set; }
+
+    public class RipData
     {
-        public int Version { get; set; } = 2;
-
-        public CoinData Coins { get; set; }
-        public Uri[] Currency { get; set; }
-        public Uri[] Dice { get; set; }
-        public RategirlData Rategirl { get; set; }
-        public XpData Xp { get; set; }
-
-        //new
-        public RipData Rip { get; set; }
-        public SlotData Slots { get; set; }
-
-        public class RipData
-        {
-            public Uri Bg { get; set; }
-            public Uri Overlay { get; set; }
-        }
-
-        public class SlotData
-        {
-            public Uri[] Emojis { get; set; }
-            public Uri[] Numbers { get; set; }
-            public Uri Bg { get; set; }
-        }
-
-        public class CoinData
-        {
-            public Uri[] Heads { get; set; }
-            public Uri[] Tails { get; set; }
-        }
-
-        public class RategirlData
-        {
-            public Uri Matrix { get; set; }
-            public Uri Dot { get; set; }
-        }
-
-        public class XpData
-        {
-            public Uri Bg { get; set; }
-        }
+        public Uri Bg { get; set; }
+        public Uri Overlay { get; set; }
     }
-}
+
+    public class SlotData
+    {
+        public Uri[] Emojis { get; set; }
+        public Uri Bg { get; set; }
+    }
+
+    public class CoinData
+    {
+        public Uri[] Heads { get; set; }
+        public Uri[] Tails { get; set; }
+    }
+
+    public class RategirlData
+    {
+        public Uri Matrix { get; set; }
+        public Uri Dot { get; set; }
+    }
+
+    public class XpData
+    {
+        public Uri Bg { get; set; }
+    }
+}

src/NadekoBot/Common/JsonConverters/CultureInfoConverter.cs

@@ -0,0 +1,14 @@
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NadekoBot.Common.JsonConverters;
+
+public class CultureInfoConverter : JsonConverter<CultureInfo>
+{
+    public override CultureInfo Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        => new(reader.GetString() ?? "en-US");
+
+    public override void Write(Utf8JsonWriter writer, CultureInfo value, JsonSerializerOptions options)
+        => writer.WriteStringValue(value.Name);
+}

src/NadekoBot/Common/JsonConverters/Rbga32Converter.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Globalization;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace NadekoBot.Common.JsonConverters
-{
-    public class Rgba32Converter : JsonConverter<Rgba32>
-    {
-        public override Rgba32 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-        {
-            return Rgba32.ParseHex(reader.GetString());
-        }
-
-        public override void Write(Utf8JsonWriter writer, Rgba32 value, JsonSerializerOptions options)
-        {
-            writer.WriteStringValue(value.ToHex());
-        }
-    }
-    
-    public class CultureInfoConverter : JsonConverter<CultureInfo>
-    {
-        public override CultureInfo Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-        {
-            return new CultureInfo(reader.GetString());
-        }
-
-        public override void Write(Utf8JsonWriter writer, CultureInfo value, JsonSerializerOptions options)
-        {
-            writer.WriteStringValue(value.Name);
-        }
-    }
-}

src/NadekoBot/Common/JsonConverters/Rgba32Converter.cs

@@ -0,0 +1,14 @@
+using SixLabors.ImageSharp.PixelFormats;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NadekoBot.Common.JsonConverters;
+
+public class Rgba32Converter : JsonConverter<Rgba32>
+{
+    public override Rgba32 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        => Rgba32.ParseHex(reader.GetString());
+
+    public override void Write(Utf8JsonWriter writer, Rgba32 value, JsonSerializerOptions options)
+        => writer.WriteStringValue(value.ToHex());
+}

src/NadekoBot/Common/Kwum.cs

@@ -1,98 +1,101 @@
-using System;
+#nullable disable
 using System.Runtime.CompilerServices;
 
-namespace NadekoBot.Common
+namespace NadekoBot.Common;
+
+// needs proper invalid input check (character array input out of range)
+// needs negative number support
+// ReSharper disable once InconsistentNaming
+#pragma warning disable IDE1006
+public readonly struct kwum : IEquatable<kwum>
+#pragma warning restore IDE1006
 {
-    // needs proper invalid input check (character array input out of range)
-    // needs negative number support
-    public readonly struct kwum : IEquatable<kwum>
+    private const string VALID_CHARACTERS = "23456789abcdefghijkmnpqrstuvwxyz";
+    private readonly int _value;
+
+    public kwum(int num)
+        => _value = num;
+
+    public kwum(in char c)
     {
-        private readonly int _value;
-        private const string ValidCharacters = "23456789abcdefghijkmnpqrstuvwxyz";
+        if (!IsValidChar(c))
+            throw new ArgumentException("Character needs to be a valid kwum character.", nameof(c));
 
-        public kwum(int num)
-            => _value = num;
-        
-        public kwum(in char c)
+        _value = InternalCharToValue(c);
+    }
+
+    public kwum(in ReadOnlySpan<char> input)
+    {
+        _value = 0;
+        for (var index = 0; index < input.Length; index++)
         {
+            var c = input[index];
             if (!IsValidChar(c))
-                throw new ArgumentException("Character needs to be a valid kwum character.", nameof(c));
+                throw new ArgumentException("All characters need to be a valid kwum characters.", nameof(input));
 
-            _value = InternalCharToValue(c);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int InternalCharToValue(in char c) 
-            => ValidCharacters.IndexOf(c);
-
-        public kwum(in ReadOnlySpan<char> input)
-        {;
-            _value = 0;
-            for (var index = 0; index < input.Length; index++)
-            {
-                var c = input[index];
-                if (!IsValidChar(c))
-                    throw new ArgumentException("All characters need to be a valid kwum characters.", nameof(input));
-
-                _value += ValidCharacters.IndexOf(c) * (int)Math.Pow(ValidCharacters.Length, input.Length - index - 1);
-            }
-        }
-
-        public static bool TryParse(in ReadOnlySpan<char> input, out kwum value)
-        {
-            value = default;
-            foreach(var c in input)
-                if (!IsValidChar(c))
-                    return false;
-
-            value = new kwum(input);
-            return true;
-        }
-
-        public static kwum operator +(kwum left, kwum right)
-            => new kwum(left._value + right._value);
-
-        public static bool operator ==(kwum left, kwum right)
-            => left._value == right._value;
-
-        public static bool operator !=(kwum left, kwum right)
-            => !(left == right);
-
-        public static implicit operator long(kwum kwum)
-            => kwum._value;
-        
-        public static implicit operator int(kwum kwum)
-            => kwum._value;
-        public static implicit operator kwum(int num)
-            => new kwum(num);
-
-        public static bool IsValidChar(char c)
-            => ValidCharacters.Contains(c);
-
-        public override string ToString()
-        {
-            var count = ValidCharacters.Length;
-            var localValue = _value;
-            var arrSize = (int)Math.Log(localValue, count) + 1;
-            Span<char> chars = new char[arrSize];
-            while (localValue > 0)
-            {
-                localValue = Math.DivRem(localValue, count, out var rem);
-                chars[--arrSize] = ValidCharacters[(int)rem];
-            }
-
-            return new string(chars);
-        }
-
-        public override bool Equals(object obj)
-            => obj is kwum kw && kw == this;
-
-        public bool Equals(kwum other)
-            => other == this;
-
-        public override int GetHashCode()
-        {
-            return _value.GetHashCode();
+            _value += VALID_CHARACTERS.IndexOf(c) * (int)Math.Pow(VALID_CHARACTERS.Length, input.Length - index - 1);
         }
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int InternalCharToValue(in char c)
+        => VALID_CHARACTERS.IndexOf(c);
+
+    public static bool TryParse(in ReadOnlySpan<char> input, out kwum value)
+    {
+        value = default;
+        foreach (var c in input)
+        {
+            if (!IsValidChar(c))
+                return false;
+        }
+
+        value = new(input);
+        return true;
+    }
+
+    public static kwum operator +(kwum left, kwum right)
+        => new(left._value + right._value);
+
+    public static bool operator ==(kwum left, kwum right)
+        => left._value == right._value;
+
+    public static bool operator !=(kwum left, kwum right)
+        => !(left == right);
+
+    public static implicit operator long(kwum kwum)
+        => kwum._value;
+
+    public static implicit operator int(kwum kwum)
+        => kwum._value;
+
+    public static implicit operator kwum(int num)
+        => new(num);
+
+    public static bool IsValidChar(char c)
+        => VALID_CHARACTERS.Contains(c);
+
+    public override string ToString()
+    {
+        var count = VALID_CHARACTERS.Length;
+        var localValue = _value;
+        var arrSize = (int)Math.Log(localValue, count) + 1;
+        Span<char> chars = new char[arrSize];
+        while (localValue > 0)
+        {
+            localValue = Math.DivRem(localValue, count, out var rem);
+            chars[--arrSize] = VALID_CHARACTERS[rem];
+        }
+
+        return new(chars);
+    }
+
+    public override bool Equals(object obj)
+        => obj is kwum kw && kw == this;
+
+    public bool Equals(kwum other)
+        => other == this;
+
+    public override int GetHashCode()
+        => _value.GetHashCode();
 }