.dockerignore

@@ -4,5 +4,5 @@ docker
 api_tests
 ansible
 tests
+.git
 *.sh
-pictrs

.drone.yml

@@ -0,0 +1,177 @@
+---
+kind: pipeline
+name: amd64
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+
+  - name: chown repo
+    image: ekidd/rust-musl-builder:1.47.0
+    user: root
+    commands:
+      - chown 1000:1000 . -R
+
+  - name: check formatting
+    image: rustdocker/rust:nightly
+    commands:
+      - /root/.cargo/bin/cargo fmt -- --check
+
+  - name: cargo clippy
+    image: ekidd/rust-musl-builder:1.47.0
+    commands:
+      - cargo clippy --workspace --tests --all-targets --all-features -- -D warnings -D deprecated -D clippy::perf -D clippy::complexity -D clippy::dbg_macro
+
+  - name: cargo test
+    image: ekidd/rust-musl-builder:1.47.0
+    environment:
+      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432/lemmy
+      RUST_BACKTRACE: 1
+      RUST_TEST_THREADS: 1
+    commands:
+      - sudo apt-get update
+      - sudo apt-get -y install --no-install-recommends espeak postgresql-client
+      - cargo test --workspace --no-fail-fast
+
+  - name: cargo build
+    image: ekidd/rust-musl-builder:1.47.0
+    commands:
+      - cargo build
+      - mv target/x86_64-unknown-linux-musl/debug/lemmy_server target/lemmy_server
+
+  - name: run federation tests
+    image: node:15-alpine3.12
+    environment:
+      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432
+      DO_WRITE_HOSTS_FILE: 1
+    commands:
+      - apk add bash curl postgresql-client
+      - bash api_tests/prepare-drone-federation-test.sh
+      - cd api_tests/
+      - yarn
+      - yarn api-test
+
+  - name: make release build and push to docker hub
+    image: plugins/docker
+    settings:
+      dockerfile: docker/prod/Dockerfile
+      username:
+        from_secret: docker_username
+      password:
+        from_secret: docker_password
+      repo: dessalines/lemmy
+      auto_tag: true
+      auto_tag_suffix: linux-amd64
+    when:
+      ref:
+      - refs/tags/*
+
+  - name: push to docker manifest
+    image: plugins/manifest
+    settings: 
+      username:
+        from_secret: docker_username
+      password:
+        from_secret: docker_password
+      target: "dessalines/lemmy:${DRONE_TAG}"
+      template: "dessalines/lemmy:${DRONE_TAG}-OS-ARCH"
+      platforms:
+        - linux/amd64
+        - linux/arm64
+      ignore_missing: true
+    when:
+      ref:
+      - refs/tags/*
+
+services:
+  - name: database
+    image: postgres:12-alpine
+    environment:
+      POSTGRES_USER: lemmy
+      POSTGRES_PASSWORD: password
+
+---
+kind: pipeline
+name: arm64
+
+platform:
+  os: linux
+  arch: arm64
+
+steps:
+
+  - name: cargo test
+    image: rust:1.47-slim-buster
+    environment:
+      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432/lemmy
+      RUST_BACKTRACE: 1
+      RUST_TEST_THREADS: 1
+    commands:
+      - apt-get update
+      - apt-get -y install --no-install-recommends espeak postgresql-client libssl-dev pkg-config libpq-dev
+      - cargo test --workspace --no-fail-fast
+      - cargo build
+
+  # Using Debian here because there seems to be no official Alpine-based Rust docker image for ARM.
+  - name: cargo build
+    image: rust:1.47-slim-buster
+    commands:
+      - apt-get update
+      - apt-get -y install --no-install-recommends libssl-dev pkg-config libpq-dev
+      - cargo build
+      - mv target/debug/lemmy_server target/lemmy_server
+
+  - name: run federation tests
+    image: node:15-buster-slim
+    environment:
+      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432
+      DO_WRITE_HOSTS_FILE: 1
+    commands:
+      - mkdir -p /usr/share/man/man1 /usr/share/man/man7
+      - apt-get update
+      - apt-get -y install --no-install-recommends bash curl libssl-dev pkg-config libpq-dev postgresql-client libc6-dev
+      - bash api_tests/prepare-drone-federation-test.sh
+      - cd api_tests/
+      - yarn
+      - yarn api-test
+
+  - name: make release build and push to docker hub
+    image: plugins/docker
+    settings:
+      dockerfile: docker/prod/Dockerfile.arm
+      username:
+        from_secret: docker_username
+      password:
+        from_secret: docker_password
+      repo: dessalines/lemmy
+      auto_tag: true
+      auto_tag_suffix: linux-arm64
+    when:
+      ref:
+        - refs/tags/*
+
+  - name: push to docker manifest
+    image: plugins/manifest
+    settings: 
+      username:
+        from_secret: docker_username
+      password:
+        from_secret: docker_password
+      target: "dessalines/lemmy:${DRONE_TAG}"
+      template: "dessalines/lemmy:${DRONE_TAG}-OS-ARCH"
+      platforms:
+        - linux/amd64
+        - linux/arm64
+      ignore_missing: true
+    when:
+      ref:
+      - refs/tags/*
+
+services:
+  - name: database
+    image: postgres:12-alpine
+    environment:
+      POSTGRES_USER: lemmy
+      POSTGRES_PASSWORD: password

.gitattributes

@@ -1,2 +0,0 @@
-# Normalize EOL for all files that Git considers text files.
-* text=auto eol=lf

.github/CODEOWNERS

@@ -1,3 +0,0 @@
-* @Nutomic @dessalines @phiresky @dullbananas @SleeplessOne1917
-crates/apub/ @Nutomic
-migrations/ @dessalines @phiresky @dullbananas

.github/ISSUE_TEMPLATE/BUG_REPORT.md

@@ -0,0 +1,29 @@
+---
+name: "\U0001F41E Bug Report"
+about: Create a report to help us improve Lemmy
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+Found a bug? Please fill out the sections below. 👍
+
+For front end issues, use [lemmy-ui](https://github.com/LemmyNet/lemmy-ui)
+
+### Issue Summary
+
+A summary of the bug.
+
+
+### Steps to Reproduce
+
+1. (for example) I clicked login, and an endless spinner show up.
+2. I tried to install lemmy via this guide, and I'm getting this error.
+3. ...
+
+### Technical details
+
+* Please post your log: `sudo docker-compose logs > lemmy_log.out`.
+* What OS are you trying to install lemmy on? 
+* Any browser console errors?

.github/ISSUE_TEMPLATE/BUG_REPORT.yml

@@ -1,70 +0,0 @@
-name: "\U0001F41E Bug Report"
-description: Create a report to help us improve lemmy
-title: "[Bug]: "
-labels: ["bug", "triage"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Found a bug? Please fill out the sections below. 👍
-        Thanks for taking the time to fill out this bug report!
-        For front end issues, use [lemmy](https://github.com/LemmyNet/lemmy-ui)
-  - type: checkboxes
-    attributes:
-      label: Requirements
-      description: Before you create a bug report please do the following.
-      options:
-        - label: Is this a bug report? For questions or discussions use https://lemmy.ml/c/lemmy_support
-          required: true
-        - label: Did you check to see if this issue already exists?
-          required: true
-        - label: Is this only a single bug? Do not put multiple bugs in one issue.
-          required: true
-        - label: Do you agree to follow the rules in our [Code of Conduct](https://join-lemmy.org/docs/code_of_conduct.html)?
-          required: true
-        - label: Is this a backend issue? Use the [lemmy-ui](https://github.com/LemmyNet/lemmy-ui) repo for UI / frontend issues.
-          required: true
-  - type: textarea
-    id: summary
-    attributes:
-      label: Summary
-      description: A summary of the bug.
-    validations:
-      required: true
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: Steps to Reproduce
-      description: |
-        Describe the steps to reproduce the bug.
-        The better your description is _(go 'here', click 'there'...)_ the fastest you'll get an _(accurate)_ resolution.
-      value: |
-        1.
-        2.
-        3.
-    validations:
-      required: true
-  - type: textarea
-    id: technical
-    attributes:
-      label: Technical Details
-      description: |
-        - Please post your log: `sudo docker-compose logs > lemmy_log.out`.
-        - What OS are you trying to install lemmy on?
-        - Any browser console errors?
-    validations:
-      required: true
-  - type: input
-    id: lemmy-backend-version
-    attributes:
-      label: Version
-      description: Which Lemmy backend version do you use? Displayed in the footer.
-      placeholder: ex. BE 0.17.4
-    validations:
-      required: true
-  - type: input
-    id: lemmy-instance
-    attributes:
-      label: Lemmy Instance URL
-      description: Which Lemmy instance do you use? The address
-      placeholder: lemmy.ml, lemmy.world, etc

.github/ISSUE_TEMPLATE/FEATURE_REQUEST.md

@@ -0,0 +1,44 @@
+---
+name: "\U0001F680 Feature request"
+about: Suggest an idea for improving Lemmy
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+For front end issues, use [lemmy-ui](https://github.com/LemmyNet/lemmy-ui)
+
+### Is your proposal related to a problem?
+
+<!--
+  Provide a clear and concise description of what the problem is.
+  For example, "I'm always frustrated when..."
+-->
+
+(Write your answer here.)
+
+### Describe the solution you'd like
+
+<!--
+  Provide a clear and concise description of what you want to happen.
+-->
+
+(Describe your proposed solution here.)
+
+### Describe alternatives you've considered
+
+<!--
+  Let us know about other solutions you've tried or researched.
+-->
+
+(Write your answer here.)
+
+### Additional context
+
+<!--
+  Is there anything else you can add about the proposal?
+  You might want to link to related issues here, if you haven't already.
+-->
+
+(Write your answer here.)

.github/ISSUE_TEMPLATE/FEATURE_REQUEST.yml

@@ -1,56 +0,0 @@
-name: "\U0001F680 Feature request"
-description: Suggest an idea for improving Lemmy
-labels: ["enhancement"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Have a suggestion about Lemmy's UI?
-        For backend issues, use [lemmy](https://github.com/LemmyNet/lemmy)
-  - type: checkboxes
-    attributes:
-      label: Requirements
-      description: Before you create a bug report please do the following.
-      options:
-        - label: Is this a feature request? For questions or discussions use https://lemmy.ml/c/lemmy_support
-          required: true
-        - label: Did you check to see if this issue already exists?
-          required: true
-        - label: Is this only a feature request? Do not put multiple feature requests in one issue.
-          required: true
-        - label: Is this a backend issue? Use the [lemmy-ui](https://github.com/LemmyNet/lemmy-ui) repo for UI / frontend issues.
-          required: true
-        - label: Do you agree to follow the rules in our [Code of Conduct](https://join-lemmy.org/docs/code_of_conduct.html)?
-          required: true
-  - type: textarea
-    id: problem
-    attributes:
-      label: Is your proposal related to a problem?
-      description: |
-        Provide a clear and concise description of what the problem is.
-        For example, "I'm always frustrated when..."
-    validations:
-      required: true
-  - type: textarea
-    id: solution
-    attributes:
-      label: Describe the solution you'd like.
-      description: |
-        Provide a clear and concise description of what you want to happen.
-    validations:
-      required: true
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: Describe alternatives you've considered.
-      description: |
-        Let us know about other solutions you've tried or researched.
-    validations:
-      required: true
-  - type: textarea
-    id: context
-    attributes:
-      label: Additional context
-      description: |
-        Is there anything else you can add about the proposal?
-        You might want to link to related issues here, if you haven't already.

.github/ISSUE_TEMPLATE/QUESTION.md

@@ -0,0 +1,10 @@
+---
+name: "? Question"
+about: General questions about Lemmy
+title: ''
+labels: question
+assignees: ''
+
+---
+
+What's the question you have about lemmy?

.github/ISSUE_TEMPLATE/QUESTION.yml

@@ -1,17 +0,0 @@
-name: "? Question"
-description: General questions about Lemmy
-title: "Question: "
-labels: ["question", "triage"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Have a question about Lemmy?
-        Please check the docs first: https://join-lemmy.org/docs/en/index.html
-  - type: textarea
-    id: question
-    attributes:
-      label: Question
-      description: What's the question you have about Lemmy?
-    validations:
-      required: true

.gitignore

@@ -1,5 +1,6 @@
 # local ansible configuration
 ansible/inventory
+ansible/inventory_dev
 ansible/passwords/
 
 # docker build files
@@ -18,19 +19,3 @@ query_testing/**/reports/*.json
 
 # API tests
 api_tests/node_modules
-api_tests/.yalc
-api_tests/yalc.lock
-api_tests/pict-rs
-
-# pictrs data
-pictrs/
-
-# The generated typescript bindings
-bindings
-
-# Database cluster and sockets for testing
-dev_pgdata/
-*.PGSQL.*
-
-# database dumps
-*.sqldump

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "crates/utils/translations"]
-	path = crates/utils/translations
-	url = https://github.com/LemmyNet/lemmy-translations.git
-        branch = main

.rgignore

@@ -0,0 +1 @@
+*.sql

.rustfmt.toml

@@ -1,7 +1,5 @@
 tab_spaces = 2
-edition = "2021"
-imports_layout = "HorizontalVertical"
-imports_granularity = "Crate"
-group_imports = "One"
-wrap_comments = true
-comment_width = 100
+edition="2018"
+imports_layout="HorizontalVertical"
+merge_imports=true
+reorder_imports=true

.woodpecker.yml

@@ -1,312 +0,0 @@
-# TODO: The when: platform conditionals aren't working currently
-# See https://github.com/woodpecker-ci/woodpecker/issues/1677
-
-variables:
-  - &rust_image "rust:1.77"
-  - &rust_nightly_image "rustlang/rust:nightly"
-  - &install_pnpm "corepack enable pnpm"
-  - &slow_check_paths
-    - event: pull_request
-      path:
-        include: [
-            # rust source code
-            "crates/**",
-            "src/**",
-            "**/Cargo.toml",
-            "Cargo.lock",
-            # database migrations
-            "migrations/**",
-            # typescript tests
-            "api_tests/**",
-            # config files and scripts used by ci
-            ".woodpecker.yml",
-            ".rustfmt.toml",
-            "scripts/update_config_defaults.sh",
-            "diesel.toml",
-            ".gitmodules",
-          ]
-  - install_binstall: &install_binstall
-      - wget https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz
-      - tar -xvf cargo-binstall-x86_64-unknown-linux-musl.tgz
-      - cp cargo-binstall /usr/local/cargo/bin
-  - install_diesel_cli: &install_diesel_cli
-      - apt update && apt install -y lsb-release build-essential
-      - sh -c 'echo "deb https://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
-      - wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -
-      - apt update && apt install -y postgresql-client-16
-      - cargo install diesel_cli --no-default-features --features postgres
-      - export PATH="$CARGO_HOME/bin:$PATH"
-
-steps:
-  prepare_repo:
-    image: alpine:3
-    commands:
-      - apk add git
-      - git submodule init
-      - git submodule update
-    when:
-      - event: [pull_request, tag]
-
-  prettier_check:
-    image: tmknom/prettier:3.0.0
-    commands:
-      - prettier -c . '!**/volumes' '!**/dist' '!target' '!**/translations' '!api_tests/pnpm-lock.yaml'
-    when:
-      - event: pull_request
-
-  toml_fmt:
-    image: tamasfe/taplo:0.8.1
-    commands:
-      - taplo format --check
-    when:
-      - event: pull_request
-
-  sql_fmt:
-    image: backplane/pgformatter
-    commands:
-      - ./scripts/sql_format_check.sh
-    when:
-      - event: pull_request
-
-  cargo_fmt:
-    image: *rust_nightly_image
-    environment:
-      # store cargo data in repo folder so that it gets cached between steps
-      CARGO_HOME: .cargo_home
-    commands:
-      - rustup component add rustfmt
-      - cargo +nightly fmt -- --check
-    when:
-      - event: pull_request
-
-  cargo_machete:
-    image: *rust_nightly_image
-    commands:
-      - <<: *install_binstall
-      - cargo binstall -y cargo-machete
-      - cargo machete
-    when:
-      - event: pull_request
-
-  ignored_files:
-    image: alpine:3
-    commands:
-      - apk add git
-      - IGNORED=$(git ls-files --cached -i --exclude-standard)
-      - if [[ "$IGNORED" ]]; then echo "Ignored files present:\n$IGNORED\n"; exit 1; fi
-    when:
-      - event: pull_request
-
-  # make sure api builds with default features (used by other crates relying on lemmy api)
-  check_api_common_default_features:
-    image: *rust_image
-    environment:
-      CARGO_HOME: .cargo_home
-    commands:
-      - cargo check --package lemmy_api_common
-    when: *slow_check_paths
-
-  lemmy_api_common_doesnt_depend_on_diesel:
-    image: *rust_image
-    environment:
-      CARGO_HOME: .cargo_home
-    commands:
-      - "! cargo tree -p lemmy_api_common --no-default-features -i diesel"
-    when: *slow_check_paths
-
-  lemmy_api_common_works_with_wasm:
-    image: *rust_image
-    environment:
-      CARGO_HOME: .cargo_home
-    commands:
-      - "rustup target add wasm32-unknown-unknown"
-      - "cargo check --target wasm32-unknown-unknown -p lemmy_api_common"
-    when: *slow_check_paths
-
-  check_defaults_hjson_updated:
-    image: *rust_image
-    environment:
-      CARGO_HOME: .cargo_home
-    commands:
-      - export LEMMY_CONFIG_LOCATION=./config/config.hjson
-      - ./scripts/update_config_defaults.sh config/defaults_current.hjson
-      - diff config/defaults.hjson config/defaults_current.hjson
-    when: *slow_check_paths
-
-  check_diesel_schema:
-    image: *rust_image
-    environment:
-      CARGO_HOME: .cargo_home
-      DATABASE_URL: postgres://lemmy:password@database:5432/lemmy
-    commands:
-      - <<: *install_diesel_cli
-      - diesel migration run
-      - diesel print-schema --config-file=diesel.toml > tmp.schema
-      - diff tmp.schema crates/db_schema/src/schema.rs
-    when: *slow_check_paths
-
-  check_db_perf_tool:
-    image: *rust_image
-    environment:
-      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432/lemmy
-      RUST_BACKTRACE: "1"
-      CARGO_HOME: .cargo_home
-    commands:
-      # same as scripts/db_perf.sh but without creating a new database server
-      - export LEMMY_CONFIG_LOCATION=config/config.hjson
-      - cargo run --package lemmy_db_perf -- --posts 10 --read-post-pages 1
-    when: *slow_check_paths
-
-  cargo_clippy:
-    image: *rust_image
-    environment:
-      CARGO_HOME: .cargo_home
-    commands:
-      - rustup component add clippy
-      - cargo clippy --workspace --tests --all-targets --features console -- -D warnings
-    when: *slow_check_paths
-
-  cargo_build:
-    image: *rust_image
-    environment:
-      CARGO_HOME: .cargo_home
-    commands:
-      - cargo build
-      - mv target/debug/lemmy_server target/lemmy_server
-    when: *slow_check_paths
-
-  cargo_test:
-    image: *rust_image
-    environment:
-      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432/lemmy
-      RUST_BACKTRACE: "1"
-      CARGO_HOME: .cargo_home
-    commands:
-      - export LEMMY_CONFIG_LOCATION=../../config/config.hjson
-      - cargo test --workspace --no-fail-fast
-    when: *slow_check_paths
-
-  check_diesel_migration:
-    # TODO: use willsquire/diesel-cli image when shared libraries become optional in lemmy_server
-    image: *rust_image
-    environment:
-      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432/lemmy
-      RUST_BACKTRACE: "1"
-      CARGO_HOME: .cargo_home
-      DATABASE_URL: postgres://lemmy:password@database:5432/lemmy
-      PGUSER: lemmy
-      PGPASSWORD: password
-      PGHOST: database
-      PGDATABASE: lemmy
-    commands:
-      # Install diesel_cli
-      - <<: *install_diesel_cli
-      # Run all migrations
-      - diesel migration run
-      # Dump schema to before.sqldump (PostgreSQL apt repo is used to prevent pg_dump version mismatch error)
-      - apt update && apt install -y lsb-release
-      - sh -c 'echo "deb https://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
-      - wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -
-      - apt update && apt install -y postgresql-client-16
-      - psql -c "DROP SCHEMA IF EXISTS r CASCADE;"
-      - pg_dump --no-owner --no-privileges --no-table-access-method --schema-only --no-sync -f before.sqldump
-      # Make sure that the newest migration is revertable without the `r` schema
-      - diesel migration redo
-      # Run schema setup twice, which fails on the 2nd time if `DROP SCHEMA IF EXISTS r CASCADE` drops the wrong things
-      - alias lemmy_schema_setup="target/lemmy_server --disable-scheduled-tasks --disable-http-server --disable-activity-sending"
-      - lemmy_schema_setup
-      - lemmy_schema_setup
-      # Make sure that the newest migration is revertable with the `r` schema
-      - diesel migration redo
-      # Check for changes in the schema, which would be caused by an incorrect migration
-      - psql -c "DROP SCHEMA IF EXISTS r CASCADE;"
-      - pg_dump --no-owner --no-privileges --no-table-access-method --schema-only --no-sync -f after.sqldump
-      - diff before.sqldump after.sqldump
-    when: *slow_check_paths
-
-  run_federation_tests:
-    image: node:20-bookworm-slim
-    environment:
-      LEMMY_DATABASE_URL: postgres://lemmy:password@database:5432
-      DO_WRITE_HOSTS_FILE: "1"
-    commands:
-      - *install_pnpm
-      - apt update && apt install -y bash curl postgresql-client
-      - bash api_tests/prepare-drone-federation-test.sh
-      - cd api_tests/
-      - pnpm i
-      - pnpm api-test
-    when: *slow_check_paths
-
-  federation_tests_server_output:
-    image: alpine:3
-    commands:
-      # `|| true` prevents this step from appearing to fail if the server output files don't exist
-      - cat target/log/lemmy_*.out || true
-      - "# If you can't see all output, then use the download button"
-    when:
-      - event: pull_request
-        status: failure
-
-  publish_release_docker:
-    image: woodpeckerci/plugin-docker-buildx
-    secrets: [docker_username, docker_password]
-    settings:
-      repo: dessalines/lemmy
-      dockerfile: docker/Dockerfile
-      platforms: linux/amd64, linux/arm64
-      build_args:
-        - RUST_RELEASE_MODE=release
-      tag: ${CI_COMMIT_TAG}
-    when:
-      - event: tag
-
-  nightly_build:
-    image: woodpeckerci/plugin-docker-buildx
-    secrets: [docker_username, docker_password]
-    settings:
-      repo: dessalines/lemmy
-      dockerfile: docker/Dockerfile
-      platforms: linux/amd64,linux/arm64
-      build_args:
-        - RUST_RELEASE_MODE=release
-      tag: dev
-    when:
-      - event: cron
-
-  # using https://github.com/pksunkara/cargo-workspaces
-  publish_to_crates_io:
-    image: *rust_image
-    commands:
-      - <<: *install_binstall
-      # Install cargo-workspaces
-      - cargo binstall -y cargo-workspaces
-      - cp -r migrations crates/db_schema/
-      - cargo workspaces publish --token "$CARGO_API_TOKEN" --from-git --allow-dirty --no-verify --allow-branch "${CI_COMMIT_TAG}" --yes custom "${CI_COMMIT_TAG}"
-    secrets: [cargo_api_token]
-    when:
-      - event: tag
-
-  notify_on_failure:
-    image: alpine:3
-    commands:
-      - apk add curl
-      - "curl -d'Lemmy CI build failed: ${CI_PIPELINE_URL}' ntfy.sh/lemmy_drone_ci"
-    when:
-      - event: [pull_request, tag]
-        status: failure
-
-  notify_on_tag_deploy:
-    image: alpine:3
-    commands:
-      - apk add curl
-      - "curl -d'lemmy:${CI_COMMIT_TAG} deployed' ntfy.sh/lemmy_drone_ci"
-    when:
-      - event: tag
-
-services:
-  database:
-    image: postgres:16-alpine
-    environment:
-      POSTGRES_USER: lemmy
-      POSTGRES_PASSWORD: password

CONTRIBUTING.md

@@ -0,0 +1,4 @@
+# Contributing
+
+See [here](https://join.lemmy.ml/docs/en/contributing/contributing.html) for contributing Instructions.
+

Cargo.toml

@@ -1,210 +1,59 @@
-[workspace.package]
-version = "0.19.4-rc.2"
-edition = "2021"
-description = "A link aggregator for the fediverse"
-license = "AGPL-3.0"
-homepage = "https://join-lemmy.org/"
-documentation = "https://join-lemmy.org/docs/en/index.html"
-repository = "https://github.com/LemmyNet/lemmy"
-
 [package]
 name = "lemmy_server"
-version.workspace = true
-edition.workspace = true
-description.workspace = true
-license.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-repository.workspace = true
-publish = false
+version = "0.0.1"
+edition = "2018"
 
-[lib]
-doctest = false
-
-[lints]
-workspace = true
-
-[profile.release]
-debug = 0
-lto = "thin"
-strip = true    # Automatically strip symbols from the binary.
-opt-level = "z" # Optimize for size.
-
-# This profile significantly speeds up build time. If debug info is needed you can comment the line
-# out temporarily, but make sure to leave this in the main branch.
 [profile.dev]
 debug = 0
 
-[features]
-embed-pictrs = ["pict-rs"]
-# This feature requires building with `tokio_unstable` flag, see documentation:
-# https://docs.rs/tokio/latest/tokio/#unstable-features
-console = [
-  "console-subscriber",
-  "opentelemetry",
-  "opentelemetry-otlp",
-  "tracing-opentelemetry",
-  "reqwest-tracing/opentelemetry_0_16",
-]
-json-log = ["tracing-subscriber/json"]
-default = []
-
 [workspace]
 members = [
-  "crates/api",
-  "crates/api_crud",
-  "crates/api_common",
-  "crates/apub",
-  "crates/utils",
-  "crates/db_perf",
-  "crates/db_schema",
-  "crates/db_views",
-  "crates/db_views_actor",
-  "crates/db_views_actor",
-  "crates/routes",
-  "crates/federate",
+    "crates/api",
+    "crates/apub",
+    "crates/utils",
+    "crates/db_queries",
+    "crates/db_schema",
+    "crates/db_views",
+    "crates/db_views_actor",
+    "crates/db_views_actor",
+    "crates/structs",
+    "crates/websocket",
+    "crates/routes"
 ]
 
-[workspace.lints.clippy]
-cast_lossless = "deny"
-complexity = { level = "deny", priority = -1 }
-correctness = { level = "deny", priority = -1 }
-dbg_macro = "deny"
-explicit_into_iter_loop = "deny"
-explicit_iter_loop = "deny"
-get_first = "deny"
-implicit_clone = "deny"
-indexing_slicing = "deny"
-inefficient_to_string = "deny"
-items-after-statements = "deny"
-manual_string_new = "deny"
-needless_collect = "deny"
-perf = { level = "deny", priority = -1 }
-redundant_closure_for_method_calls = "deny"
-style = { level = "deny", priority = -1 }
-suspicious = { level = "deny", priority = -1 }
-uninlined_format_args = "allow"
-unused_self = "deny"
-unwrap_used = "deny"
-
-[workspace.dependencies]
-lemmy_api = { version = "=0.19.4-rc.2", path = "./crates/api" }
-lemmy_api_crud = { version = "=0.19.4-rc.2", path = "./crates/api_crud" }
-lemmy_apub = { version = "=0.19.4-rc.2", path = "./crates/apub" }
-lemmy_utils = { version = "=0.19.4-rc.2", path = "./crates/utils", default-features = false }
-lemmy_db_schema = { version = "=0.19.4-rc.2", path = "./crates/db_schema" }
-lemmy_api_common = { version = "=0.19.4-rc.2", path = "./crates/api_common" }
-lemmy_routes = { version = "=0.19.4-rc.2", path = "./crates/routes" }
-lemmy_db_views = { version = "=0.19.4-rc.2", path = "./crates/db_views" }
-lemmy_db_views_actor = { version = "=0.19.4-rc.2", path = "./crates/db_views_actor" }
-lemmy_db_views_moderator = { version = "=0.19.4-rc.2", path = "./crates/db_views_moderator" }
-lemmy_federate = { version = "=0.19.4-rc.2", path = "./crates/federate" }
-activitypub_federation = { version = "0.5.6", default-features = false, features = [
-  "actix-web",
-] }
-diesel = "2.1.6"
-diesel_migrations = "2.1.0"
-diesel-async = "0.4.1"
-serde = { version = "1.0.202", features = ["derive"] }
-serde_with = "3.8.1"
-actix-web = { version = "4.6.0", default-features = false, features = [
-  "macros",
-  "rustls",
-  "compress-brotli",
-  "compress-gzip",
-  "compress-zstd",
-  "cookies",
-] }
-tracing = "0.1.40"
-tracing-actix-web = { version = "0.7.10", default-features = false }
-tracing-error = "0.2.0"
-tracing-log = "0.2.0"
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-url = { version = "2.5.0", features = ["serde"] }
-reqwest = { version = "0.11.27", features = ["json", "blocking", "gzip"] }
-reqwest-middleware = "0.2.5"
-reqwest-tracing = "0.4.8"
-clokwerk = "0.4.0"
-doku = { version = "0.21.1", features = ["url-2"] }
-bcrypt = "0.15.1"
-chrono = { version = "0.4.38", features = ["serde"], default-features = false }
-serde_json = { version = "1.0.117", features = ["preserve_order"] }
-base64 = "0.22.1"
-uuid = { version = "1.8.0", features = ["serde", "v4"] }
-async-trait = "0.1.80"
-captcha = "0.0.9"
-anyhow = { version = "1.0.86", features = [
-  "backtrace",
-] } # backtrace is on by default on nightly, but not stable rust
-diesel_ltree = "0.3.1"
-typed-builder = "0.18.2"
-serial_test = "3.1.1"
-tokio = { version = "1.37.0", features = ["full"] }
-regex = "1.10.4"
-once_cell = "1.19.0"
-diesel-derive-newtype = "2.1.2"
-diesel-derive-enum = { version = "2.1.0", features = ["postgres"] }
-strum = "0.26.2"
-strum_macros = "0.26.2"
-itertools = "0.13.0"
-futures = "0.3.30"
-http = "0.2.12"
-rosetta-i18n = "0.1.3"
-opentelemetry = { version = "0.19.0", features = ["rt-tokio"] }
-tracing-opentelemetry = { version = "0.19.0" }
-ts-rs = { version = "7.1.1", features = [
-  "serde-compat",
-  "chrono-impl",
-  "no-serde-warnings",
-] }
-rustls = { version = "0.23.8", features = ["ring"] }
-futures-util = "0.3.30"
-tokio-postgres = "0.7.10"
-tokio-postgres-rustls = "0.12.0"
-urlencoding = "2.1.3"
-enum-map = "2.7"
-moka = { version = "0.12.7", features = ["future"] }
-i-love-jesus = { version = "0.1.0" }
-clap = { version = "4.5.4", features = ["derive", "env"] }
-pretty_assertions = "1.4.0"
-
 [dependencies]
-lemmy_api = { workspace = true }
-lemmy_api_crud = { workspace = true }
-lemmy_apub = { workspace = true }
-lemmy_utils = { workspace = true }
-lemmy_db_schema = { workspace = true }
-lemmy_api_common = { workspace = true }
-lemmy_routes = { workspace = true }
-lemmy_federate = { workspace = true }
-activitypub_federation = { workspace = true }
-diesel = { workspace = true }
-diesel-async = { workspace = true }
-actix-web = { workspace = true }
-tracing = { workspace = true }
-tracing-actix-web = { workspace = true }
-tracing-error = { workspace = true }
-tracing-log = { workspace = true }
-tracing-subscriber = { workspace = true }
-url = { workspace = true }
-reqwest = { workspace = true }
-reqwest-middleware = { workspace = true }
-reqwest-tracing = { workspace = true }
-clokwerk = { workspace = true }
-serde_json = { workspace = true }
-tracing-opentelemetry = { workspace = true, optional = true }
-opentelemetry = { workspace = true, optional = true }
-console-subscriber = { version = "0.1.10", optional = true }
-opentelemetry-otlp = { version = "0.12.0", optional = true }
-pict-rs = { version = "0.5.14", optional = true }
-tokio.workspace = true
-actix-cors = "0.7.0"
-futures-util = { workspace = true }
-chrono = { workspace = true }
-prometheus = { version = "0.13.4", features = ["process"] }
-serial_test = { workspace = true }
-clap = { workspace = true }
-actix-web-prom = "0.8.0"
+lemmy_api = { path = "./crates/api" }
+lemmy_apub = { path = "./crates/apub" }
+lemmy_utils = { path = "./crates/utils" }
+lemmy_db_schema = { path = "./crates/db_schema" }
+lemmy_db_queries = { path = "./crates/db_queries" }
+lemmy_db_views = { path = "./crates/db_views" }
+lemmy_db_views_moderator = { path = "./crates/db_views_moderator" }
+lemmy_db_views_actor = { path = "./crates/db_views_actor" }
+lemmy_structs = { path = "./crates/structs" }
+lemmy_websocket = { path = "./crates/websocket" }
+lemmy_routes = { path = "./crates/routes" }
+diesel = "1.4.5"
+diesel_migrations = "1.4.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+serde = { version = "1.0.123", features = ["derive"] }
+actix = "0.10.0"
+actix-web = { version = "3.3.2", default-features = false, features = ["rustls"] }
+log = "0.4.14"
+env_logger = "0.8.2"
+strum = "0.20.0"
+url = { version = "2.2.0", features = ["serde"] }
+openssl = "0.10.32"
+http-signature-normalization-actix = { version = "0.4.1", default-features = false, features = ["sha-2"] }
+tokio = "0.3.6"
+anyhow = "1.0.38"
+reqwest = { version = "0.10.10", features = ["json"] }
+activitystreams = "0.7.0-alpha.10"
+actix-rt = { version = "1.1.1", default-features = false }
+serde_json = { version = "1.0.61", features = ["preserve_order"] }
+clokwerk = "0.3.4"
 
-[dev-dependencies]
-pretty_assertions = { workspace = true }
+[dev-dependencies.cargo-husky]
+version = "1.5.0"
+default-features = false # Disable features which are enabled by default
+features = ["precommit-hook", "run-cargo-fmt", "run-cargo-clippy"]

README.md

@@ -1,39 +1,27 @@
 <div align="center">
 
 ![GitHub tag (latest SemVer)](https://img.shields.io/github/tag/LemmyNet/lemmy.svg)
-[![Build Status](https://woodpecker.join-lemmy.org/api/badges/LemmyNet/lemmy/status.svg)](https://woodpecker.join-lemmy.org/LemmyNet/lemmy)
+[![Build Status](https://cloud.drone.io/api/badges/LemmyNet/lemmy/status.svg)](https://cloud.drone.io/LemmyNet/lemmy/)
 [![GitHub issues](https://img.shields.io/github/issues-raw/LemmyNet/lemmy.svg)](https://github.com/LemmyNet/lemmy/issues)
 [![Docker Pulls](https://img.shields.io/docker/pulls/dessalines/lemmy.svg)](https://cloud.docker.com/repository/docker/dessalines/lemmy/)
-[![Translation status](http://weblate.join-lemmy.org/widgets/lemmy/-/lemmy/svg-badge.svg)](http://weblate.join-lemmy.org/engage/lemmy/)
+[![Translation status](http://weblate.yerbamate.ml/widgets/lemmy/-/lemmy/svg-badge.svg)](http://weblate.yerbamate.ml/engage/lemmy/)
 [![License](https://img.shields.io/github/license/LemmyNet/lemmy.svg)](LICENSE)
 ![GitHub stars](https://img.shields.io/github/stars/LemmyNet/lemmy?style=social)
-<a href="https://endsoftwarepatents.org/innovating-without-patents"><img style="height: 20px;" src="https://static.fsf.org/nosvn/esp/logos/patent-free.svg"></a>
-
+[![Awesome Humane Tech](https://raw.githubusercontent.com/humanetech-community/awesome-humane-tech/main/humane-tech-badge.svg?sanitize=true)](https://github.com/humanetech-community/awesome-humane-tech)
 </div>
 
 <p align="center">
-  <span>English</span> |
-  <a href="readmes/README.es.md">Español</a> |
-  <a href="readmes/README.ru.md">Русский</a> |
-  <a href="readmes/README.zh.hans.md">汉语</a> |
-  <a href="readmes/README.zh.hant.md">漢語</a> |
-  <a href="readmes/README.ja.md">日本語</a>
-</p>
-
-<p align="center">
-  <a href="https://join-lemmy.org/" rel="noopener">
+  <a href="https://join.lemmy.ml/" rel="noopener">
  <img width=200px height=200px src="https://raw.githubusercontent.com/LemmyNet/lemmy-ui/main/src/assets/icons/favicon.svg"></a>
 
- <h3 align="center"><a href="https://join-lemmy.org">Lemmy</a></h3>
+ <h3 align="center"><a href="https://join.lemmy.ml">Lemmy</a></h3>
   <p align="center">
-    A link aggregator and forum for the fediverse.
+    A link aggregator / Reddit clone for the fediverse.
     <br />
     <br />
-    <a href="https://join-lemmy.org">Join Lemmy</a>
+    <a href="https://join.lemmy.ml">Join Lemmy</a>
     ·
-    <a href="https://join-lemmy.org/docs/index.html">Documentation</a>
-    ·
-    <a href="https://matrix.to/#/#lemmy-space:matrix.org">Matrix Chat</a>
+    <a href="https://join.lemmy.ml/docs/en/index.html">Documentation</a>
     ·
     <a href="https://github.com/LemmyNet/lemmy/issues">Report Bug</a>
     ·
@@ -41,27 +29,29 @@
     ·
     <a href="https://github.com/LemmyNet/lemmy/blob/main/RELEASES.md">Releases</a>
     ·
-    <a href="https://join-lemmy.org/docs/code_of_conduct.html">Code of Conduct</a>
+    <a href="https://join.lemmy.ml/docs/en/code_of_conduct.html">Code of Conduct</a>
   </p>
 </p>
 
 ## About The Project
 
-| Desktop                                                                                                         | Mobile                                                                                                      |
-| --------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| ![desktop](https://raw.githubusercontent.com/LemmyNet/joinlemmy-site/main/src/assets/images/main_screen_2.webp) | ![mobile](https://raw.githubusercontent.com/LemmyNet/joinlemmy-site/main/src/assets/images/mobile_pic.webp) |
+Desktop|Mobile
+---|---
+![desktop](https://raw.githubusercontent.com/LemmyNet/joinlemmy-site/main/static/images/main_img.webp)|![mobile](https://raw.githubusercontent.com/LemmyNet/joinlemmy-site/main/static/images/mobile_pic.webp)
 
 [Lemmy](https://github.com/LemmyNet/lemmy) is similar to sites like [Reddit](https://reddit.com), [Lobste.rs](https://lobste.rs), or [Hacker News](https://news.ycombinator.com/): you subscribe to forums you're interested in, post links and discussions, then vote, and comment on them. Behind the scenes, it is very different; anyone can easily run a server, and all these servers are federated (think email), and connected to the same universe, called the [Fediverse](https://en.wikipedia.org/wiki/Fediverse).
 
 For a link aggregator, this means a user registered on one server can subscribe to forums on any other server, and can have discussions with users registered elsewhere.
 
-It is an easily self-hostable, decentralized alternative to Reddit and other link aggregators, outside of their corporate control and meddling.
+The overall goal is to create an easily self-hostable, decentralized alternative to Reddit and other link aggregators, outside of their corporate control and meddling.
 
 Each Lemmy server can set its own moderation policy; appointing site-wide admins, and community moderators to keep out the trolls, and foster a healthy, non-toxic environment where all can feel comfortable contributing.
 
+*Note: Federation is still in active development and the WebSocket, as well as, HTTP API are currently unstable*
+
 ### Why's it called Lemmy?
 
-- Lead singer from [Motörhead](https://invidio.us/watch?v=3mbvWn1EY6g).
+- Lead singer from [Motörhead](https://invidio.us/watch?v=pWB5JZRGl0U).
 - The old school [video game](<https://en.wikipedia.org/wiki/Lemmings_(video_game)>).
 - The [Koopa from Super Mario](https://www.mariowiki.com/Lemmy_Koopa).
 - The [furry rodents](http://sunchild.fpwc.org/lemming-the-little-giant-of-the-north/).
@@ -78,7 +68,7 @@ Each Lemmy server can set its own moderation policy; appointing site-wide admins
 
 - Open source, [AGPL License](/LICENSE).
 - Self hostable, easy to deploy.
-  - Comes with [Docker](https://join-lemmy.org/docs/administration/install_docker.html) and [Ansible](https://join-lemmy.org/docs/administration/install_ansible.html).
+  - Comes with [Docker](https://join.lemmy.ml/docs/en/administration/install_docker.html) and [Ansible](https://join.lemmy.ml/docs/en/administration/install_ansible.html).
 - Clean, mobile-friendly interface.
   - Only a minimum of a username and password is required to sign up!
   - User avatar support.
@@ -95,7 +85,7 @@ Each Lemmy server can set its own moderation policy; appointing site-wide admins
   - i18n / internationalization support.
   - RSS / Atom feeds for `All`, `Subscribed`, `Inbox`, `User`, and `Community`.
 - Cross-posting support.
-  - A _similar post search_ when creating new posts. Great for question / answer communities.
+  - A *similar post search* when creating new posts. Great for question / answer communities.
 - Moderation abilities.
   - Public Moderation Logs.
   - Can sticky posts to the top of communities.
@@ -105,28 +95,39 @@ Each Lemmy server can set its own moderation policy; appointing site-wide admins
   - Can transfer site and communities to others.
 - Can fully erase your data, replacing all posts and comments.
 - NSFW post / community support.
+- OEmbed support via Iframely.
 - High performance.
   - Server is written in rust.
+  - Front end is `~80kB` gzipped.
   - Supports arm64 / Raspberry Pi.
 
 ## Installation
 
-- [Lemmy Administration Docs](https://join-lemmy.org/docs/administration/administration.html)
+- [Docker](https://join.lemmy.ml/docs/en/administration/install_docker.html)
+- [Ansible](https://join.lemmy.ml/docs/en/administration/install_ansible.html)
 
 ## Lemmy Projects
 
-- [awesome-lemmy - A community driven list of apps and tools for lemmy](https://github.com/dbeley/awesome-lemmy)
+### Apps
+
+- [lemmy-ui - The official web app for lemmy](https://github.com/LemmyNet/lemmy-ui)
+- [Lemmur - A mobile client for Lemmy (Android, Linux, Windows)](https://github.com/krawieck/lemmur)
+- [Remmel - A native iOS app](https://github.com/uuttff8/Lemmy-iOS)
+
+### Libraries
+
+- [lemmy-js-client](https://github.com/LemmyNet/lemmy-js-client)
+- [Kotlin API ( under development )](https://github.com/eiknat/lemmy-client)
+- [Dart API client ( under development )](https://github.com/krawieck/lemmy_api_client)
 
 ## Support / Donate
 
 Lemmy is free, open-source software, meaning no advertising, monetizing, or venture capital, ever. Your donations directly support full-time development of the project.
 
-Lemmy is made possible by a generous grant from the [NLnet foundation](https://nlnet.nl/).
-
 - [Support on Liberapay](https://liberapay.com/Lemmy).
 - [Support on Patreon](https://www.patreon.com/dessalines).
 - [Support on OpenCollective](https://opencollective.com/lemmy).
-- [List of Sponsors](https://join-lemmy.org/donate).
+- [List of Sponsors](https://join.lemmy.ml/sponsors).
 
 ### Crypto
 
@@ -136,28 +137,23 @@ Lemmy is made possible by a generous grant from the [NLnet foundation](https://n
 
 ## Contributing
 
-Read the following documentation to setup the development environment and start coding:
-
-- [Contributing instructions](https://join-lemmy.org/docs/contributors/01-overview.html)
-- [Docker Development](https://join-lemmy.org/docs/contributors/03-docker-development.html)
-- [Local Development](https://join-lemmy.org/docs/contributors/02-local-development.html)
-
-When working on an issue or pull request, you can comment with any questions you may have so that maintainers can answer them. You can also join the [Matrix Development Chat](https://matrix.to/#/#lemmydev:matrix.org) for general assistance.
+- [Contributing instructions](https://join.lemmy.ml/docs/en/contributing/contributing.html)
+- [Docker Development](https://join.lemmy.ml/docs/en/contributing/docker_development.html)
+- [Local Development](https://join.lemmy.ml/docs/en/contributing/local_development.html)
 
 ### Translations
 
-- If you want to help with translating, take a look at [Weblate](https://weblate.join-lemmy.org/projects/lemmy/). You can also help by [translating the documentation](https://github.com/LemmyNet/lemmy-docs#adding-a-new-language).
+If you want to help with translating, take a look at [Weblate](https://weblate.yerbamate.ml/projects/lemmy/). You can also help by [translating the documentation](https://github.com/LemmyNet/lemmy-docs#adding-a-new-language).
 
-## Community
+## Contact
 
-- [Matrix Space](https://matrix.to/#/#lemmy-space:matrix.org)
-- [Lemmy Forum](https://lemmy.ml/c/lemmy)
-- [Lemmy Support Forum](https://lemmy.ml/c/lemmy_support)
+- [Mastodon](https://mastodon.social/@LemmyDev)
+- [Matrix](https://matrix.to/#/#lemmy:matrix.org)
 
 ## Code Mirrors
 
 - [GitHub](https://github.com/LemmyNet/lemmy)
-- [Gitea](https://git.join-lemmy.org/LemmyNet/lemmy)
+- [Gitea](https://yerbamate.ml/LemmyNet/lemmy)
 - [Codeberg](https://codeberg.org/LemmyNet/lemmy)
 
 ## Credits

RELEASES.md

@@ -1,3 +1,309 @@
-[Lemmy Releases / news](https://join-lemmy.org/news)
+# Lemmy v0.9.7 Release (2021-02-08)
 
-[Github link](https://github.com/LemmyNet/joinlemmy-site/tree/main/src/assets/news)
+## Changes
+
+- Posts and comments are no longer live-sorted (meaning most content should stay in place).
+- Fixed an issue with the create post title field not expanding when copied from iframely suggestion.
+- Fixed broken federated community paging / sorting.
+- Added aria attributes for accessibility, thx to @Mitch Lillie.
+- Updated translations and added croatian.
+- No changes to lemmy back-end.
+
+# Lemmy v0.9.6 Release (2021-02-05)
+
+## Changes
+
+- Fixed inbox_urls not being correctly set, which broke federation in `v0.9.5`. Added some logging to catch these.
+- Fixing community search not using auth.
+- Moved docs to https://join.lemmy.ml
+- Fixed an issue w/ lemmy-ui with forms being cleared out.
+
+# Lemmy v0.9.4 Pre-Release (2021-02-02)
+
+## Changes
+
+### Lemmy
+
+- Fixed a critical bug with votes and comment unlike responses not being `0` for your user.
+- Fixed a critical bug with comment creation not checking if its parent comment is in the post.
+- Serving proper activities for community outbox.
+- Added some active user counts, including `users_active_day`, `users_active_week`, `users_active_month`, `users_active_half_year` to `SiteAggregates` and `CommunityAggregates`. (Also added to lemmy-ui)
+- Made sure banned users can't follow.
+- Added `FederatedInstances` to `SiteResponse`, to show allowed and blocked instances. (Also added to lemmy-ui)
+- Added a `MostComments` sort for posts. (Also added to lemmy-ui)
+
+### Lemmy-UI
+
+- Added a scroll position restore to lemmy-ui.
+- Reworked the combined inbox so incoming comments don't wipe out your current form.
+- Fixed an updated bug on the user page.
+- Fixed cross-post titles and body getting clipped.
+- Fixing the post creation title height.
+- Squashed some other smaller bugs.
+
+# Lemmy v0.9.0 Release (2021-01-25)
+
+## Changes
+
+Since our last release in October of last year, and we've had [~450](https://github.com/LemmyNet/lemmy/compare/v0.8.0...main) commits.
+
+The biggest changes, as we'll outline below, are a re-work of Lemmy's database structure, a `v2` of Lemmy's API, and activitypub compliance fixes. The new re-worked DB is much faster, easier to maintain, and [now supports hierarchical rather than flat objects in the new API](https://github.com/LemmyNet/lemmy/issues/1275).
+
+We've also seen the first release of [Lemmur](https://github.com/krawieck/lemmur/releases/tag/v0.1.1), an android / iOS (soon) / windows / linux client, as well as [Lemmer](https://github.com/uuttff8/Lemmy-iOS), a native iOS client. Much thanks to @krawieck, @shilangyu, and @uuttff8 for making these great clients. If you can, please contribute to their [patreon](https://www.patreon.com/lemmur) to help fund lemmur development.
+
+## LemmyNet projects
+
+### Lemmy Server
+
+- [Moved views from SQL to Diesel](https://github.com/LemmyNet/lemmy/issues/1275). This was a spinal replacement for much of lemmy.
+  - Removed all the old fast_tables and triggers, and created new aggregates tables.
+- Added a `v2` of the API to support the hierarchical objects created from the above changes.
+- Moved continuous integration to [drone](https://cloud.drone.io/LemmyNet/lemmy/), now includes formatting, clippy, and cargo build checks, unit testing, and federation testing. [Drone also deploys both amd64 and arm64 images to dockerhub.](https://hub.docker.com/r/dessalines/lemmy)
+- Split out documentation into git submodule.
+- Shortened slur filter to avoid false positives.
+- Added query performance testing and comparisons. Added indexes to make sure every query is `< 30 ms`.
+- Added compilation time testing.
+
+### Federation
+
+This release includes some bug fixes for federation, and some changes to get us closer to compliance with the ActivityPub standard.
+
+- [Community bans now federating](https://github.com/LemmyNet/lemmy/issues/1287).
+- [Local posts sometimes got marked as remote](https://github.com/LemmyNet/lemmy/issues/1302).
+- [Creator of post/comment was not notified about new child comments](https://github.com/LemmyNet/lemmy/issues/1325).
+- [Community deletion now federated](https://github.com/LemmyNet/lemmy/issues/1256).
+
+None of these are breaking changes, so federation between 0.9.0 and 0.8.11 will work without problems.
+
+### Lemmy javascript / typescript client
+
+- Updated the [lemmy-js-client](https://github.com/LemmyNet/lemmy-js-client) to use the new `v2` API. Our API docs now reference this project's files, to show what the http / websocket forms and responses should look like.
+- Drone now handles publishing its [npm packages.](https://www.npmjs.com/package/lemmy-js-client)
+
+### Lemmy-UI
+
+- Updated it to use the `v2` API via `lemmy-js-client`, required changing nearly every component.
+- Added a live comment count.
+- Added drone deploying, and builds for ARM.
+- Fixed community link wrapping.
+- Various other bug fixes.
+
+
+### Lemmy Docs
+
+- We moved documentation into a separate git repository, and support translation for the docs now!
+- Moved our code of conduct into the documentation.
+
+## Upgrading
+
+If you'd like to make a DB backup before upgrading, follow [this guide](https://join.lemmy.ml/docs/en/administration/backup_and_restore.html).
+
+- [Upgrade with manual Docker installation](https://join.lemmy.ml/docs/en/administration/install_docker.html#updating)
+- [Upgrade with Ansible installation](https://join.lemmy.ml/docs/en/administration/install_ansible.html)
+
+# Lemmy v0.8.0 Release (2020-10-16)
+
+## Changes
+
+We've been working at warp speed since our `v0.7.0` release in June, adding over [870 commits](https://github.com/LemmyNet/lemmy/compare/v0.7.0...main) since then. :sweat: 
+
+Here are some of the bigger changes:
+
+### LemmyNet projects
+
+- Created [LemmyNet](https://github.com/LemmyNet), where all lemmy-related projects live.
+- Split out the frontend into a separete repository, [lemmy-ui](https://github.com/LemmyNet/lemmy-ui)
+- Created a [lemmy-js-client](https://github.com/LemmyNet/lemmy-js-client), for any js / typescript developers.
+- Split out i18n [lemmy-translations](https://github.com/LemmyNet/lemmy-translations), that any app or site developers can import and use. Lemmy currently supports [~30 languages!](https://weblate.yerbamate.ml/projects/lemmy/lemmy/)
+
+### Lemmy Server
+
+#### Federation
+
+- The first **federation public beta release**, woohoo :fireworks: 
+- All Lemmy functionality now works over ActivityPub (except turning remote users into mods/admins)
+- Instance allowlist and blocklist
+- Documentation for [admins](https://join.lemmy.ml/docs/administration_federation.html) and [devs](https://join.lemmy.ml/docs/contributing_federation_overview.html) on how federation works
+- Upgraded to newest versions of @asonix activitypub libraries
+- Full local federation setup for manual testing
+- Automated testing for nearly every federation action
+- Many additional security checks
+- Lots and lots of refactoring
+- Asynchronous sending of outgoing activities
+
+### User Interface
+
+- Separated the UI from the server code, in [lemmy-ui](https://github.com/LemmyNet/lemmy-ui).
+- The UI can now read with javascript disabled! 
+- It's now a fully isomorphic application using [inferno-isomorphic](https://infernojs.org/docs/guides/isomorphic). This means that page loads are now much faster, as the server does the work.
+- The UI now also supports open-graph and twitter cards! Linking to lemmy posts (from whatever platform you use) looks pretty now: ![](https://i.imgur.com/6TZ2v7s.png)
+- Improved the search page ( more features incoming ).
+- The default view is now `Local`, instead of `All`, since all would show all federated posts.
+- User settings are now shared across browsers ( a page refresh will pick up changes ).
+- A much leaner mobile view.
+
+#### Backend
+
+- Re-organized the rust codebase into separate workspaces for backend and frontend.
+- Removed materialized views, making the database **a lot faster**.
+- New post sorts `Active` (previously called hot), and `Hot`. Active shows posts with recent comments, hot shows highly ranked posts.
+- New sort for `Local` ( meaning from local communities).
+- Customizeable site, user, and community icons and banners.
+- Added user preferred names / display names, bios, and cakedays.
+- Visual / Audio captchas through the lemmy API.
+- Lots of API field verifications.
+- Upgraded to pictrs-v2 ( thanks to @asonix )
+- Wayyy too many bugfixes to count.
+
+## Contributors
+
+We'd also like to thank both the [NLnet foundation](https://nlnet.nl/) for their support in allowing us to work full-time on Lemmy ( as well as their support for [other important open-source projects](https://nlnet.nl/project/current.html) ), [those who sponsor us](https://lemmy.ml/sponsors), and those who [help translate Lemmy](https://weblate.yerbamate.ml/projects/lemmy/). Every little bit does help. We remain committed to never allowing advertisements, monetizing, or venture-capital in Lemmy; software should be communal, and should benefit humanity, not a small group of company owners. 
+
+## Upgrading
+
+- [with manual Docker installation](https://join.lemmy.ml/docs/administration_install_docker.html#updating)
+- [with Ansible installation](https://join.lemmy.ml/docs/administration_install_ansible.html)
+
+## Testing Federation
+
+Federation is finally ready in Lemmy, pending possible bugs or other issues. So for now we suggest to enable federation only on test servers, or try it on our own test servers ( [enterprise](https://enterprise.lemmy.ml/), [ds9](https://ds9.lemmy.ml/), [voyager](https://voyager.lemmy.ml/) ).
+
+If everything goes well, after a few weeks we will enable federation on lemmy.ml, at first with a limited number of trusted instances. We will also likely change the domain to https://lemmy.ml . Keep in mind that changing domains after turning on federation will break things.
+
+To enable on your instance, edit your [lemmy.hjson](https://github.com/LemmyNet/lemmy/blob/main/config/defaults.hjson#L60) federation section to `enabled: true`, and restart.
+
+### Connecting to another server
+
+The server https://ds9.lemmy.ml has open federation, so after either adding it to the `allowed_instances` list in your `config.hjson`, or if you have open federation, you don't need to add it explicitly.
+
+To federate / connect with a server, type in `!community_name@server.tld`, in your server's search box [like so](https://voyager.lemmy.ml/search/q/!main%40ds9.lemmy.ml/type/All/sort/TopAll/page/1).
+
+To connect with the `main` community on ds9, the search is `!main@ds9.lemmy.ml`.
+
+You can then click the community, and you will see a local version of the community, which you can subscribe to. New posts and comments from `!main@ds9.lemmy.ml` will now show up on your front page, or `/c/All`
+
+# Lemmy v0.7.40 Pre-Release (2020-08-05)
+
+We've [added a lot](https://github.com/LemmyNet/lemmy/compare/v0.7.40...v0.7.0) in this pre-release:
+
+- New post sorts `Active` (previously called hot), and `Hot`. Active shows posts with recent comments, hot shows highly ranked posts.
+- Customizeable site icon and banner, user icon and banner, and community icon and banner.
+- Added user preferred names / display names, bios, and cakedays.
+- User settings are now shared across browsers (a page refresh will pick up changes).
+- Visual / Audio captchas through the lemmy API.
+- Lots of UI prettiness.
+- Lots of bug fixes.
+- Lots of additional translations.
+- Lots of federation prepping / additions / refactors.
+
+This release removes the need for you to have a pictrs nginx route (the requests are now routed through lemmy directly). Follow the upgrade instructions below to replace your nginx with the new one.
+
+## Upgrading
+
+**With Ansible:**
+
+```
+# run these commands locally
+git pull
+cd ansible
+ansible-playbook lemmy.yml
+```
+
+**With manual Docker installation:**
+```
+# run these commands on your server
+cd /lemmy
+wget https://raw.githubusercontent.com/LemmyNet/lemmy/master/ansible/templates/nginx.conf
+# Replace the {{ vars }}
+sudo mv nginx.conf /etc/nginx/sites-enabled/lemmy.conf
+sudo nginx -s reload
+wget https://raw.githubusercontent.com/LemmyNet/lemmy/master/docker/prod/docker-compose.yml
+sudo docker-compose up -d
+```
+
+
+# Lemmy v0.7.0 Release (2020-06-23)
+
+This release replaces [pictshare](https://github.com/HaschekSolutions/pictshare)
+with [pict-rs](https://git.asonix.dog/asonix/pict-rs), which improves performance
+and security.
+
+Overall, since our last major release in January (v0.6.0), we have closed over
+[100 issues!](https://github.com/LemmyNet/lemmy/milestone/16?closed=1)
+
+- Site-wide list of recent comments
+- Reconnecting websockets
+- Many more themes, including a default light one.
+- Expandable embeds for post links (and thumbnails), from
+[iframely](https://github.com/itteco/iframely)
+- Better icons
+- Emoji autocomplete to post and message bodies, and an Emoji Picker
+- Post body now searchable
+- Community title and description is now searchable
+- Simplified cross-posts
+- Better documentation
+- LOTS more languages
+- Lots of bugs squashed
+- And more ...
+
+## Upgrading
+
+Before starting the upgrade, make sure that you have a working backup of your
+database and image files. See our
+[documentation](https://join.lemmy.ml/docs/administration_backup_and_restore.html)
+for backup instructions.
+
+**With Ansible:**
+
+```
+# deploy with ansible from your local lemmy git repo
+git pull
+cd ansible
+ansible-playbook lemmy.yml
+# connect via ssh to run the migration script
+ssh your-server
+cd /lemmy/
+wget https://raw.githubusercontent.com/LemmyNet/lemmy/master/docker/prod/migrate-pictshare-to-pictrs.bash
+chmod +x migrate-pictshare-to-pictrs.bash
+sudo ./migrate-pictshare-to-pictrs.bash
+```
+
+**With manual Docker installation:**
+```
+# run these commands on your server
+cd /lemmy
+wget https://raw.githubusercontent.com/LemmyNet/lemmy/master/ansible/templates/nginx.conf
+# Replace the {{ vars }}
+sudo mv nginx.conf /etc/nginx/sites-enabled/lemmy.conf
+sudo nginx -s reload
+wget https://raw.githubusercontent.com/LemmyNet/lemmy/master/docker/prod/docker-compose.yml
+wget https://raw.githubusercontent.com/LemmyNet/lemmy/master/docker/prod/migrate-pictshare-to-pictrs.bash
+chmod +x migrate-pictshare-to-pictrs.bash
+sudo bash migrate-pictshare-to-pictrs.bash
+```
+
+**Note:** After upgrading, all users need to reload the page, then logout and
+login again, so that images are loaded correctly.
+
+# Lemmy v0.6.0 Release (2020-01-16)
+
+`v0.6.0` is here, and we've closed [41 issues!](https://github.com/LemmyNet/lemmy/milestone/15?closed=1) 
+
+This is the biggest release by far:
+
+- Avatars!
+- Optional Email notifications for username mentions, post and comment replies.
+- Ability to change your password and email address.
+- Can set a custom language.
+- Lemmy-wide settings to disable downvotes, and close registration.
+- A better documentation system, hosted in lemmy itself.
+- [Huge DB performance gains](https://github.com/LemmyNet/lemmy/issues/411) (everthing down to < `30ms`) by using materialized views. 
+- Fixed major issue with similar post URL and title searching.
+- Upgraded to Actix `2.0`
+- Faster comment / post voting.
+- Better small screen support.
+- Lots of bug fixes, refactoring of back end code.
+
+Another major announcement is that Lemmy now has another lead developer besides me, [@felix@radical.town](https://radical.town/@felix). Theyve created a better documentation system, implemented RSS feeds, simplified docker and project configs, upgraded actix, working on federation, a whole lot else.
+
+https://lemmy.ml

SECURITY.md

@@ -1,5 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Use [Github's security advisory issue system](https://github.com/LemmyNet/lemmy/security/advisories/new).

ansible/VERSION

@@ -0,0 +1 @@
+0.9.7

ansible/ansible.cfg

@@ -0,0 +1,6 @@
+[defaults]
+inventory = inventory
+interpreter_python = /usr/bin/python3
+
+[ssh_connection]
+pipelining = True

ansible/inventory.example

@@ -0,0 +1,12 @@
+[lemmy]
+# to get started, copy this file to `inventory` and adjust the values below.
+# - `myuser@example.com`: replace with the destination you use to connect to your server via ssh
+# - `domain=example.com`: replace `example.com` with your lemmy domain
+# - `letsencrypt_contact_email=your@email.com` replace `your@email.com` with your email address,
+#                                              to get notifications if your ssl cert expires
+# - `lemmy_base_dir=/srv/lemmy`: the location on the server where lemmy can be installed, can be any folder
+#                                if you are upgrading from a previous version, set this to `/lemmy`
+myuser@example.com  domain=example.com  letsencrypt_contact_email=your@email.com lemmy_base_dir=/srv/lemmy
+
+[all:vars]
+ansible_connection=ssh

ansible/lemmy.yml

@@ -0,0 +1,119 @@
+---
+- hosts: all
+
+  # Install python if required
+  # https://www.josharcher.uk/code/ansible-python-connection-failure-ubuntu-server-1604/
+  gather_facts: False
+  pre_tasks:
+    - name: check lemmy_base_dir
+      fail:
+        msg: "`lemmy_base_dir` is unset. if you are upgrading from an older version, add `lemmy_base_dir=/lemmy` to your inventory file."
+      when: lemmy_base_dir is not defined
+
+    - name: install python for Ansible
+      # python2-minimal instead of python-minimal for ubuntu 20.04 and up
+      raw: test -e /usr/bin/python || (apt -y update && apt install -y python3-minimal python3-setuptools)
+      args:
+        executable: /bin/bash
+      register: output
+      changed_when: output.stdout != ''
+
+    - setup: # gather facts
+
+  tasks:
+  - name: install dependencies
+    apt:
+      pkg:
+        - 'nginx'
+        - 'docker-compose'
+        - 'docker.io'
+        - 'certbot'
+
+  - name: install certbot-nginx on ubuntu < 20
+    apt:
+      pkg:
+        - 'python-certbot-nginx'
+    when: ansible_distribution == 'Ubuntu' and ansible_distribution_version is version('20.04', '<')
+
+  - name: install certbot-nginx on ubuntu > 20
+    apt:
+      pkg:
+        - 'python3-certbot-nginx'
+    when: ansible_distribution == 'Ubuntu' and ansible_distribution_version is version('20.04', '>=')
+
+  - name: request initial letsencrypt certificate
+    command: certbot certonly --nginx --agree-tos -d '{{ domain }}' -m '{{ letsencrypt_contact_email }}'
+    args:
+      creates: '/etc/letsencrypt/live/{{domain}}/privkey.pem'
+
+  - name: create lemmy folder
+    file:
+      path: '{{item.path}}'
+      owner: '{{item.owner}}'
+      state: directory
+    with_items:
+      - path: '{{lemmy_base_dir}}'
+        owner: 'root'
+      - path: '{{lemmy_base_dir}}/volumes/'
+        owner: 'root'
+      - path: '{{lemmy_base_dir}}/volumes/pictrs/'
+        owner: '991'
+
+  - block:
+    - name:  add template files
+      template:
+        src: '{{item.src}}'
+        dest: '{{item.dest}}'
+        mode: '{{item.mode}}'
+      with_items:
+        - src: 'templates/docker-compose.yml'
+          dest: '{{lemmy_base_dir}}/docker-compose.yml'
+          mode: '0600'
+        - src: 'templates/nginx.conf'
+          dest: '/etc/nginx/sites-enabled/lemmy.conf'
+          mode: '0644'
+        - src: '../docker/iframely.config.local.js'
+          dest: '{{lemmy_base_dir}}/iframely.config.local.js'
+          mode: '0600'
+      vars:
+        lemmy_docker_image: "dessalines/lemmy:{{ lookup('file', 'VERSION') }}"
+        lemmy_docker_ui_image: "dessalines/lemmy-ui:{{ lookup('file', 'VERSION') }}"
+        lemmy_port: "8536"
+        lemmy_ui_port: "1235"
+        pictshare_port: "8537"
+        iframely_port: "8538"
+
+    - name:  add config file (only during initial setup)
+      template:
+        src: 'templates/config.hjson'
+        dest: '{{lemmy_base_dir}}/lemmy.hjson'
+        mode: '0600'
+        force: false
+        owner: '1000'
+        group: '1000'
+    vars:
+      postgres_password: "{{ lookup('password', 'passwords/{{ inventory_hostname }}/postgres chars=ascii_letters,digits') }}"
+      jwt_password: "{{ lookup('password', 'passwords/{{ inventory_hostname }}/jwt chars=ascii_letters,digits') }}"
+
+  - name: enable and start docker service
+    systemd:
+      name: docker
+      enabled: yes
+      state: started
+
+  - name: start docker-compose
+    docker_compose:
+      project_src: '{{lemmy_base_dir}}'
+      state: present
+      pull: yes
+      remove_orphans: yes
+
+  - name: reload nginx with new config
+    shell: nginx -s reload
+
+  - name: certbot renewal cronjob
+    cron:
+      special_time: daily
+      name: certbot-renew-lemmy
+      user: root
+      job: "certbot certonly --nginx -d '{{ domain }}' --deploy-hook 'nginx -s reload'"

ansible/lemmy_dev.yml

@@ -0,0 +1,141 @@
+---
+- hosts: all
+  vars:
+    lemmy_docker_image: 'lemmy:dev'
+
+  # Install python if required
+  # https://www.josharcher.uk/code/ansible-python-connection-failure-ubuntu-server-1604/
+  gather_facts: False
+  pre_tasks:
+    - name: check lemmy_base_dir
+      fail:
+        msg: "`lemmy_base_dir` is unset. if you are upgrading from an older version, add `lemmy_base_dir=/lemmy` to your inventory file."
+      when: lemmy_base_dir is not defined
+
+    - name: install python for Ansible
+      raw: test -e /usr/bin/python || (apt -y update && apt install -y python-minimal python-setuptools)
+      args:
+        executable: /bin/bash
+      register: output
+      changed_when: output.stdout != ''
+    - setup: # gather facts
+
+  tasks:
+  - name: install dependencies
+    apt:
+      pkg:
+        - 'nginx'
+        - 'docker-compose'
+        - 'docker.io'
+        - 'certbot'
+        - 'python-certbot-nginx'
+
+  - name: request initial letsencrypt certificate
+    command: certbot certonly --nginx --agree-tos -d '{{ domain }}' -m '{{ letsencrypt_contact_email }}'
+    args:
+      creates: '/etc/letsencrypt/live/{{domain}}/privkey.pem'
+
+  - name: create lemmy folder
+    file:
+      path: '{{item.path}}'
+      owner: '{{item.owner}}'
+      state: directory
+    with_items:
+      - path: '{{lemmy_base_dir}}/lemmy/'
+        owner: 'root'
+      - path: '{{lemmy_base_dir}}/volumes/'
+        owner: 'root'
+      - path: '{{lemmy_base_dir}}/volumes/pictrs/'
+        owner: '991'
+
+  - block:
+    - name:  add template files
+      template:
+        src: '{{item.src}}'
+        dest: '{{item.dest}}'
+        mode: '{{item.mode}}'
+      with_items:
+        - src: 'templates/docker-compose.yml'
+          dest: '{{lemmy_base_dir}}/docker-compose.yml'
+          mode: '0600'
+        - src: 'templates/nginx.conf'
+          dest: '/etc/nginx/sites-enabled/lemmy.conf'
+          mode: '0644'
+        - src: '../docker/iframely.config.local.js'
+          dest: '{{lemmy_base_dir}}/iframely.config.local.js'
+          mode: '0600'
+
+    - name:  add config file (only during initial setup)
+      template:
+        src: 'templates/config.hjson'
+        dest: '{{lemmy_base_dir}}/lemmy.hjson'
+        mode: '0600'
+        force: false
+        owner: '1000'
+        group: '1000'
+      vars:
+        postgres_password: "{{ lookup('password', 'passwords/{{ inventory_hostname }}/postgres chars=ascii_letters,digits') }}"
+        jwt_password: "{{ lookup('password', 'passwords/{{ inventory_hostname }}/jwt chars=ascii_letters,digits') }}"
+
+  - name: build the dev docker image
+    local_action: shell cd .. && sudo docker build . -f docker/dev/Dockerfile -t lemmy:dev
+    register: image_build
+
+  - name: find hash of the new docker image
+    set_fact:
+      image_hash: "{{ image_build.stdout | regex_search('(?<=Successfully built )[0-9a-f]{12}') }}"
+
+  # this does not use become so that the output file is written as non-root user and is easy to delete later
+  - name: save dev docker image to file
+    local_action: shell sudo docker save lemmy:dev > lemmy-dev.tar
+
+  - name: copy dev docker image to server
+    copy:
+      src: lemmy-dev.tar
+      dest: '{{lemmy_base_dir}}/lemmy-dev.tar'
+
+  - name: import docker image
+    docker_image:
+      name: lemmy
+      tag: dev
+      load_path: '{{lemmy_base_dir}}/lemmy-dev.tar'
+      source: load
+      force_source: yes
+    register: image_import
+
+  - name: delete remote image file
+    file:
+      path: '{{lemmy_base_dir}}/lemmy-dev.tar'
+      state: absent
+
+  - name: delete local image file
+    local_action:
+      module: file
+      path: lemmy-dev.tar
+      state: absent
+
+  - name: enable and start docker service
+    systemd:
+      name: docker
+      enabled: yes
+      state: started
+
+  # cant pull here because that fails due to lemmy:dev (without dessalines/) not being on docker hub, but that shouldnt
+  # be a problem for testing
+  - name: start docker-compose
+    docker_compose:
+      project_src: '{{lemmy_base_dir}}'
+      state: present
+      recreate: always
+      remove_orphans: yes
+    ignore_errors: yes
+
+  - name: reload nginx with new config
+    shell: nginx -s reload
+
+  - name: certbot renewal cronjob
+    cron:
+      special_time: daily
+      name: certbot-renew-lemmy
+      user: root
+      job: "certbot certonly --nginx -d '{{ domain }}' --deploy-hook 'nginx -s reload'"

ansible/templates/config.hjson

@@ -0,0 +1,36 @@
+{
+  # for more info about the config, check out the documentation
+  # https://join.lemmy.ml/docs/en/administration/configuration.html
+
+  # settings related to the postgresql database
+  database: {
+    # password to connect to postgres
+    password: "{{ postgres_password }}"
+    # host where postgres is running
+    host: "postgres"
+  }
+  # the domain name of your instance (eg "lemmy.ml")
+  hostname: "{{ domain }}"
+  # json web token for authorization between server and client
+  jwt_secret: "{{ jwt_password }}"
+  # email sending configuration
+  email: {
+    # hostname of the smtp server
+    smtp_server: "postfix:25"
+    # address to send emails from, eg "noreply@your-instance.com"
+    smtp_from_address: "noreply@{{ domain }}"
+    use_tls: false
+  }
+  # settings related to activitypub federation
+  federation: {
+    # whether to enable activitypub federation. 
+    enabled: false
+    # Allows and blocks are described here:
+    # https://join.lemmy.ml/docs/en/federation/administration.html#instance-allowlist-and-blocklist
+    #
+    # comma separated list of instances with which federation is allowed
+    # allowed_instances: ""
+    # comma separated list of instances which are blocked from federating
+    # blocked_instances: ""
+  }
+}

ansible/templates/docker-compose.yml

@@ -0,0 +1,61 @@
+version: '3.3'
+
+services:
+  lemmy:
+    image: {{ lemmy_docker_image }}
+    ports:
+      - "127.0.0.1:8536:8536"
+    restart: always
+    environment:
+      - RUST_LOG=error
+    volumes:
+      - ./lemmy.hjson:/config/config.hjson:ro
+    depends_on:
+      - postgres
+      - pictrs
+      - iframely
+
+  lemmy-ui:
+    image: {{ lemmy_docker_ui_image }}
+    ports:
+      - "127.0.0.1:1235:1234"
+    restart: always
+    environment:
+      - LEMMY_INTERNAL_HOST=lemmy:8536
+      - LEMMY_EXTERNAL_HOST={{ domain }}
+      - LEMMY_HTTPS=true
+    depends_on: 
+      - lemmy
+
+  postgres:
+    image: postgres:12-alpine
+    environment:
+      - POSTGRES_USER=lemmy
+      - POSTGRES_PASSWORD={{ postgres_password }}
+      - POSTGRES_DB=lemmy
+    volumes:
+      - ./volumes/postgres:/var/lib/postgresql/data
+    restart: always
+
+  pictrs:
+    image: asonix/pictrs:v0.2.5-r0
+    user: 991:991
+    ports:
+      - "127.0.0.1:8537:8080"
+    volumes:
+      - ./volumes/pictrs:/mnt
+    restart: always
+
+  iframely:
+    image: dogbin/iframely:latest
+    ports:
+      - "127.0.0.1:8061:80"
+    volumes:
+      - ./iframely.config.local.js:/iframely/config.local.js:ro
+    restart: always
+
+  postfix:
+    image: mwader/postfix-relay
+    environment:
+      - POSTFIX_myhostname={{ domain }}
+    restart: "always"

ansible/templates/nginx.conf

@@ -0,0 +1,121 @@
+limit_req_zone $binary_remote_addr zone=lemmy_ratelimit:10m rate=1r/s;
+
+server {
+    listen 80;
+    server_name {{ domain }};
+    location /.well-known/acme-challenge/ {
+        root /var/www/certbot;
+    }
+    location / {
+        return 301 https://$host$request_uri;
+    }
+}
+
+server {
+    listen 443 ssl http2;
+    server_name {{ domain }};
+
+    ssl_certificate /etc/letsencrypt/live/{{domain}}/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/{{domain}}/privkey.pem;
+
+    # Various TLS hardening settings
+    # https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_prefer_server_ciphers on;
+    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256';
+    ssl_session_timeout  10m;
+    ssl_session_cache shared:SSL:10m;
+    ssl_session_tickets off;
+    ssl_stapling on;
+    ssl_stapling_verify on;
+
+    # Hide nginx version
+    server_tokens off;
+
+    # Enable compression for JS/CSS/HTML bundle, for improved client load times.
+    # It might be nice to compress JSON, but leaving that out to protect against potential
+    # compression+encryption information leak attacks like BREACH.
+    gzip on;
+    gzip_types text/css application/javascript image/svg+xml;
+    gzip_vary on;
+
+    # Only connect to this site via HTTPS for the two years
+    add_header Strict-Transport-Security "max-age=63072000";
+
+    # Various content security headers
+    add_header Referrer-Policy "same-origin";
+    add_header X-Content-Type-Options "nosniff";
+    add_header X-Frame-Options "DENY";
+    add_header X-XSS-Protection "1; mode=block";
+
+    # Upload limit for pictrs
+    client_max_body_size 20M;
+
+    # frontend
+    location / {
+      # The default ports:
+      # lemmy_ui_port: 1235
+      # lemmy_port: 8536
+
+      set $proxpass "http://0.0.0.0:{{ lemmy_ui_port }}";
+      if ($http_accept = "application/activity+json") {
+        set $proxpass "http://0.0.0.0:{{ lemmy_port }}";
+      }
+      if ($http_accept = "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"") {
+        set $proxpass "http://0.0.0.0:{{ lemmy_port }}";
+      }
+      if ($request_method = POST) {
+        set $proxpass "http://0.0.0.0:{{ lemmy_port }}";
+      }
+      proxy_pass $proxpass;
+
+      rewrite ^(.+)/+$ $1 permanent;
+
+      # Send actual client IP upstream
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header Host $host;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+
+    # backend
+    location ~ ^/(api|pictrs|feeds|nodeinfo|.well-known) {
+      proxy_pass http://0.0.0.0:{{ lemmy_port }};
+      proxy_http_version 1.1;
+      proxy_set_header Upgrade $http_upgrade;
+      proxy_set_header Connection "upgrade";
+
+      # Rate limit
+      limit_req zone=lemmy_ratelimit burst=30 nodelay;
+
+      # Add IP forwarding headers
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header Host $host;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+
+
+    # Redirect pictshare images to pictrs
+    location ~ /pictshare/(.*)$ {
+      return 301 /pictrs/image/$1;
+    }
+
+    location /iframely/ {
+      proxy_pass http://0.0.0.0:8061/;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header Host $host;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+}
+
+# Anonymize IP addresses
+# https://www.supertechcrew.com/anonymizing-logs-nginx-apache/
+map $remote_addr $remote_addr_anon {
+  ~(?P<ip>\d+\.\d+\.\d+)\.    $ip.0;
+  ~(?P<ip>[^:]+:[^:]+):       $ip::;
+  127.0.0.1                   $remote_addr;
+  ::1                         $remote_addr;
+  default                     0.0.0.0;
+}
+log_format main '$remote_addr_anon - $remote_user [$time_local] "$request" '
+'$status $body_bytes_sent "$http_referer" "$http_user_agent"';
+access_log /var/log/nginx/access.log main;

ansible/uninstall.yml

@@ -0,0 +1,54 @@
+---
+- hosts: all
+
+  vars_prompt:
+
+    - name: confirm_uninstall
+      prompt: "Do you really want to uninstall Lemmy? This will delete all data and can not be reverted [yes/no]"
+      private: no
+
+    - name: delete_certs
+      prompt: "Delete certificates? Select 'no' if you want to reinstall Lemmy [yes/no]"
+      private: no
+
+  tasks:
+  - name: end play if no confirmation was given
+    debug:
+      msg: "Uninstall cancelled, doing nothing"
+    when: not confirm_uninstall|bool
+
+  - meta: end_play
+    when: not confirm_uninstall|bool
+
+  - name: stop docker-compose
+    docker_compose:
+      project_src: '{{lemmy_base_dir}}'
+      state: absent
+
+  - name: delete data
+    file:
+      path: '{{item.path}}'
+      state: absent
+    with_items:
+      - path: '{{lemmy_base_dir}}'
+      - path: '/etc/nginx/sites-enabled/lemmy.conf'
+
+  - name: Remove a volume
+    docker_volume:
+      name: '{{item.name}}'
+      state: absent
+    with_items:
+      - name: 'lemmy_lemmy_db'
+      - name: 'lemmy_lemmy_pictshare'
+
+  - name: delete entire ecloud folder
+    file:
+      path: '/mnt/repo-base/'
+      state: absent
+    when: delete_certs|bool
+
+  - name: remove certbot cronjob
+    cron:
+      name: certbot-renew-lemmy
+      state: absent
+

api_tests/.eslintrc.json

@@ -3,18 +3,27 @@
   "env": {
     "browser": true
   },
-  "plugins": ["@typescript-eslint"],
-  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  "plugins": [
+    "jane"
+  ],
+  "extends": [
+    "plugin:jane/recommended",
+    "plugin:jane/typescript"
+  ],
   "parser": "@typescript-eslint/parser",
   "parserOptions": {
     "project": "./tsconfig.json",
     "warnOnUnsupportedTypeScriptVersion": false
   },
   "rules": {
-    "@typescript-eslint/ban-ts-comment": 0,
+    "@typescript-eslint/camelcase": 0,
+    "@typescript-eslint/member-delimiter-style": 0,
+    "@typescript-eslint/no-empty-interface": 0,
     "@typescript-eslint/no-explicit-any": 0,
-    "@typescript-eslint/explicit-module-boundary-types": 0,
-    "@typescript-eslint/no-var-requires": 0,
+    "@typescript-eslint/no-this-alias": 0,
+    "@typescript-eslint/no-unused-vars": 0,
+    "@typescript-eslint/no-use-before-define": 0,
+    "@typescript-eslint/no-useless-constructor": 0,
     "arrow-body-style": 0,
     "curly": 0,
     "eol-last": 0,

api_tests/.npmrc

@@ -1 +0,0 @@
-package-manager-strict=false

api_tests/.prettierrc.js

@@ -0,0 +1,4 @@
+module.exports = Object.assign(require('eslint-plugin-jane/prettier-ts'), {
+  arrowParens: 'avoid',
+  semi: true,
+});

api_tests/.prettierrc.json

@@ -1,4 +0,0 @@
-{
-  "arrowParens": "avoid",
-  "semi": true
-}

api_tests/jest.config.js

@@ -1,4 +1,4 @@
 module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-};
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

api_tests/package.json

@@ -6,31 +6,20 @@
   "repository": "https://github.com/LemmyNet/lemmy",
   "author": "Dessalines",
   "license": "AGPL-3.0",
-  "packageManager": "pnpm@9.1.1+sha256.9551e803dcb7a1839fdf5416153a844060c7bce013218ce823410532504ac10b",
   "scripts": {
-    "lint": "tsc --noEmit && eslint --report-unused-disable-directives --ext .js,.ts,.tsx src && prettier --check 'src/**/*.ts'",
+    "lint": "tsc --noEmit && eslint --report-unused-disable-directives --ext .js,.ts,.tsx src",
     "fix": "prettier --write src && eslint --fix src",
-    "api-test": "jest -i follow.spec.ts && jest -i image.spec.ts && jest -i user.spec.ts && jest -i private_message.spec.ts && jest -i community.spec.ts &&  jest -i post.spec.ts && jest -i comment.spec.ts ",
-    "api-test-follow": "jest -i follow.spec.ts",
-    "api-test-comment": "jest -i comment.spec.ts",
-    "api-test-post": "jest -i post.spec.ts",
-    "api-test-user": "jest -i user.spec.ts",
-    "api-test-community": "jest -i community.spec.ts",
-    "api-test-private-message": "jest -i private_message.spec.ts",
-    "api-test-image": "jest -i image.spec.ts"
+    "api-test": "jest src/ -i --verbose"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.12.4",
-    "@typescript-eslint/eslint-plugin": "^7.5.0",
-    "@typescript-eslint/parser": "^7.5.0",
-    "download-file-sync": "^1.0.4",
-    "eslint": "^8.57.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "jest": "^29.5.0",
-    "lemmy-js-client": "0.19.4-alpha.18",
-    "prettier": "^3.2.5",
-    "ts-jest": "^29.1.0",
-    "typescript": "^5.4.4"
+    "@types/jest": "^26.0.20",
+    "eslint": "^7.18.0",
+    "eslint-plugin-jane": "^9.0.3",
+    "jest": "^26.6.3",
+    "lemmy-js-client": "0.9.1-rc.1",
+    "node-fetch": "^2.6.1",
+    "prettier": "^2.1.2",
+    "ts-jest": "^26.4.4",
+    "typescript": "^4.1.3"
   }
 }

api_tests/prepare-drone-federation-test.sh

@@ -1,34 +1,18 @@
-#!/usr/bin/env bash
-# IMPORTANT NOTE: this script does not use the normal LEMMY_DATABASE_URL format
-#   it is expected that this script is called by run-federation-test.sh script.
+#!/bin/bash
 set -e
 
-if [ -z "$LEMMY_LOG_LEVEL" ];
-then
-  LEMMY_LOG_LEVEL=info
-fi
-
+export LEMMY_JWT_SECRET=changeme
+export LEMMY_FEDERATION__ENABLED=true
+export LEMMY_TLS_ENABLED=false
+export LEMMY_SETUP__ADMIN_PASSWORD=lemmy
+export LEMMY_RATE_LIMIT__POST=99999
+export LEMMY_RATE_LIMIT__REGISTER=99999
+export LEMMY_CAPTCHA__ENABLED=false
+export LEMMY_TEST_SEND_SYNC=1
 export RUST_BACKTRACE=1
-export RUST_LOG="warn,lemmy_server=$LEMMY_LOG_LEVEL,lemmy_federate=$LEMMY_LOG_LEVEL,lemmy_api=$LEMMY_LOG_LEVEL,lemmy_api_common=$LEMMY_LOG_LEVEL,lemmy_api_crud=$LEMMY_LOG_LEVEL,lemmy_apub=$LEMMY_LOG_LEVEL,lemmy_db_schema=$LEMMY_LOG_LEVEL,lemmy_db_views=$LEMMY_LOG_LEVEL,lemmy_db_views_actor=$LEMMY_LOG_LEVEL,lemmy_db_views_moderator=$LEMMY_LOG_LEVEL,lemmy_routes=$LEMMY_LOG_LEVEL,lemmy_utils=$LEMMY_LOG_LEVEL,lemmy_websocket=$LEMMY_LOG_LEVEL"
-
-export LEMMY_TEST_FAST_FEDERATION=1 # by default, the persistent federation queue has delays in the scale of 30s-5min
-
-# pictrs setup
-if [ ! -f "api_tests/pict-rs" ]; then
-  curl "https://git.asonix.dog/asonix/pict-rs/releases/download/v0.5.13/pict-rs-linux-amd64" -o api_tests/pict-rs
-  chmod +x api_tests/pict-rs
-fi
-./api_tests/pict-rs \
-  run -a 0.0.0.0:8080 \
-  --danger-dummy-mode \
-  --api-key "my-pictrs-key" \
-  filesystem -p /tmp/pictrs/files \
-  sled -p /tmp/pictrs/sled-repo 2>&1 &
 
 for INSTANCE in lemmy_alpha lemmy_beta lemmy_gamma lemmy_delta lemmy_epsilon; do
-  echo "DB URL: ${LEMMY_DATABASE_URL} INSTANCE: $INSTANCE"
   psql "${LEMMY_DATABASE_URL}/lemmy" -c "DROP DATABASE IF EXISTS $INSTANCE"
-  echo "create database"
   psql "${LEMMY_DATABASE_URL}/lemmy" -c "CREATE DATABASE $INSTANCE"
 done
 
@@ -45,50 +29,62 @@ if [ -z "$DO_WRITE_HOSTS_FILE" ]; then
   fi
 else
   for INSTANCE in lemmy-alpha lemmy-beta lemmy-gamma lemmy-delta lemmy-epsilon; do
-    echo "127.0.0.1 $INSTANCE" >>/etc/hosts
+    echo "127.0.0.1 $INSTANCE" >> /etc/hosts
   done
 fi
 
-echo "$PWD"
-
-LOG_DIR=target/log
-mkdir -p $LOG_DIR
+killall lemmy_server || true
 
 echo "start alpha"
-LEMMY_CONFIG_LOCATION=./docker/federation/lemmy_alpha.hjson \
+LEMMY_HOSTNAME=lemmy-alpha:8541 \
+  LEMMY_PORT=8541 \
   LEMMY_DATABASE_URL="${LEMMY_DATABASE_URL}/lemmy_alpha" \
-  target/lemmy_server >$LOG_DIR/lemmy_alpha.out 2>&1 &
+  LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-beta,lemmy-gamma,lemmy-delta,lemmy-epsilon \
+  LEMMY_SETUP__ADMIN_USERNAME=lemmy_alpha \
+  LEMMY_SETUP__SITE_NAME=lemmy-alpha \
+  target/lemmy_server >/dev/null 2>&1 &
 
 echo "start beta"
-LEMMY_CONFIG_LOCATION=./docker/federation/lemmy_beta.hjson \
+LEMMY_HOSTNAME=lemmy-beta:8551 \
+  LEMMY_PORT=8551 \
   LEMMY_DATABASE_URL="${LEMMY_DATABASE_URL}/lemmy_beta" \
-  target/lemmy_server >$LOG_DIR/lemmy_beta.out 2>&1 &
+  LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-alpha,lemmy-gamma,lemmy-delta,lemmy-epsilon \
+  LEMMY_SETUP__ADMIN_USERNAME=lemmy_beta \
+  LEMMY_SETUP__SITE_NAME=lemmy-beta \
+  target/lemmy_server >/dev/null 2>&1 &
 
 echo "start gamma"
-LEMMY_CONFIG_LOCATION=./docker/federation/lemmy_gamma.hjson \
+LEMMY_HOSTNAME=lemmy-gamma:8561 \
+  LEMMY_PORT=8561 \
   LEMMY_DATABASE_URL="${LEMMY_DATABASE_URL}/lemmy_gamma" \
-  target/lemmy_server >$LOG_DIR/lemmy_gamma.out 2>&1 &
+  LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-alpha,lemmy-beta,lemmy-delta,lemmy-epsilon \
+  LEMMY_SETUP__ADMIN_USERNAME=lemmy_gamma \
+  LEMMY_SETUP__SITE_NAME=lemmy-gamma \
+  target/lemmy_server >/dev/null 2>&1 &
 
 echo "start delta"
 # An instance with only an allowlist for beta
-LEMMY_CONFIG_LOCATION=./docker/federation/lemmy_delta.hjson \
+LEMMY_HOSTNAME=lemmy-delta:8571 \
+  LEMMY_PORT=8571 \
   LEMMY_DATABASE_URL="${LEMMY_DATABASE_URL}/lemmy_delta" \
-  target/lemmy_server >$LOG_DIR/lemmy_delta.out 2>&1 &
+  LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-beta \
+  LEMMY_SETUP__ADMIN_USERNAME=lemmy_delta \
+  LEMMY_SETUP__SITE_NAME=lemmy-delta \
+  target/lemmy_server >/dev/null 2>&1 &
 
 echo "start epsilon"
 # An instance who has a blocklist, with lemmy-alpha blocked
-LEMMY_CONFIG_LOCATION=./docker/federation/lemmy_epsilon.hjson \
+LEMMY_HOSTNAME=lemmy-epsilon:8581 \
+  LEMMY_PORT=8581 \
   LEMMY_DATABASE_URL="${LEMMY_DATABASE_URL}/lemmy_epsilon" \
-  target/lemmy_server >$LOG_DIR/lemmy_epsilon.out 2>&1 &
+  LEMMY_FEDERATION__BLOCKED_INSTANCES=lemmy-alpha \
+  LEMMY_SETUP__ADMIN_USERNAME=lemmy_epsilon \
+  LEMMY_SETUP__SITE_NAME=lemmy-epsilon \
+  target/lemmy_server >/dev/null 2>&1 &
 
 echo "wait for all instances to start"
-while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'lemmy-alpha:8541/api/v3/site')" != "200" ]]; do sleep 1; done
-echo "alpha started"
-while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'lemmy-beta:8551/api/v3/site')" != "200" ]]; do sleep 1; done
-echo "beta started"
-while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'lemmy-gamma:8561/api/v3/site')" != "200" ]]; do sleep 1; done
-echo "gamma started"
-while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'lemmy-delta:8571/api/v3/site')" != "200" ]]; do sleep 1; done
-echo "delta started"
-while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'lemmy-epsilon:8581/api/v3/site')" != "200" ]]; do sleep 1; done
-echo "epsilon started. All started"
+while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'localhost:8541/api/v2/site')" != "200" ]]; do sleep 1; done
+while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'localhost:8551/api/v2/site')" != "200" ]]; do sleep 1; done
+while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'localhost:8561/api/v2/site')" != "200" ]]; do sleep 1; done
+while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'localhost:8571/api/v2/site')" != "200" ]]; do sleep 1; done
+while [[ "$(curl -s -o /dev/null -w '%{http_code}' 'localhost:8581/api/v2/site')" != "200" ]]; do sleep 1; done

api_tests/run-federation-test.sh

@@ -1,21 +1,20 @@
-#!/usr/bin/env bash
+#!/bin/bash
 set -e
 
 export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432
+
 pushd ..
-cargo build
+cargo +1.47.0 build
 rm target/lemmy_server || true
 cp target/debug/lemmy_server target/lemmy_server
-killall -s1 lemmy_server || true
 ./api_tests/prepare-drone-federation-test.sh
 popd
 
-pnpm i
-pnpm api-test || true
+yarn
+yarn api-test || true
+
+killall lemmy_server
 
-killall -s1 lemmy_server || true
-killall -s1 pict-rs || true
 for INSTANCE in lemmy_alpha lemmy_beta lemmy_gamma lemmy_delta lemmy_epsilon; do
   psql "$LEMMY_DATABASE_URL" -c "DROP DATABASE $INSTANCE"
 done
-rm -r /tmp/pictrs

api_tests/src/comment.spec.ts

@@ -1,6 +1,4 @@
 jest.setTimeout(180000);
-
-import { PostResponse } from "lemmy-js-client/dist/types/PostResponse";
 import {
   alpha,
   beta,
@@ -8,542 +6,305 @@ import {
   setupLogins,
   createPost,
   getPost,
-  resolveComment,
+  searchComment,
   likeComment,
   followBeta,
-  resolveBetaCommunity,
+  searchForBetaCommunity,
   createComment,
   editComment,
   deleteComment,
   removeComment,
   getMentions,
-  resolvePost,
+  searchPost,
   unfollowRemotes,
   createCommunity,
   registerUser,
-  reportComment,
-  listCommentReports,
-  randomString,
-  unfollows,
-  getComments,
-  getCommentParentId,
-  resolveCommunity,
-  getPersonDetails,
-  getReplies,
-  getUnreadCount,
-  waitUntil,
-  waitForPost,
-  alphaUrl,
-  followCommunity,
-  blockCommunity,
-  delay,
-} from "./shared";
-import { CommentView, CommunityView } from "lemmy-js-client";
+  API,
+} from './shared';
+import { CommentView } from 'lemmy-js-client';
 
-let betaCommunity: CommunityView | undefined;
-let postOnAlphaRes: PostResponse;
+import { PostResponse } from 'lemmy-js-client';
+
+let postRes: PostResponse;
 
 beforeAll(async () => {
   await setupLogins();
-  await Promise.all([followBeta(alpha), followBeta(gamma)]);
-  betaCommunity = (await resolveBetaCommunity(alpha)).community;
-  if (betaCommunity) {
-    postOnAlphaRes = await createPost(alpha, betaCommunity.community.id);
-  }
+  await followBeta(alpha);
+  await followBeta(gamma);
+  let search = await searchForBetaCommunity(alpha);
+  postRes = await createPost(
+    alpha,
+    search.communities.find(c => c.community.local == false).community.id
+  );
 });
 
-afterAll(unfollows);
+afterAll(async () => {
+  await unfollowRemotes(alpha);
+  await unfollowRemotes(gamma);
+});
 
 function assertCommentFederation(
-  commentOne?: CommentView,
-  commentTwo?: CommentView,
+  commentOne: CommentView,
+  commentTwo: CommentView
 ) {
-  expect(commentOne?.comment.ap_id).toBe(commentTwo?.comment.ap_id);
-  expect(commentOne?.comment.content).toBe(commentTwo?.comment.content);
-  expect(commentOne?.creator.name).toBe(commentTwo?.creator.name);
-  expect(commentOne?.community.actor_id).toBe(commentTwo?.community.actor_id);
-  expect(commentOne?.comment.published).toBe(commentTwo?.comment.published);
-  expect(commentOne?.comment.updated).toBe(commentOne?.comment.updated);
-  expect(commentOne?.comment.deleted).toBe(commentOne?.comment.deleted);
-  expect(commentOne?.comment.removed).toBe(commentOne?.comment.removed);
+  expect(commentOne.comment.ap_id).toBe(commentOne.comment.ap_id);
+  expect(commentOne.comment.content).toBe(commentTwo.comment.content);
+  expect(commentOne.creator.name).toBe(commentTwo.creator.name);
+  expect(commentOne.community.actor_id).toBe(commentTwo.community.actor_id);
+  expect(commentOne.comment.published).toBe(commentTwo.comment.published);
+  expect(commentOne.comment.updated).toBe(commentOne.comment.updated);
+  expect(commentOne.comment.deleted).toBe(commentOne.comment.deleted);
+  expect(commentOne.comment.removed).toBe(commentOne.comment.removed);
 }
 
-test("Create a comment", async () => {
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
+test('Create a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
   expect(commentRes.comment_view.comment.content).toBeDefined();
   expect(commentRes.comment_view.community.local).toBe(false);
   expect(commentRes.comment_view.creator.local).toBe(true);
   expect(commentRes.comment_view.counts.score).toBe(1);
 
   // Make sure that comment is liked on beta
-  let betaComment = (
-    await waitUntil(
-      () => resolveComment(beta, commentRes.comment_view.comment),
-      c => c.comment?.counts.score === 1,
-    )
-  ).comment;
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  let betaComment = searchBeta.comments[0];
   expect(betaComment).toBeDefined();
-  expect(betaComment?.community.local).toBe(true);
-  expect(betaComment?.creator.local).toBe(false);
-  expect(betaComment?.counts.score).toBe(1);
+  expect(betaComment.community.local).toBe(true);
+  expect(betaComment.creator.local).toBe(false);
+  expect(betaComment.counts.score).toBe(1);
   assertCommentFederation(betaComment, commentRes.comment_view);
 });
 
-test("Create a comment in a non-existent post", async () => {
-  await expect(createComment(alpha, -1)).rejects.toStrictEqual(
-    Error("couldnt_find_post"),
-  );
+test('Create a comment in a non-existent post', async () => {
+  let commentRes = await createComment(alpha, -1);
+  expect(commentRes).toStrictEqual({ error: 'couldnt_find_post' });
 });
 
-test("Update a comment", async () => {
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
+test('Update a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
   // Federate the comment first
-  let betaComment = (
-    await resolveComment(beta, commentRes.comment_view.comment)
-  ).comment;
-  assertCommentFederation(betaComment, commentRes.comment_view);
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  assertCommentFederation(searchBeta.comments[0], commentRes.comment_view);
 
   let updateCommentRes = await editComment(
     alpha,
-    commentRes.comment_view.comment.id,
+    commentRes.comment_view.comment.id
   );
   expect(updateCommentRes.comment_view.comment.content).toBe(
-    "A jest test federated comment update",
+    'A jest test federated comment update'
   );
   expect(updateCommentRes.comment_view.community.local).toBe(false);
   expect(updateCommentRes.comment_view.creator.local).toBe(true);
 
   // Make sure that post is updated on beta
-  let betaCommentUpdated = (
-    await waitUntil(
-      () => resolveComment(beta, commentRes.comment_view.comment),
-      c =>
-        c.comment?.comment.content === "A jest test federated comment update",
-    )
-  ).comment;
-  assertCommentFederation(betaCommentUpdated, updateCommentRes.comment_view);
+  let searchBetaUpdated = await searchComment(
+    beta,
+    commentRes.comment_view.comment
+  );
+  assertCommentFederation(
+    searchBetaUpdated.comments[0],
+    updateCommentRes.comment_view
+  );
 });
 
-test("Delete a comment", async () => {
-  let post = await createPost(alpha, betaCommunity!.community.id);
-  // creating a comment on alpha (remote from home of community)
-  let commentRes = await createComment(alpha, post.post_view.post.id);
-
-  // Find the comment on beta (home of community)
-  let betaComment = (
-    await resolveComment(beta, commentRes.comment_view.comment)
-  ).comment;
-  if (!betaComment) {
-    throw "Missing beta comment before delete";
-  }
-
-  // Find the comment on remote instance gamma
-  let gammaComment = (
-    await waitUntil(
-      () =>
-        resolveComment(gamma, commentRes.comment_view.comment).catch(e => e),
-      r => r.message !== "couldnt_find_object",
-    )
-  ).comment;
-  if (!gammaComment) {
-    throw "Missing gamma comment (remote-home-remote replication) before delete";
-  }
+test('Delete a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
 
   let deleteCommentRes = await deleteComment(
     alpha,
     true,
-    commentRes.comment_view.comment.id,
+    commentRes.comment_view.comment.id
   );
   expect(deleteCommentRes.comment_view.comment.deleted).toBe(true);
-  expect(deleteCommentRes.comment_view.comment.content).toBe("");
 
   // Make sure that comment is undefined on beta
-  await waitUntil(
-    () => resolveComment(beta, commentRes.comment_view.comment).catch(e => e),
-    e => e.message == "couldnt_find_object",
-  );
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  let betaComment = searchBeta.comments[0];
+  expect(betaComment).toBeUndefined();
 
-  // Make sure that comment is undefined on gamma after delete
-  await waitUntil(
-    () => resolveComment(gamma, commentRes.comment_view.comment).catch(e => e),
-    e => e.message === "couldnt_find_object",
-  );
-
-  // Test undeleting the comment
   let undeleteCommentRes = await deleteComment(
     alpha,
     false,
-    commentRes.comment_view.comment.id,
+    commentRes.comment_view.comment.id
   );
   expect(undeleteCommentRes.comment_view.comment.deleted).toBe(false);
 
   // Make sure that comment is undeleted on beta
-  let betaComment2 = (
-    await waitUntil(
-      () => resolveComment(beta, commentRes.comment_view.comment).catch(e => e),
-      e => e.message !== "couldnt_find_object",
-    )
-  ).comment;
-  expect(betaComment2?.comment.deleted).toBe(false);
-  assertCommentFederation(betaComment2, undeleteCommentRes.comment_view);
+  let searchBeta2 = await searchComment(beta, commentRes.comment_view.comment);
+  let betaComment2 = searchBeta2.comments[0];
+  expect(betaComment2.comment.deleted).toBe(false);
+  assertCommentFederation(
+    searchBeta2.comments[0],
+    undeleteCommentRes.comment_view
+  );
 });
 
-test.skip("Remove a comment from admin and community on the same instance", async () => {
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
+test('Remove a comment from admin and community on the same instance', async () => {
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
 
   // Get the id for beta
   let betaCommentId = (
-    await resolveComment(beta, commentRes.comment_view.comment)
-  ).comment?.comment.id;
-
-  if (!betaCommentId) {
-    throw "beta comment id is missing";
-  }
+    await searchComment(beta, commentRes.comment_view.comment)
+  ).comments[0].comment.id;
 
   // The beta admin removes it (the community lives on beta)
   let removeCommentRes = await removeComment(beta, true, betaCommentId);
   expect(removeCommentRes.comment_view.comment.removed).toBe(true);
 
   // Make sure that comment is removed on alpha (it gets pushed since an admin from beta removed it)
-  let refetchedPostComments = await getPersonDetails(
-    alpha,
-    commentRes.comment_view.comment.creator_id,
-  );
-  expect(refetchedPostComments.comments[0].comment.removed).toBe(true);
+  let refetchedPost = await getPost(alpha, postRes.post_view.post.id);
+  expect(refetchedPost.comments[0].comment.removed).toBe(true);
 
-  // beta will unremove the comment
   let unremoveCommentRes = await removeComment(beta, false, betaCommentId);
   expect(unremoveCommentRes.comment_view.comment.removed).toBe(false);
 
-  // Make sure that comment is unremoved on alpha
-  let refetchedPostComments2 = await getComments(
-    alpha,
-    postOnAlphaRes.post_view.post.id,
-  );
-  expect(refetchedPostComments2.comments[0].comment.removed).toBe(false);
+  // Make sure that comment is unremoved on beta
+  let refetchedPost2 = await getPost(alpha, postRes.post_view.post.id);
+  expect(refetchedPost2.comments[0].comment.removed).toBe(false);
   assertCommentFederation(
-    refetchedPostComments2.comments[0],
-    unremoveCommentRes.comment_view,
+    refetchedPost2.comments[0],
+    unremoveCommentRes.comment_view
   );
 });
 
-test("Remove a comment from admin and community on different instance", async () => {
-  let newAlphaApi = await registerUser(alpha, alphaUrl);
+test('Remove a comment from admin and community on different instance', async () => {
+  let alphaUser = await registerUser(alpha);
+  let newAlphaApi: API = {
+    client: alpha.client,
+    auth: alphaUser.jwt,
+  };
 
   // New alpha user creates a community, post, and comment.
   let newCommunity = await createCommunity(newAlphaApi);
   let newPost = await createPost(
     newAlphaApi,
-    newCommunity.community_view.community.id,
+    newCommunity.community_view.community.id
   );
   let commentRes = await createComment(newAlphaApi, newPost.post_view.post.id);
   expect(commentRes.comment_view.comment.content).toBeDefined();
 
   // Beta searches that to cache it, then removes it
-  let betaComment = (
-    await resolveComment(beta, commentRes.comment_view.comment)
-  ).comment;
-
-  if (!betaComment) {
-    throw "beta comment missing";
-  }
-
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  let betaComment = searchBeta.comments[0];
   let removeCommentRes = await removeComment(
     beta,
     true,
-    betaComment.comment.id,
+    betaComment.comment.id
   );
   expect(removeCommentRes.comment_view.comment.removed).toBe(true);
-  expect(removeCommentRes.comment_view.comment.content).toBe("");
-
-  // Comment text is also hidden from list
-  let listComments = await getComments(
-    beta,
-    removeCommentRes.comment_view.post.id,
-  );
-  expect(listComments.comments.length).toBe(1);
-  expect(listComments.comments[0].comment.removed).toBe(true);
-  expect(listComments.comments[0].comment.content).toBe("");
 
   // Make sure its not removed on alpha
-  let refetchedPostComments = await getComments(
-    alpha,
-    newPost.post_view.post.id,
-  );
-  expect(refetchedPostComments.comments[0].comment.removed).toBe(false);
-  assertCommentFederation(
-    refetchedPostComments.comments[0],
-    commentRes.comment_view,
-  );
+  let refetchedPost = await getPost(newAlphaApi, newPost.post_view.post.id);
+  expect(refetchedPost.comments[0].comment.removed).toBe(false);
+  assertCommentFederation(refetchedPost.comments[0], commentRes.comment_view);
 });
 
-test("Unlike a comment", async () => {
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
-
-  // Lemmy automatically creates 1 like (vote) by author of comment.
-  // Make sure that comment is liked (voted up) on gamma, downstream peer
-  // This is testing replication from remote-home-remote (alpha-beta-gamma)
-
-  let gammaComment1 = (
-    await waitUntil(
-      () => resolveComment(gamma, commentRes.comment_view.comment),
-      c => c.comment?.counts.score === 1,
-    )
-  ).comment;
-  expect(gammaComment1).toBeDefined();
-  expect(gammaComment1?.community.local).toBe(false);
-  expect(gammaComment1?.creator.local).toBe(false);
-  expect(gammaComment1?.counts.score).toBe(1);
-
+test('Unlike a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
   let unlike = await likeComment(alpha, 0, commentRes.comment_view.comment);
   expect(unlike.comment_view.counts.score).toBe(0);
 
-  // Make sure that comment is unliked on beta
-  let betaComment = (
-    await waitUntil(
-      () => resolveComment(beta, commentRes.comment_view.comment),
-      c => c.comment?.counts.score === 0,
-    )
-  ).comment;
+  // Make sure that post is unliked on beta
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  let betaComment = searchBeta.comments[0];
   expect(betaComment).toBeDefined();
-  expect(betaComment?.community.local).toBe(true);
-  expect(betaComment?.creator.local).toBe(false);
-  expect(betaComment?.counts.score).toBe(0);
-
-  // Make sure that comment is unliked on gamma, downstream peer
-  // This is testing replication from remote-home-remote (alpha-beta-gamma)
-  let gammaComment = (
-    await waitUntil(
-      () => resolveComment(gamma, commentRes.comment_view.comment),
-      c => c.comment?.counts.score === 0,
-    )
-  ).comment;
-  expect(gammaComment).toBeDefined();
-  expect(gammaComment?.community.local).toBe(false);
-  expect(gammaComment?.creator.local).toBe(false);
-  expect(gammaComment?.counts.score).toBe(0);
+  expect(betaComment.community.local).toBe(true);
+  expect(betaComment.creator.local).toBe(false);
+  expect(betaComment.counts.score).toBe(0);
 });
 
-test("Federated comment like", async () => {
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
-  await waitUntil(
-    () => resolveComment(beta, commentRes.comment_view.comment),
-    c => c.comment?.counts.score === 1,
-  );
-  // Find the comment on beta
-  let betaComment = (
-    await resolveComment(beta, commentRes.comment_view.comment)
-  ).comment;
+test('Federated comment like', async () => {
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
 
-  if (!betaComment) {
-    throw "Missing beta comment";
-  }
+  // Find the comment on beta
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  let betaComment = searchBeta.comments[0];
 
   let like = await likeComment(beta, 1, betaComment.comment);
   expect(like.comment_view.counts.score).toBe(2);
 
   // Get the post from alpha, check the likes
-  let postComments = await waitUntil(
-    () => getComments(alpha, postOnAlphaRes.post_view.post.id),
-    c => c.comments[0].counts.score === 2,
-  );
-  expect(postComments.comments[0].counts.score).toBe(2);
+  let post = await getPost(alpha, postRes.post_view.post.id);
+  expect(post.comments[0].counts.score).toBe(2);
 });
 
-test("Reply to a comment from another instance, get notification", async () => {
-  await alpha.markAllAsRead();
+test('Reply to a comment', async () => {
+  // Create a comment on alpha, find it on beta
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  let betaComment = searchBeta.comments[0];
 
-  let betaCommunity = (
-    await waitUntil(
-      () => resolveBetaCommunity(alpha),
-      c => !!c.community?.community.instance_id,
-    )
-  ).community;
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-
-  const postOnAlphaRes = await createPost(alpha, betaCommunity.community.id);
-
-  // Create a root-level trunk-branch comment on alpha
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
   // find that comment id on beta
-  let betaComment = (
-    await waitUntil(
-      () => resolveComment(beta, commentRes.comment_view.comment),
-      c => c.comment?.counts.score === 1,
-    )
-  ).comment;
 
-  if (!betaComment) {
-    throw "Missing beta comment";
-  }
-
-  // Reply from beta, extending the branch
+  // Reply from beta
   let replyRes = await createComment(
     beta,
     betaComment.post.id,
-    betaComment.comment.id,
+    betaComment.comment.id
   );
   expect(replyRes.comment_view.comment.content).toBeDefined();
   expect(replyRes.comment_view.community.local).toBe(true);
   expect(replyRes.comment_view.creator.local).toBe(true);
-  expect(getCommentParentId(replyRes.comment_view.comment)).toBe(
-    betaComment.comment.id,
-  );
+  expect(replyRes.comment_view.comment.parent_id).toBe(betaComment.comment.id);
   expect(replyRes.comment_view.counts.score).toBe(1);
 
-  // Make sure that reply comment is seen on alpha
-  let commentSearch = await waitUntil(
-    () => resolveComment(alpha, replyRes.comment_view.comment),
-    c => c.comment?.counts.score === 1,
-  );
-  let alphaComment = commentSearch.comment!;
-  let postComments = await waitUntil(
-    () => getComments(alpha, postOnAlphaRes.post_view.post.id),
-    pc => pc.comments.length >= 2,
-  );
-  // Note: this test fails when run twice and this count will differ
-  expect(postComments.comments.length).toBeGreaterThanOrEqual(2);
+  // Make sure that comment is seen on alpha
+  // TODO not sure why, but a searchComment back to alpha, for the ap_id of betas
+  // comment, isn't working.
+  // let searchAlpha = await searchComment(alpha, replyRes.comment);
+  let post = await getPost(alpha, postRes.post_view.post.id);
+  let alphaComment = post.comments[0];
   expect(alphaComment.comment.content).toBeDefined();
-
-  expect(getCommentParentId(alphaComment.comment)).toBe(
-    postComments.comments[1].comment.id,
-  );
+  expect(alphaComment.comment.parent_id).toBe(post.comments[1].comment.id);
   expect(alphaComment.community.local).toBe(false);
   expect(alphaComment.creator.local).toBe(false);
   expect(alphaComment.counts.score).toBe(1);
   assertCommentFederation(alphaComment, replyRes.comment_view);
-
-  // Did alpha get notified of the reply from beta?
-  let alphaUnreadCountRes = await waitUntil(
-    () => getUnreadCount(alpha),
-    e => e.replies >= 1,
-  );
-  expect(alphaUnreadCountRes.replies).toBeGreaterThanOrEqual(1);
-
-  // check inbox of replies on alpha, fetching read/unread both
-  let alphaRepliesRes = await waitUntil(
-    () => getReplies(alpha),
-    r => r.replies.length > 0,
-  );
-  const alphaReply = alphaRepliesRes.replies.find(
-    r => r.comment.id === alphaComment.comment.id,
-  );
-  expect(alphaReply).toBeDefined();
-  if (!alphaReply) throw Error();
-  expect(alphaReply.comment.content).toBeDefined();
-  expect(alphaReply.community.local).toBe(false);
-  expect(alphaReply.creator.local).toBe(false);
-  expect(alphaReply.counts.score).toBe(1);
-  // ToDo: interesting alphaRepliesRes.replies[0].comment_reply.id is 1, meaning? how did that come about?
-  expect(alphaReply.comment.id).toBe(alphaComment.comment.id);
-  // this is a new notification, getReplies fetch was for read/unread both, confirm it is unread.
-  expect(alphaReply.comment_reply.read).toBe(false);
-  assertCommentFederation(alphaReply, replyRes.comment_view);
 });
 
-test("Mention beta from alpha", async () => {
-  if (!betaCommunity) throw Error("no community");
-  const postOnAlphaRes = await createPost(alpha, betaCommunity.community.id);
-  // Create a new branch, trunk-level comment branch, from alpha instance
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
-  // Create a reply comment to previous comment, this has a mention in body
-  let mentionContent = "A test mention of @lemmy_beta@lemmy-beta:8551";
+test('Mention beta', async () => {
+  // Create a mention on alpha
+  let mentionContent = 'A test mention of @lemmy_beta@lemmy-beta:8551';
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
   let mentionRes = await createComment(
     alpha,
-    postOnAlphaRes.post_view.post.id,
+    postRes.post_view.post.id,
     commentRes.comment_view.comment.id,
-    mentionContent,
+    mentionContent
   );
   expect(mentionRes.comment_view.comment.content).toBeDefined();
   expect(mentionRes.comment_view.community.local).toBe(false);
   expect(mentionRes.comment_view.creator.local).toBe(true);
   expect(mentionRes.comment_view.counts.score).toBe(1);
 
-  // get beta's localized copy of the alpha post
-  let betaPost = await waitForPost(beta, postOnAlphaRes.post_view.post);
-  if (!betaPost) {
-    throw "unable to locate post on beta";
-  }
-  expect(betaPost.post.ap_id).toBe(postOnAlphaRes.post_view.post.ap_id);
-  expect(betaPost.post.name).toBe(postOnAlphaRes.post_view.post.name);
-
-  // Make sure that both new comments are seen on beta and have parent/child relationship
-  let betaPostComments = await waitUntil(
-    () => getComments(beta, betaPost!.post.id),
-    c => c.comments[1]?.counts.score === 1,
-  );
-  expect(betaPostComments.comments.length).toEqual(2);
-  // the trunk-branch root comment will be older than the mention reply comment, so index 1
-  let betaRootComment = betaPostComments.comments[1];
-  // the trunk-branch root comment should not have a parent
-  expect(getCommentParentId(betaRootComment.comment)).toBeUndefined();
-  expect(betaRootComment.comment.content).toBeDefined();
-  // the mention reply comment should have parent that points to the branch root level comment
-  expect(getCommentParentId(betaPostComments.comments[0].comment)).toBe(
-    betaPostComments.comments[1].comment.id,
-  );
-  expect(betaRootComment.community.local).toBe(true);
-  expect(betaRootComment.creator.local).toBe(false);
-  expect(betaRootComment.counts.score).toBe(1);
-  assertCommentFederation(betaRootComment, commentRes.comment_view);
-
-  let mentionsRes = await waitUntil(
-    () => getMentions(beta),
-    m => !!m.mentions[0],
-  );
+  let mentionsRes = await getMentions(beta);
   expect(mentionsRes.mentions[0].comment.content).toBeDefined();
   expect(mentionsRes.mentions[0].community.local).toBe(true);
   expect(mentionsRes.mentions[0].creator.local).toBe(false);
   expect(mentionsRes.mentions[0].counts.score).toBe(1);
-  // the reply comment with mention should be the most fresh, newest, index 0
-  expect(mentionsRes.mentions[0].person_mention.comment_id).toBe(
-    betaPostComments.comments[0].comment.id,
-  );
 });
 
-test("Comment Search", async () => {
-  let commentRes = await createComment(alpha, postOnAlphaRes.post_view.post.id);
-  let betaComment = (
-    await resolveComment(beta, commentRes.comment_view.comment)
-  ).comment;
-  assertCommentFederation(betaComment, commentRes.comment_view);
+test('Comment Search', async () => {
+  let commentRes = await createComment(alpha, postRes.post_view.post.id);
+  let searchBeta = await searchComment(beta, commentRes.comment_view.comment);
+  assertCommentFederation(searchBeta.comments[0], commentRes.comment_view);
 });
 
-test("A and G subscribe to B (center) A posts, G mentions B, it gets announced to A", async () => {
+test('A and G subscribe to B (center) A posts, G mentions B, it gets announced to A', async () => {
   // Create a local post
-  let alphaCommunity = (await resolveCommunity(alpha, "!main@lemmy-alpha:8541"))
-    .community;
-
-  if (!alphaCommunity) {
-    throw "Missing alpha community";
-  }
-
-  // follow community from beta so that it accepts the mention
-  let betaCommunity = await resolveCommunity(
-    beta,
-    alphaCommunity.community.actor_id,
-  );
-  await followCommunity(beta, true, betaCommunity.community!.community.id);
-
-  let alphaPost = await createPost(alpha, alphaCommunity.community.id);
+  let alphaPost = await createPost(alpha, 2);
   expect(alphaPost.post_view.community.local).toBe(true);
 
   // Make sure gamma sees it
-  let gammaPost = (await resolvePost(gamma, alphaPost.post_view.post))!.post;
-
-  if (!gammaPost) {
-    throw "Missing gamma post";
-  }
+  let search = await searchPost(gamma, alphaPost.post_view.post);
+  let gammaPost = search.posts[0];
 
   let commentContent =
-    "A jest test federated comment announce, lets mention @lemmy_beta@lemmy-beta:8551";
+    'A jest test federated comment announce, lets mention @lemmy_beta@lemmy-beta:8551';
   let commentRes = await createComment(
     gamma,
     gammaPost.post.id,
     undefined,
-    commentContent,
+    commentContent
   );
   expect(commentRes.comment_view.comment.content).toBe(commentContent);
   expect(commentRes.comment_view.community.local).toBe(false);
@@ -551,256 +312,80 @@ test("A and G subscribe to B (center) A posts, G mentions B, it gets announced t
   expect(commentRes.comment_view.counts.score).toBe(1);
 
   // Make sure alpha sees it
-  let alphaPostComments2 = await waitUntil(
-    () => getComments(alpha, alphaPost.post_view.post.id),
-    e => e.comments[0]?.counts.score === 1,
-  );
-  expect(alphaPostComments2.comments[0].comment.content).toBe(commentContent);
-  expect(alphaPostComments2.comments[0].community.local).toBe(true);
-  expect(alphaPostComments2.comments[0].creator.local).toBe(false);
-  expect(alphaPostComments2.comments[0].counts.score).toBe(1);
-  assertCommentFederation(
-    alphaPostComments2.comments[0],
-    commentRes.comment_view,
-  );
+  let alphaPost2 = await getPost(alpha, alphaPost.post_view.post.id);
+  expect(alphaPost2.comments[0].comment.content).toBe(commentContent);
+  expect(alphaPost2.comments[0].community.local).toBe(true);
+  expect(alphaPost2.comments[0].creator.local).toBe(false);
+  expect(alphaPost2.comments[0].counts.score).toBe(1);
+  assertCommentFederation(alphaPost2.comments[0], commentRes.comment_view);
 
   // Make sure beta has mentions
-  let relevantMention = await waitUntil(
-    () =>
-      getMentions(beta).then(m =>
-        m.mentions.find(
-          m => m.comment.ap_id === commentRes.comment_view.comment.ap_id,
-        ),
-      ),
-    e => !!e,
-  );
-  if (!relevantMention) throw Error("could not find mention");
-  expect(relevantMention.comment.content).toBe(commentContent);
-  expect(relevantMention.community.local).toBe(false);
-  expect(relevantMention.creator.local).toBe(false);
+  let mentionsRes = await getMentions(beta);
+  expect(mentionsRes.mentions[0].comment.content).toBe(commentContent);
+  expect(mentionsRes.mentions[0].community.local).toBe(false);
+  expect(mentionsRes.mentions[0].creator.local).toBe(false);
   // TODO this is failing because fetchInReplyTos aren't getting score
   // expect(mentionsRes.mentions[0].score).toBe(1);
 });
 
-test("Check that activity from another instance is sent to third instance", async () => {
-  // Alpha and gamma users follow beta community
-  let alphaFollow = await followBeta(alpha);
-  expect(alphaFollow.community_view.community.local).toBe(false);
-  expect(alphaFollow.community_view.community.name).toBe("main");
-
-  let gammaFollow = await followBeta(gamma);
-  expect(gammaFollow.community_view.community.local).toBe(false);
-  expect(gammaFollow.community_view.community.name).toBe("main");
-  await waitUntil(
-    () => resolveBetaCommunity(alpha),
-    c => c.community?.subscribed === "Subscribed",
-  );
-  await waitUntil(
-    () => resolveBetaCommunity(gamma),
-    c => c.community?.subscribed === "Subscribed",
-  );
-
-  // Create a post on beta
-  let betaPost = await createPost(beta, 2);
-  expect(betaPost.post_view.community.local).toBe(true);
-
-  // Make sure gamma and alpha see it
-  let gammaPost = await waitForPost(gamma, betaPost.post_view.post);
-  if (!gammaPost) {
-    throw "Missing gamma post";
-  }
-  expect(gammaPost.post).toBeDefined();
-
-  let alphaPost = await waitForPost(alpha, betaPost.post_view.post);
-  if (!alphaPost) {
-    throw "Missing alpha post";
-  }
-  expect(alphaPost.post).toBeDefined();
-
-  // The bug: gamma comments, and alpha should see it.
-  let commentContent = "Comment from gamma";
-  let commentRes = await createComment(
-    gamma,
-    gammaPost.post.id,
-    undefined,
-    commentContent,
-  );
-  expect(commentRes.comment_view.comment.content).toBe(commentContent);
-  expect(commentRes.comment_view.community.local).toBe(false);
-  expect(commentRes.comment_view.creator.local).toBe(true);
-  expect(commentRes.comment_view.counts.score).toBe(1);
-
-  // Make sure alpha sees it
-  let alphaPostComments2 = await waitUntil(
-    () => getComments(alpha, alphaPost!.post.id),
-    e => e.comments[0]?.counts.score === 1,
-  );
-  expect(alphaPostComments2.comments[0].comment.content).toBe(commentContent);
-  expect(alphaPostComments2.comments[0].community.local).toBe(false);
-  expect(alphaPostComments2.comments[0].creator.local).toBe(false);
-  expect(alphaPostComments2.comments[0].counts.score).toBe(1);
-  assertCommentFederation(
-    alphaPostComments2.comments[0],
-    commentRes.comment_view,
-  );
-
-  await Promise.all([unfollowRemotes(alpha), unfollowRemotes(gamma)]);
-});
-
-test("Fetch in_reply_tos: A is unsubbed from B, B makes a post, and some embedded comments, A subs to B, B updates the lowest level comment, A fetches both the post and all the inreplyto comments for that post.", async () => {
+test('Fetch in_reply_tos: A is unsubbed from B, B makes a post, and some embedded comments, A subs to B, B updates the lowest level comment, A fetches both the post and all the inreplyto comments for that post.', async () => {
   // Unfollow all remote communities
-  let site = await unfollowRemotes(alpha);
+  let followed = await unfollowRemotes(alpha);
   expect(
-    site.my_user?.follows.filter(c => c.community.local == false).length,
+    followed.communities.filter(c => c.community.local == false).length
   ).toBe(0);
 
   // B creates a post, and two comments, should be invisible to A
-  let postOnBetaRes = await createPost(beta, 2);
-  expect(postOnBetaRes.post_view.post.name).toBeDefined();
+  let postRes = await createPost(beta, 2);
+  expect(postRes.post_view.post.name).toBeDefined();
 
-  let parentCommentContent = "An invisible top level comment from beta";
+  let parentCommentContent = 'An invisible top level comment from beta';
   let parentCommentRes = await createComment(
     beta,
-    postOnBetaRes.post_view.post.id,
+    postRes.post_view.post.id,
     undefined,
-    parentCommentContent,
+    parentCommentContent
   );
   expect(parentCommentRes.comment_view.comment.content).toBe(
-    parentCommentContent,
+    parentCommentContent
   );
 
   // B creates a comment, then a child one of that.
-  let childCommentContent = "An invisible child comment from beta";
+  let childCommentContent = 'An invisible child comment from beta';
   let childCommentRes = await createComment(
     beta,
-    postOnBetaRes.post_view.post.id,
+    postRes.post_view.post.id,
     parentCommentRes.comment_view.comment.id,
-    childCommentContent,
+    childCommentContent
   );
   expect(childCommentRes.comment_view.comment.content).toBe(
-    childCommentContent,
+    childCommentContent
   );
 
   // Follow beta again
   let follow = await followBeta(alpha);
   expect(follow.community_view.community.local).toBe(false);
-  expect(follow.community_view.community.name).toBe("main");
+  expect(follow.community_view.community.name).toBe('main');
 
   // An update to the child comment on beta, should push the post, parent, and child to alpha now
-  let updatedCommentContent = "An update child comment from beta";
+  let updatedCommentContent = 'An update child comment from beta';
   let updateRes = await editComment(
     beta,
     childCommentRes.comment_view.comment.id,
-    updatedCommentContent,
+    updatedCommentContent
   );
   expect(updateRes.comment_view.comment.content).toBe(updatedCommentContent);
 
   // Get the post from alpha
-  let alphaPostB = await waitForPost(alpha, postOnBetaRes.post_view.post);
-
-  if (!alphaPostB) {
-    throw "Missing alpha post B";
-  }
+  let search = await searchPost(alpha, postRes.post_view.post);
+  let alphaPostB = search.posts[0];
 
   let alphaPost = await getPost(alpha, alphaPostB.post.id);
-  let alphaPostComments = await waitUntil(
-    () => getComments(alpha, alphaPostB!.post.id),
-    c =>
-      c.comments[1]?.comment.content ===
-        parentCommentRes.comment_view.comment.content &&
-      c.comments[0]?.comment.content === updateRes.comment_view.comment.content,
-  );
   expect(alphaPost.post_view.post.name).toBeDefined();
-  assertCommentFederation(
-    alphaPostComments.comments[1],
-    parentCommentRes.comment_view,
-  );
-  assertCommentFederation(
-    alphaPostComments.comments[0],
-    updateRes.comment_view,
-  );
+  assertCommentFederation(alphaPost.comments[1], parentCommentRes.comment_view);
+  assertCommentFederation(alphaPost.comments[0], updateRes.comment_view);
   expect(alphaPost.post_view.community.local).toBe(false);
   expect(alphaPost.post_view.creator.local).toBe(false);
 
   await unfollowRemotes(alpha);
 });
-
-test("Report a comment", async () => {
-  let betaCommunity = (await resolveBetaCommunity(beta)).community;
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-  let postOnBetaRes = (await createPost(beta, betaCommunity.community.id))
-    .post_view.post;
-  expect(postOnBetaRes).toBeDefined();
-  let commentRes = (await createComment(beta, postOnBetaRes.id)).comment_view
-    .comment;
-  expect(commentRes).toBeDefined();
-
-  let alphaComment = (await resolveComment(alpha, commentRes)).comment?.comment;
-  if (!alphaComment) {
-    throw "Missing alpha comment";
-  }
-
-  const reason = randomString(10);
-  let alphaReport = (await reportComment(alpha, alphaComment.id, reason))
-    .comment_report_view.comment_report;
-
-  let betaReport = (await waitUntil(
-    () =>
-      listCommentReports(beta).then(r =>
-        r.comment_reports.find(rep => rep.comment_report.reason === reason),
-      ),
-    e => !!e,
-  ))!.comment_report;
-  expect(betaReport).toBeDefined();
-  expect(betaReport.resolved).toBe(false);
-  expect(betaReport.original_comment_text).toBe(
-    alphaReport.original_comment_text,
-  );
-  expect(betaReport.reason).toBe(alphaReport.reason);
-});
-
-test("Dont send a comment reply to a blocked community", async () => {
-  let newCommunity = await createCommunity(beta);
-  let newCommunityId = newCommunity.community_view.community.id;
-
-  // Create a post on beta
-  let betaPost = await createPost(beta, newCommunityId);
-
-  let alphaPost = (await resolvePost(alpha, betaPost.post_view.post))!.post;
-  if (!alphaPost) {
-    throw "unable to locate post on alpha";
-  }
-
-  // Check beta's inbox count
-  let unreadCount = await getUnreadCount(beta);
-  expect(unreadCount.replies).toBe(1);
-
-  // Beta blocks the new beta community
-  let blockRes = await blockCommunity(beta, newCommunityId, true);
-  expect(blockRes.blocked).toBe(true);
-  delay();
-
-  // Alpha creates a comment
-  let commentRes = await createComment(alpha, alphaPost.post.id);
-  expect(commentRes.comment_view.comment.content).toBeDefined();
-  let alphaComment = await resolveComment(
-    beta,
-    commentRes.comment_view.comment,
-  );
-  if (!alphaComment) {
-    throw "Missing alpha comment before block";
-  }
-
-  // Check beta's inbox count, make sure it stays the same
-  unreadCount = await getUnreadCount(beta);
-  expect(unreadCount.replies).toBe(1);
-
-  let replies = await getReplies(beta);
-  expect(replies.replies.length).toBe(1);
-
-  // Unblock the community
-  blockRes = await blockCommunity(beta, newCommunityId, false);
-  expect(blockRes.blocked).toBe(false);
-});

api_tests/src/community.spec.ts

@@ -1,94 +1,76 @@
 jest.setTimeout(120000);
-
-import { CommunityView } from "lemmy-js-client/dist/types/CommunityView";
 import {
   alpha,
   beta,
-  gamma,
   setupLogins,
-  resolveCommunity,
+  searchForCommunity,
   createCommunity,
   deleteCommunity,
   removeCommunity,
   getCommunity,
   followCommunity,
-  banPersonFromCommunity,
-  resolvePerson,
-  getSite,
-  createPost,
-  getPost,
-  resolvePost,
-  registerUser,
-  getPosts,
-  getComments,
-  createComment,
-  getCommunityByName,
-  blockInstance,
-  waitUntil,
-  alphaUrl,
-  delta,
-  betaAllowedInstances,
-  searchPostLocal,
-  longDelay,
-  editCommunity,
-  unfollows,
-} from "./shared";
-import { EditCommunity, EditSite } from "lemmy-js-client";
+} from './shared';
+import { CommunityView } from 'lemmy-js-client';
 
-beforeAll(setupLogins);
-afterAll(unfollows);
+beforeAll(async () => {
+  await setupLogins();
+});
 
 function assertCommunityFederation(
-  communityOne?: CommunityView,
-  communityTwo?: CommunityView,
+  communityOne: CommunityView,
+  communityTwo: CommunityView
 ) {
-  expect(communityOne?.community.actor_id).toBe(
-    communityTwo?.community.actor_id,
+  expect(communityOne.community.actor_id).toBe(communityTwo.community.actor_id);
+  expect(communityOne.community.name).toBe(communityTwo.community.name);
+  expect(communityOne.community.title).toBe(communityTwo.community.title);
+  expect(communityOne.community.description).toBe(
+    communityTwo.community.description
   );
-  expect(communityOne?.community.name).toBe(communityTwo?.community.name);
-  expect(communityOne?.community.title).toBe(communityTwo?.community.title);
-  expect(communityOne?.community.description).toBe(
-    communityTwo?.community.description,
+  expect(communityOne.community.icon).toBe(communityTwo.community.icon);
+  expect(communityOne.community.banner).toBe(communityTwo.community.banner);
+  expect(communityOne.community.published).toBe(
+    communityTwo.community.published
   );
-  expect(communityOne?.community.icon).toBe(communityTwo?.community.icon);
-  expect(communityOne?.community.banner).toBe(communityTwo?.community.banner);
-  expect(communityOne?.community.published).toBe(
-    communityTwo?.community.published,
+  expect(communityOne.creator.actor_id).toBe(communityTwo.creator.actor_id);
+  expect(communityOne.community.nsfw).toBe(communityTwo.community.nsfw);
+  expect(communityOne.community.category_id).toBe(
+    communityTwo.community.category_id
   );
-  expect(communityOne?.community.nsfw).toBe(communityTwo?.community.nsfw);
-  expect(communityOne?.community.removed).toBe(communityTwo?.community.removed);
-  expect(communityOne?.community.deleted).toBe(communityTwo?.community.deleted);
+  expect(communityOne.community.removed).toBe(communityTwo.community.removed);
+  expect(communityOne.community.deleted).toBe(communityTwo.community.deleted);
 }
 
-test("Create community", async () => {
+test('Create community', async () => {
   let communityRes = await createCommunity(alpha);
   expect(communityRes.community_view.community.name).toBeDefined();
 
   // A dupe check
   let prevName = communityRes.community_view.community.name;
-  await expect(createCommunity(alpha, prevName)).rejects.toStrictEqual(
-    Error("community_already_exists"),
-  );
+  let communityRes2: any = await createCommunity(alpha, prevName);
+  expect(communityRes2['error']).toBe('community_already_exists');
 
   // Cache the community on beta, make sure it has the other fields
   let searchShort = `!${prevName}@lemmy-alpha:8541`;
-  let betaCommunity = (await resolveCommunity(beta, searchShort)).community;
-  assertCommunityFederation(betaCommunity, communityRes.community_view);
+  let search = await searchForCommunity(beta, searchShort);
+  let communityOnBeta = search.communities[0];
+  assertCommunityFederation(communityOnBeta, communityRes.community_view);
 });
 
-test("Delete community", async () => {
+test('Delete community', async () => {
   let communityRes = await createCommunity(beta);
 
   // Cache the community on Alpha
   let searchShort = `!${communityRes.community_view.community.name}@lemmy-beta:8551`;
-  let alphaCommunity = (await resolveCommunity(alpha, searchShort)).community;
-  if (!alphaCommunity) {
-    throw "Missing alpha community";
-  }
-  assertCommunityFederation(alphaCommunity, communityRes.community_view);
+  let search = await searchForCommunity(alpha, searchShort);
+  let communityOnAlpha = search.communities[0];
+  assertCommunityFederation(communityOnAlpha, communityRes.community_view);
 
   // Follow the community from alpha
-  let follow = await followCommunity(alpha, true, alphaCommunity.community.id);
+  let follow = await followCommunity(
+    alpha,
+    true,
+    communityOnAlpha.community.id
+  );
 
   // Make sure the follow response went through
   expect(follow.community_view.community.local).toBe(false);
@@ -96,17 +78,14 @@ test("Delete community", async () => {
   let deleteCommunityRes = await deleteCommunity(
     beta,
     true,
-    communityRes.community_view.community.id,
+    communityRes.community_view.community.id
   );
   expect(deleteCommunityRes.community_view.community.deleted).toBe(true);
-  expect(deleteCommunityRes.community_view.community.title).toBe(
-    communityRes.community_view.community.title,
-  );
 
   // Make sure it got deleted on A
-  let communityOnAlphaDeleted = await waitUntil(
-    () => getCommunity(alpha, alphaCommunity!.community.id),
-    g => g.community_view.community.deleted,
+  let communityOnAlphaDeleted = await getCommunity(
+    alpha,
+    communityOnAlpha.community.id
   );
   expect(communityOnAlphaDeleted.community_view.community.deleted).toBe(true);
 
@@ -114,33 +93,35 @@ test("Delete community", async () => {
   let undeleteCommunityRes = await deleteCommunity(
     beta,
     false,
-    communityRes.community_view.community.id,
+    communityRes.community_view.community.id
   );
   expect(undeleteCommunityRes.community_view.community.deleted).toBe(false);
 
   // Make sure it got undeleted on A
-  let communityOnAlphaUnDeleted = await waitUntil(
-    () => getCommunity(alpha, alphaCommunity!.community.id),
-    g => !g.community_view.community.deleted,
+  let communityOnAlphaUnDeleted = await getCommunity(
+    alpha,
+    communityOnAlpha.community.id
   );
   expect(communityOnAlphaUnDeleted.community_view.community.deleted).toBe(
-    false,
+    false
   );
 });
 
-test("Remove community", async () => {
+test('Remove community', async () => {
   let communityRes = await createCommunity(beta);
 
   // Cache the community on Alpha
   let searchShort = `!${communityRes.community_view.community.name}@lemmy-beta:8551`;
-  let alphaCommunity = (await resolveCommunity(alpha, searchShort)).community;
-  if (!alphaCommunity) {
-    throw "Missing alpha community";
-  }
-  assertCommunityFederation(alphaCommunity, communityRes.community_view);
+  let search = await searchForCommunity(alpha, searchShort);
+  let communityOnAlpha = search.communities[0];
+  assertCommunityFederation(communityOnAlpha, communityRes.community_view);
 
   // Follow the community from alpha
-  let follow = await followCommunity(alpha, true, alphaCommunity.community.id);
+  let follow = await followCommunity(
+    alpha,
+    true,
+    communityOnAlpha.community.id
+  );
 
   // Make sure the follow response went through
   expect(follow.community_view.community.local).toBe(false);
@@ -148,17 +129,14 @@ test("Remove community", async () => {
   let removeCommunityRes = await removeCommunity(
     beta,
     true,
-    communityRes.community_view.community.id,
+    communityRes.community_view.community.id
   );
   expect(removeCommunityRes.community_view.community.removed).toBe(true);
-  expect(removeCommunityRes.community_view.community.title).toBe(
-    communityRes.community_view.community.title,
-  );
 
   // Make sure it got Removed on A
-  let communityOnAlphaRemoved = await waitUntil(
-    () => getCommunity(alpha, alphaCommunity!.community.id),
-    g => g.community_view.community.removed,
+  let communityOnAlphaRemoved = await getCommunity(
+    alpha,
+    communityOnAlpha.community.id
   );
   expect(communityOnAlphaRemoved.community_view.community.removed).toBe(true);
 
@@ -166,370 +144,26 @@ test("Remove community", async () => {
   let unremoveCommunityRes = await removeCommunity(
     beta,
     false,
-    communityRes.community_view.community.id,
+    communityRes.community_view.community.id
   );
   expect(unremoveCommunityRes.community_view.community.removed).toBe(false);
 
   // Make sure it got undeleted on A
-  let communityOnAlphaUnRemoved = await waitUntil(
-    () => getCommunity(alpha, alphaCommunity!.community.id),
-    g => !g.community_view.community.removed,
+  let communityOnAlphaUnRemoved = await getCommunity(
+    alpha,
+    communityOnAlpha.community.id
   );
   expect(communityOnAlphaUnRemoved.community_view.community.removed).toBe(
-    false,
+    false
   );
 });
 
-test("Search for beta community", async () => {
+test('Search for beta community', async () => {
   let communityRes = await createCommunity(beta);
   expect(communityRes.community_view.community.name).toBeDefined();
 
   let searchShort = `!${communityRes.community_view.community.name}@lemmy-beta:8551`;
-  let alphaCommunity = (await resolveCommunity(alpha, searchShort)).community;
-  assertCommunityFederation(alphaCommunity, communityRes.community_view);
-});
-
-test("Admin actions in remote community are not federated to origin", async () => {
-  // create a community on alpha
-  let communityRes = (await createCommunity(alpha)).community_view;
-  expect(communityRes.community.name).toBeDefined();
-
-  // gamma follows community and posts in it
-  let gammaCommunity = (
-    await resolveCommunity(gamma, communityRes.community.actor_id)
-  ).community;
-  if (!gammaCommunity) {
-    throw "Missing gamma community";
-  }
-  await followCommunity(gamma, true, gammaCommunity.community.id);
-  gammaCommunity = (
-    await waitUntil(
-      () => resolveCommunity(gamma, communityRes.community.actor_id),
-      g => g.community?.subscribed === "Subscribed",
-    )
-  ).community;
-  if (!gammaCommunity) {
-    throw "Missing gamma community";
-  }
-  expect(gammaCommunity.subscribed).toBe("Subscribed");
-  let gammaPost = (await createPost(gamma, gammaCommunity.community.id))
-    .post_view;
-  expect(gammaPost.post.id).toBeDefined();
-  expect(gammaPost.creator_banned_from_community).toBe(false);
-
-  // admin of beta decides to ban gamma from community
-  let betaCommunity = (
-    await resolveCommunity(beta, communityRes.community.actor_id)
-  ).community;
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-  let bannedUserInfo1 = (await getSite(gamma)).my_user?.local_user_view.person;
-  if (!bannedUserInfo1) {
-    throw "Missing banned user 1";
-  }
-  let bannedUserInfo2 = (await resolvePerson(beta, bannedUserInfo1.actor_id))
-    .person;
-  if (!bannedUserInfo2) {
-    throw "Missing banned user 2";
-  }
-  let banRes = await banPersonFromCommunity(
-    beta,
-    bannedUserInfo2.person.id,
-    betaCommunity.community.id,
-    true,
-    true,
-  );
-  expect(banRes.banned).toBe(true);
-
-  // ban doesn't federate to community's origin instance alpha
-  let alphaPost = (await resolvePost(alpha, gammaPost.post)).post;
-  expect(alphaPost?.creator_banned_from_community).toBe(false);
-
-  // and neither to gamma
-  let gammaPost2 = await getPost(gamma, gammaPost.post.id);
-  expect(gammaPost2.post_view.creator_banned_from_community).toBe(false);
-});
-
-test("moderator view", async () => {
-  // register a new user with their own community on alpha and post to it
-  let otherUser = await registerUser(alpha, alphaUrl);
-
-  let otherCommunity = (await createCommunity(otherUser)).community_view;
-  expect(otherCommunity.community.name).toBeDefined();
-  let otherPost = (await createPost(otherUser, otherCommunity.community.id))
-    .post_view;
-  expect(otherPost.post.id).toBeDefined();
-
-  let otherComment = (await createComment(otherUser, otherPost.post.id))
-    .comment_view;
-  expect(otherComment.comment.id).toBeDefined();
-
-  // create a community and post on alpha
-  let alphaCommunity = (await createCommunity(alpha)).community_view;
-  expect(alphaCommunity.community.name).toBeDefined();
-  let alphaPost = (await createPost(alpha, alphaCommunity.community.id))
-    .post_view;
-  expect(alphaPost.post.id).toBeDefined();
-
-  let alphaComment = (await createComment(otherUser, alphaPost.post.id))
-    .comment_view;
-  expect(alphaComment.comment.id).toBeDefined();
-
-  // other user also posts on alpha's community
-  let otherAlphaPost = (
-    await createPost(otherUser, alphaCommunity.community.id)
-  ).post_view;
-  expect(otherAlphaPost.post.id).toBeDefined();
-
-  let otherAlphaComment = (
-    await createComment(otherUser, otherAlphaPost.post.id)
-  ).comment_view;
-  expect(otherAlphaComment.comment.id).toBeDefined();
-
-  // alpha lists posts and comments on home page, should contain all posts that were made
-  let posts = (await getPosts(alpha, "All")).posts;
-  expect(posts).toBeDefined();
-  let postIds = posts.map(post => post.post.id);
-
-  let comments = (await getComments(alpha, undefined, "All")).comments;
-  expect(comments).toBeDefined();
-  let commentIds = comments.map(comment => comment.comment.id);
-
-  expect(postIds).toContain(otherPost.post.id);
-  expect(commentIds).toContain(otherComment.comment.id);
-
-  expect(postIds).toContain(alphaPost.post.id);
-  expect(commentIds).toContain(alphaComment.comment.id);
-
-  expect(postIds).toContain(otherAlphaPost.post.id);
-  expect(commentIds).toContain(otherAlphaComment.comment.id);
-
-  // in moderator view, alpha should not see otherPost, wich was posted on a community alpha doesn't moderate
-  posts = (await getPosts(alpha, "ModeratorView")).posts;
-  expect(posts).toBeDefined();
-  postIds = posts.map(post => post.post.id);
-
-  comments = (await getComments(alpha, undefined, "ModeratorView")).comments;
-  expect(comments).toBeDefined();
-  commentIds = comments.map(comment => comment.comment.id);
-
-  expect(postIds).not.toContain(otherPost.post.id);
-  expect(commentIds).not.toContain(otherComment.comment.id);
-
-  expect(postIds).toContain(alphaPost.post.id);
-  expect(commentIds).toContain(alphaComment.comment.id);
-
-  expect(postIds).toContain(otherAlphaPost.post.id);
-  expect(commentIds).toContain(otherAlphaComment.comment.id);
-});
-
-test("Get community for different casing on domain", async () => {
-  let communityRes = await createCommunity(alpha);
-  expect(communityRes.community_view.community.name).toBeDefined();
-
-  // A dupe check
-  let prevName = communityRes.community_view.community.name;
-  await expect(createCommunity(alpha, prevName)).rejects.toStrictEqual(
-    Error("community_already_exists"),
-  );
-
-  // Cache the community on beta, make sure it has the other fields
-  let communityName = `${communityRes.community_view.community.name}@LEMMY-ALPHA:8541`;
-  let betaCommunity = (await getCommunityByName(beta, communityName))
-    .community_view;
-  assertCommunityFederation(betaCommunity, communityRes.community_view);
-});
-
-test("User blocks instance, communities are hidden", async () => {
-  // create community and post on beta
-  let communityRes = await createCommunity(beta);
-  expect(communityRes.community_view.community.name).toBeDefined();
-  let postRes = await createPost(
-    beta,
-    communityRes.community_view.community.id,
-  );
-  expect(postRes.post_view.post.id).toBeDefined();
-
-  // fetch post to alpha
-  let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post!;
-  expect(alphaPost.post).toBeDefined();
-
-  // post should be included in listing
-  let listing = await getPosts(alpha, "All");
-  let listing_ids = listing.posts.map(p => p.post.ap_id);
-  expect(listing_ids).toContain(postRes.post_view.post.ap_id);
-
-  // block the beta instance
-  await blockInstance(alpha, alphaPost.community.instance_id, true);
-
-  // after blocking, post should not be in listing
-  let listing2 = await getPosts(alpha, "All");
-  let listing_ids2 = listing2.posts.map(p => p.post.ap_id);
-  expect(listing_ids2.indexOf(postRes.post_view.post.ap_id)).toBe(-1);
-
-  // unblock instance again
-  await blockInstance(alpha, alphaPost.community.instance_id, false);
-
-  // post should be included in listing
-  let listing3 = await getPosts(alpha, "All");
-  let listing_ids3 = listing3.posts.map(p => p.post.ap_id);
-  expect(listing_ids3).toContain(postRes.post_view.post.ap_id);
-});
-
-test("Community follower count is federated", async () => {
-  // Follow the beta community from alpha
-  let community = await createCommunity(beta);
-  let communityActorId = community.community_view.community.actor_id;
-  let resolved = await resolveCommunity(alpha, communityActorId);
-  if (!resolved.community) {
-    throw "Missing beta community";
-  }
-
-  await followCommunity(alpha, true, resolved.community.community.id);
-  let followed = (
-    await waitUntil(
-      () => resolveCommunity(alpha, communityActorId),
-      c => c.community?.subscribed === "Subscribed",
-    )
-  ).community;
-
-  // Make sure there is 1 subscriber
-  expect(followed?.counts.subscribers).toBe(1);
-
-  // Follow the community from gamma
-  resolved = await resolveCommunity(gamma, communityActorId);
-  if (!resolved.community) {
-    throw "Missing beta community";
-  }
-
-  await followCommunity(gamma, true, resolved.community.community.id);
-  followed = (
-    await waitUntil(
-      () => resolveCommunity(gamma, communityActorId),
-      c => c.community?.subscribed === "Subscribed",
-    )
-  ).community;
-
-  // Make sure there are 2 subscribers
-  expect(followed?.counts?.subscribers).toBe(2);
-
-  // Follow the community from delta
-  resolved = await resolveCommunity(delta, communityActorId);
-  if (!resolved.community) {
-    throw "Missing beta community";
-  }
-
-  await followCommunity(delta, true, resolved.community.community.id);
-  followed = (
-    await waitUntil(
-      () => resolveCommunity(delta, communityActorId),
-      c => c.community?.subscribed === "Subscribed",
-    )
-  ).community;
-
-  // Make sure there are 3 subscribers
-  expect(followed?.counts?.subscribers).toBe(3);
-});
-
-test("Dont receive community activities after unsubscribe", async () => {
-  let communityRes = await createCommunity(alpha);
-  expect(communityRes.community_view.community.name).toBeDefined();
-  expect(communityRes.community_view.counts.subscribers).toBe(1);
-
-  let betaCommunity = (
-    await resolveCommunity(beta, communityRes.community_view.community.actor_id)
-  ).community;
-  assertCommunityFederation(betaCommunity, communityRes.community_view);
-
-  // follow alpha community from beta
-  await followCommunity(beta, true, betaCommunity!.community.id);
-
-  // ensure that follower count was updated
-  let communityRes1 = await getCommunity(
-    alpha,
-    communityRes.community_view.community.id,
-  );
-  expect(communityRes1.community_view.counts.subscribers).toBe(2);
-
-  // temporarily block alpha, so that it doesn't know about unfollow
-  let editSiteForm: EditSite = {};
-  editSiteForm.allowed_instances = ["lemmy-epsilon"];
-  await beta.editSite(editSiteForm);
-  await longDelay();
-
-  // unfollow
-  await followCommunity(beta, false, betaCommunity!.community.id);
-
-  // ensure that alpha still sees beta as follower
-  let communityRes2 = await getCommunity(
-    alpha,
-    communityRes.community_view.community.id,
-  );
-  expect(communityRes2.community_view.counts.subscribers).toBe(2);
-
-  // unblock alpha
-  editSiteForm.allowed_instances = betaAllowedInstances;
-  await beta.editSite(editSiteForm);
-  await longDelay();
-
-  // create a post, it shouldnt reach beta
-  let postRes = await createPost(
-    alpha,
-    communityRes.community_view.community.id,
-  );
-  expect(postRes.post_view.post.id).toBeDefined();
-  // await longDelay();
-
-  let postResBeta = searchPostLocal(beta, postRes.post_view.post);
-  expect((await postResBeta).posts.length).toBe(0);
-});
-
-test("Fetch community, includes posts", async () => {
-  let communityRes = await createCommunity(alpha);
-  expect(communityRes.community_view.community.name).toBeDefined();
-  expect(communityRes.community_view.counts.subscribers).toBe(1);
-
-  let postRes = await createPost(
-    alpha,
-    communityRes.community_view.community.id,
-  );
-  expect(postRes.post_view.post).toBeDefined();
-
-  let resolvedCommunity = await waitUntil(
-    () =>
-      resolveCommunity(beta, communityRes.community_view.community.actor_id),
-    c => c.community?.community.id != undefined,
-  );
-  let betaCommunity = resolvedCommunity.community;
-  expect(betaCommunity?.community.actor_id).toBe(
-    communityRes.community_view.community.actor_id,
-  );
-
-  await longDelay();
-
-  let post_listing = await getPosts(beta, "All", betaCommunity?.community.id);
-  expect(post_listing.posts.length).toBe(1);
-  expect(post_listing.posts[0].post.ap_id).toBe(postRes.post_view.post.ap_id);
-});
-
-test("Content in local-only community doesn't federate", async () => {
-  // create a community and set it local-only
-  let communityRes = (await createCommunity(alpha)).community_view.community;
-  let form: EditCommunity = {
-    community_id: communityRes.id,
-    visibility: "LocalOnly",
-  };
-  await editCommunity(alpha, form);
-
-  // cant resolve the community from another instance
-  await expect(
-    resolveCommunity(beta, communityRes.actor_id),
-  ).rejects.toStrictEqual(Error("couldnt_find_object"));
-
-  // create a post, also cant resolve it
-  let postRes = await createPost(alpha, communityRes.id);
-  await expect(resolvePost(beta, postRes.post_view.post)).rejects.toStrictEqual(
-    Error("couldnt_find_object"),
-  );
+  let search = await searchForCommunity(alpha, searchShort);
+  let communityOnAlpha = search.communities[0];
+  assertCommunityFederation(communityOnAlpha, communityRes.community_view);
 });

api_tests/src/follow.spec.ts

@@ -1,98 +1,45 @@
 jest.setTimeout(120000);
-
 import {
   alpha,
   setupLogins,
-  resolveBetaCommunity,
+  searchForBetaCommunity,
   followCommunity,
-  getSite,
-  waitUntil,
-  beta,
-  betaUrl,
-  registerUser,
-  unfollows,
-} from "./shared";
+  checkFollowedCommunities,
+  unfollowRemotes,
+} from './shared';
 
-beforeAll(setupLogins);
-
-afterAll(unfollows);
-
-test("Follow local community", async () => {
-  let user = await registerUser(beta, betaUrl);
-
-  let community = (await resolveBetaCommunity(user)).community!;
-  expect(community.counts.subscribers).toBe(1);
-  expect(community.counts.subscribers_local).toBe(1);
-  let follow = await followCommunity(user, true, community.community.id);
-
-  // Make sure the follow response went through
-  expect(follow.community_view.community.local).toBe(true);
-  expect(follow.community_view.subscribed).toBe("Subscribed");
-  expect(follow.community_view.counts.subscribers).toBe(2);
-  expect(follow.community_view.counts.subscribers_local).toBe(2);
-
-  // Test an unfollow
-  let unfollow = await followCommunity(user, false, community.community.id);
-  expect(unfollow.community_view.subscribed).toBe("NotSubscribed");
-  expect(unfollow.community_view.counts.subscribers).toBe(1);
-  expect(unfollow.community_view.counts.subscribers_local).toBe(1);
+beforeAll(async () => {
+  await setupLogins();
 });
 
-test("Follow federated community", async () => {
-  // It takes about 1 second for the community aggregates to federate
-  let betaCommunity = (
-    await waitUntil(
-      () => resolveBetaCommunity(alpha),
-      c =>
-        c.community?.counts.subscribers === 1 &&
-        c.community.counts.subscribers_local === 0,
-    )
-  ).community;
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-  let follow = await followCommunity(alpha, true, betaCommunity.community.id);
-  expect(follow.community_view.subscribed).toBe("Pending");
-  betaCommunity = (
-    await waitUntil(
-      () => resolveBetaCommunity(alpha),
-      c => c.community?.subscribed === "Subscribed",
-    )
-  ).community;
+afterAll(async () => {
+  await unfollowRemotes(alpha);
+});
+
+test('Follow federated community', async () => {
+  let search = await searchForBetaCommunity(alpha); // TODO sometimes this is returning null?
+  let follow = await followCommunity(
+    alpha,
+    true,
+    search.communities[0].community.id
+  );
 
   // Make sure the follow response went through
-  expect(betaCommunity?.community.local).toBe(false);
-  expect(betaCommunity?.community.name).toBe("main");
-  expect(betaCommunity?.subscribed).toBe("Subscribed");
-  expect(betaCommunity?.counts.subscribers_local).toBe(1);
-
-  // check that unfollow was federated
-  let communityOnBeta1 = await resolveBetaCommunity(beta);
-  expect(communityOnBeta1.community?.counts.subscribers).toBe(2);
-  expect(communityOnBeta1.community?.counts.subscribers_local).toBe(1);
+  expect(follow.community_view.community.local).toBe(false);
+  expect(follow.community_view.community.name).toBe('main');
 
   // Check it from local
-  let site = await getSite(alpha);
-  let remoteCommunityId = site.my_user?.follows.find(
-    c => c.community.local == false,
-  )?.community.id;
+  let followCheck = await checkFollowedCommunities(alpha);
+  let remoteCommunityId = followCheck.communities.find(
+    c => c.community.local == false
+  ).community.id;
   expect(remoteCommunityId).toBeDefined();
-  expect(site.my_user?.follows.length).toBe(2);
-
-  if (!remoteCommunityId) {
-    throw "Missing remote community id";
-  }
 
   // Test an unfollow
   let unfollow = await followCommunity(alpha, false, remoteCommunityId);
-  expect(unfollow.community_view.subscribed).toBe("NotSubscribed");
+  expect(unfollow.community_view.community.local).toBe(false);
 
   // Make sure you are unsubbed locally
-  let siteUnfollowCheck = await getSite(alpha);
-  expect(siteUnfollowCheck.my_user?.follows.length).toBe(1);
-
-  // check that unfollow was federated
-  let communityOnBeta2 = await resolveBetaCommunity(beta);
-  expect(communityOnBeta2.community?.counts.subscribers).toBe(1);
-  expect(communityOnBeta2.community?.counts.subscribers_local).toBe(1);
+  let unfollowCheck = await checkFollowedCommunities(alpha);
+  expect(unfollowCheck.communities.length).toBeGreaterThanOrEqual(1);
 });

api_tests/src/image.spec.ts

@@ -1,363 +0,0 @@
-jest.setTimeout(120000);
-
-import {
-  UploadImage,
-  DeleteImage,
-  PurgePerson,
-  PurgePost,
-} from "lemmy-js-client";
-import {
-  alpha,
-  alphaImage,
-  alphaUrl,
-  beta,
-  betaUrl,
-  createCommunity,
-  createPost,
-  deleteAllImages,
-  epsilon,
-  followCommunity,
-  gamma,
-  getSite,
-  imageFetchLimit,
-  registerUser,
-  resolveBetaCommunity,
-  resolveCommunity,
-  resolvePost,
-  setupLogins,
-  waitForPost,
-  unfollows,
-  getPost,
-  waitUntil,
-  createPostWithThumbnail,
-  sampleImage,
-  sampleSite,
-} from "./shared";
-const downloadFileSync = require("download-file-sync");
-
-beforeAll(setupLogins);
-
-afterAll(async () => {
-  await Promise.all([unfollows(), deleteAllImages(alpha)]);
-});
-
-test("Upload image and delete it", async () => {
-  // Before running this test, you need to delete all previous images in the DB
-  await deleteAllImages(alpha);
-
-  // Upload test image. We use a simple string buffer as pictrs doesn't require an actual image
-  // in testing mode.
-  const upload_form: UploadImage = {
-    image: Buffer.from("test"),
-  };
-  const upload = await alphaImage.uploadImage(upload_form);
-  expect(upload.files![0].file).toBeDefined();
-  expect(upload.files![0].delete_token).toBeDefined();
-  expect(upload.url).toBeDefined();
-  expect(upload.delete_url).toBeDefined();
-
-  // ensure that image download is working. theres probably a better way to do this
-  const content = downloadFileSync(upload.url);
-  expect(content.length).toBeGreaterThan(0);
-
-  // Ensure that it comes back with the list_media endpoint
-  const listMediaRes = await alphaImage.listMedia();
-  expect(listMediaRes.images.length).toBe(1);
-
-  // Ensure that it also comes back with the admin all images
-  const listAllMediaRes = await alphaImage.listAllMedia({
-    limit: imageFetchLimit,
-  });
-
-  // This number comes from all the previous thumbnails fetched in other tests.
-  const previousThumbnails = 1;
-  expect(listAllMediaRes.images.length).toBe(previousThumbnails);
-
-  // The deleteUrl is a combination of the endpoint, delete token, and alias
-  let firstImage = listMediaRes.images[0];
-  let deleteUrl = `${alphaUrl}/pictrs/image/delete/${firstImage.local_image.pictrs_delete_token}/${firstImage.local_image.pictrs_alias}`;
-  expect(deleteUrl).toBe(upload.delete_url);
-
-  // Make sure the uploader is correct
-  expect(firstImage.person.actor_id).toBe(
-    `http://lemmy-alpha:8541/u/lemmy_alpha`,
-  );
-
-  // delete image
-  const delete_form: DeleteImage = {
-    token: upload.files![0].delete_token,
-    filename: upload.files![0].file,
-  };
-  const delete_ = await alphaImage.deleteImage(delete_form);
-  expect(delete_).toBe(true);
-
-  // ensure that image is deleted
-  const content2 = downloadFileSync(upload.url);
-  expect(content2).toBe("");
-
-  // Ensure that it shows the image is deleted
-  const deletedListMediaRes = await alphaImage.listMedia();
-  expect(deletedListMediaRes.images.length).toBe(0);
-
-  // Ensure that the admin shows its deleted
-  const deletedListAllMediaRes = await alphaImage.listAllMedia({
-    limit: imageFetchLimit,
-  });
-  expect(deletedListAllMediaRes.images.length).toBe(previousThumbnails - 1);
-});
-
-test("Purge user, uploaded image removed", async () => {
-  let user = await registerUser(alphaImage, alphaUrl);
-
-  // upload test image
-  const upload_form: UploadImage = {
-    image: Buffer.from("test"),
-  };
-  const upload = await user.uploadImage(upload_form);
-  expect(upload.files![0].file).toBeDefined();
-  expect(upload.files![0].delete_token).toBeDefined();
-  expect(upload.url).toBeDefined();
-  expect(upload.delete_url).toBeDefined();
-
-  // ensure that image download is working. theres probably a better way to do this
-  const content = downloadFileSync(upload.url);
-  expect(content.length).toBeGreaterThan(0);
-
-  // purge user
-  let site = await getSite(user);
-  const purgeForm: PurgePerson = {
-    person_id: site.my_user!.local_user_view.person.id,
-  };
-  const delete_ = await alphaImage.purgePerson(purgeForm);
-  expect(delete_.success).toBe(true);
-
-  // ensure that image is deleted
-  const content2 = downloadFileSync(upload.url);
-  expect(content2).toBe("");
-});
-
-test("Purge post, linked image removed", async () => {
-  let user = await registerUser(beta, betaUrl);
-
-  // upload test image
-  const upload_form: UploadImage = {
-    image: Buffer.from("test"),
-  };
-  const upload = await user.uploadImage(upload_form);
-  expect(upload.files![0].file).toBeDefined();
-  expect(upload.files![0].delete_token).toBeDefined();
-  expect(upload.url).toBeDefined();
-  expect(upload.delete_url).toBeDefined();
-
-  // ensure that image download is working. theres probably a better way to do this
-  const content = downloadFileSync(upload.url);
-  expect(content.length).toBeGreaterThan(0);
-
-  let community = await resolveBetaCommunity(user);
-  let post = await createPost(
-    user,
-    community.community!.community.id,
-    upload.url,
-  );
-  expect(post.post_view.post.url).toBe(upload.url);
-
-  // purge post
-  const purgeForm: PurgePost = {
-    post_id: post.post_view.post.id,
-  };
-  const delete_ = await beta.purgePost(purgeForm);
-  expect(delete_.success).toBe(true);
-
-  // ensure that image is deleted
-  const content2 = downloadFileSync(upload.url);
-  expect(content2).toBe("");
-});
-
-test("Images in remote image post are proxied if setting enabled", async () => {
-  let community = await createCommunity(gamma);
-  let postRes = await createPost(
-    gamma,
-    community.community_view.community.id,
-    sampleImage,
-    `![](${sampleImage})`,
-  );
-  const post = postRes.post_view.post;
-  expect(post).toBeDefined();
-
-  // remote image gets proxied after upload
-  expect(
-    post.thumbnail_url?.startsWith(
-      "http://lemmy-gamma:8561/api/v3/image_proxy?url",
-    ),
-  ).toBeTruthy();
-  expect(
-    post.body?.startsWith("![](http://lemmy-gamma:8561/api/v3/image_proxy?url"),
-  ).toBeTruthy();
-
-  // Make sure that it ends with jpg, to be sure its an image
-  expect(post.thumbnail_url?.endsWith(".jpg")).toBeTruthy();
-
-  let epsilonPostRes = await resolvePost(epsilon, postRes.post_view.post);
-  expect(epsilonPostRes.post).toBeDefined();
-
-  // Fetch the post again, the metadata should be backgrounded now
-  // Wait for the metadata to get fetched, since this is backgrounded now
-  let epsilonPostRes2 = await waitUntil(
-    () => getPost(epsilon, epsilonPostRes.post!.post.id),
-    p => p.post_view.post.thumbnail_url != undefined,
-  );
-  const epsilonPost = epsilonPostRes2.post_view.post;
-
-  expect(
-    epsilonPost.thumbnail_url?.startsWith(
-      "http://lemmy-epsilon:8581/api/v3/image_proxy?url",
-    ),
-  ).toBeTruthy();
-  expect(
-    epsilonPost.body?.startsWith(
-      "![](http://lemmy-epsilon:8581/api/v3/image_proxy?url",
-    ),
-  ).toBeTruthy();
-
-  // Make sure that it ends with jpg, to be sure its an image
-  expect(epsilonPost.thumbnail_url?.endsWith(".jpg")).toBeTruthy();
-});
-
-test("Thumbnail of remote image link is proxied if setting enabled", async () => {
-  let community = await createCommunity(gamma);
-  let postRes = await createPost(
-    gamma,
-    community.community_view.community.id,
-    // The sample site metadata thumbnail ends in png
-    sampleSite,
-  );
-  const post = postRes.post_view.post;
-  expect(post).toBeDefined();
-
-  // remote image gets proxied after upload
-  expect(
-    post.thumbnail_url?.startsWith(
-      "http://lemmy-gamma:8561/api/v3/image_proxy?url",
-    ),
-  ).toBeTruthy();
-
-  // Make sure that it ends with png, to be sure its an image
-  expect(post.thumbnail_url?.endsWith(".png")).toBeTruthy();
-
-  let epsilonPostRes = await resolvePost(epsilon, postRes.post_view.post);
-  expect(epsilonPostRes.post).toBeDefined();
-
-  let epsilonPostRes2 = await waitUntil(
-    () => getPost(epsilon, epsilonPostRes.post!.post.id),
-    p => p.post_view.post.thumbnail_url != undefined,
-  );
-  const epsilonPost = epsilonPostRes2.post_view.post;
-
-  expect(
-    epsilonPost.thumbnail_url?.startsWith(
-      "http://lemmy-epsilon:8581/api/v3/image_proxy?url",
-    ),
-  ).toBeTruthy();
-
-  // Make sure that it ends with png, to be sure its an image
-  expect(epsilonPost.thumbnail_url?.endsWith(".png")).toBeTruthy();
-});
-
-test("No image proxying if setting is disabled", async () => {
-  let user = await registerUser(beta, betaUrl);
-  let community = await createCommunity(alpha);
-  let betaCommunity = await resolveCommunity(
-    beta,
-    community.community_view.community.actor_id,
-  );
-  await followCommunity(beta, true, betaCommunity.community!.community.id);
-
-  const upload_form: UploadImage = {
-    image: Buffer.from("test"),
-  };
-  const upload = await user.uploadImage(upload_form);
-  let post = await createPost(
-    alpha,
-    community.community_view.community.id,
-    upload.url,
-    `![](${sampleImage})`,
-  );
-  expect(post.post_view.post).toBeDefined();
-
-  // remote image doesn't get proxied after upload
-  expect(
-    post.post_view.post.url?.startsWith("http://127.0.0.1:8551/pictrs/image/"),
-  ).toBeTruthy();
-  expect(post.post_view.post.body).toBe(`![](${sampleImage})`);
-
-  let betaPost = await waitForPost(
-    beta,
-    post.post_view.post,
-    res => res?.post.alt_text != null,
-  );
-  expect(betaPost.post).toBeDefined();
-
-  // remote image doesn't get proxied after federation
-  expect(
-    betaPost.post.url?.startsWith("http://127.0.0.1:8551/pictrs/image/"),
-  ).toBeTruthy();
-  expect(betaPost.post.body).toBe(`![](${sampleImage})`);
-  // Make sure the alt text got federated
-  expect(post.post_view.post.alt_text).toBe(betaPost.post.alt_text);
-});
-
-test("Make regular post, and give it a custom thumbnail", async () => {
-  const uploadForm1: UploadImage = {
-    image: Buffer.from("testRegular1"),
-  };
-  const upload1 = await alphaImage.uploadImage(uploadForm1);
-
-  const community = await createCommunity(alphaImage);
-
-  // Use wikipedia since it has an opengraph image
-  const wikipediaUrl = "https://wikipedia.org/";
-
-  let post = await createPostWithThumbnail(
-    alphaImage,
-    community.community_view.community.id,
-    wikipediaUrl,
-    upload1.url!,
-  );
-
-  // Wait for the metadata to get fetched, since this is backgrounded now
-  post = await waitUntil(
-    () => getPost(alphaImage, post.post_view.post.id),
-    p => p.post_view.post.thumbnail_url != undefined,
-  );
-  expect(post.post_view.post.url).toBe(wikipediaUrl);
-  // Make sure it uses custom thumbnail
-  expect(post.post_view.post.thumbnail_url).toBe(upload1.url);
-});
-
-test("Create an image post, and make sure a custom thumbnail doesn't overwrite it", async () => {
-  const uploadForm1: UploadImage = {
-    image: Buffer.from("test1"),
-  };
-  const upload1 = await alphaImage.uploadImage(uploadForm1);
-
-  const uploadForm2: UploadImage = {
-    image: Buffer.from("test2"),
-  };
-  const upload2 = await alphaImage.uploadImage(uploadForm2);
-
-  const community = await createCommunity(alphaImage);
-
-  let post = await createPostWithThumbnail(
-    alphaImage,
-    community.community_view.community.id,
-    upload1.url!,
-    upload2.url!,
-  );
-  post = await waitUntil(
-    () => getPost(alphaImage, post.post_view.post.id),
-    p => p.post_view.post.thumbnail_url != undefined,
-  );
-  expect(post.post_view.post.url).toBe(upload1.url);
-  // Make sure the custom thumbnail is ignored
-  expect(post.post_view.post.thumbnail_url == upload2.url).toBe(false);
-});

api_tests/src/post.spec.ts

@@ -1,6 +1,4 @@
 jest.setTimeout(120000);
-
-import { CommunityView } from "lemmy-js-client/dist/types/CommunityView";
 import {
   alpha,
   beta,
@@ -10,139 +8,92 @@ import {
   setupLogins,
   createPost,
   editPost,
-  featurePost,
+  stickyPost,
   lockPost,
-  resolvePost,
+  searchPost,
   likePost,
   followBeta,
-  resolveBetaCommunity,
+  searchForBetaCommunity,
   createComment,
   deletePost,
-  delay,
   removePost,
   getPost,
   unfollowRemotes,
-  resolvePerson,
-  banPersonFromSite,
-  followCommunity,
-  banPersonFromCommunity,
-  reportPost,
-  listPostReports,
-  randomString,
-  registerUser,
-  getSite,
-  unfollows,
-  resolveCommunity,
-  waitUntil,
-  waitForPost,
-  alphaUrl,
-  loginUser,
-  createCommunity,
-} from "./shared";
-import { PostView } from "lemmy-js-client/dist/types/PostView";
-import { EditSite, ResolveObject } from "lemmy-js-client";
+  searchForUser,
+  banUserFromSite,
+  searchPostLocal,
+  banUserFromCommunity,
+} from './shared';
+import { PostView, CommunityView } from 'lemmy-js-client';
 
-let betaCommunity: CommunityView | undefined;
+let betaCommunity: CommunityView;
 
 beforeAll(async () => {
   await setupLogins();
-  betaCommunity = (await resolveBetaCommunity(alpha)).community;
-  expect(betaCommunity).toBeDefined();
+  let search = await searchForBetaCommunity(alpha);
+  betaCommunity = search.communities[0];
+  await unfollows();
 });
 
-afterAll(unfollows);
+afterAll(async () => {
+  await unfollows();
+});
 
-async function assertPostFederation(postOne: PostView, postTwo: PostView) {
-  // Link metadata is generated in background task and may not be ready yet at this time,
-  // so wait for it explicitly. For removed posts we cant refetch anything.
-  postOne = await waitForPost(beta, postOne.post, res => {
-    return res === null || res?.post.embed_title !== null;
-  });
-  postTwo = await waitForPost(
-    beta,
-    postTwo.post,
-    res => res === null || res?.post.embed_title !== null,
-  );
-
-  expect(postOne?.post.ap_id).toBe(postTwo?.post.ap_id);
-  expect(postOne?.post.name).toBe(postTwo?.post.name);
-  expect(postOne?.post.body).toBe(postTwo?.post.body);
-  // TODO url clears arent working
-  // expect(postOne?.post.url).toBe(postTwo?.post.url);
-  expect(postOne?.post.nsfw).toBe(postTwo?.post.nsfw);
-  expect(postOne?.post.embed_title).toBe(postTwo?.post.embed_title);
-  expect(postOne?.post.embed_description).toBe(postTwo?.post.embed_description);
-  expect(postOne?.post.embed_video_url).toBe(postTwo?.post.embed_video_url);
-  expect(postOne?.post.published).toBe(postTwo?.post.published);
-  expect(postOne?.community.actor_id).toBe(postTwo?.community.actor_id);
-  expect(postOne?.post.locked).toBe(postTwo?.post.locked);
-  expect(postOne?.post.removed).toBe(postTwo?.post.removed);
-  expect(postOne?.post.deleted).toBe(postTwo?.post.deleted);
+async function unfollows() {
+  await unfollowRemotes(alpha);
+  await unfollowRemotes(gamma);
+  await unfollowRemotes(delta);
+  await unfollowRemotes(epsilon);
 }
 
-test("Create a post", async () => {
-  // Setup some allowlists and blocklists
-  const editSiteForm: EditSite = {};
+function assertPostFederation(postOne: PostView, postTwo: PostView) {
+  expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
+  expect(postOne.post.name).toBe(postTwo.post.name);
+  expect(postOne.post.body).toBe(postTwo.post.body);
+  expect(postOne.post.url).toBe(postTwo.post.url);
+  expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
+  expect(postOne.post.embed_title).toBe(postTwo.post.embed_title);
+  expect(postOne.post.embed_description).toBe(postTwo.post.embed_description);
+  expect(postOne.post.embed_html).toBe(postTwo.post.embed_html);
+  expect(postOne.post.published).toBe(postTwo.post.published);
+  expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
+  expect(postOne.post.locked).toBe(postTwo.post.locked);
+  expect(postOne.post.removed).toBe(postTwo.post.removed);
+  expect(postOne.post.deleted).toBe(postTwo.post.deleted);
+}
 
-  editSiteForm.allowed_instances = [];
-  editSiteForm.blocked_instances = ["lemmy-alpha"];
-  await epsilon.editSite(editSiteForm);
-
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-
-  let postRes = await createPost(
-    alpha,
-    betaCommunity.community.id,
-    "https://example.com/",
-    "აშშ ითხოვს ირანს დაუყოვნებლივ გაანთავისუფლოს დაკავებული ნავთობის ტანკერი",
-  );
+test('Create a post', async () => {
+  let postRes = await createPost(alpha, betaCommunity.community.id);
   expect(postRes.post_view.post).toBeDefined();
   expect(postRes.post_view.community.local).toBe(false);
   expect(postRes.post_view.creator.local).toBe(true);
   expect(postRes.post_view.counts.score).toBe(1);
 
   // Make sure that post is liked on beta
-  const betaPost = await waitForPost(
-    beta,
-    postRes.post_view.post,
-    res => res?.counts.score === 1,
-  );
+  let searchBeta = await searchPost(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
 
   expect(betaPost).toBeDefined();
-  expect(betaPost?.community.local).toBe(true);
-  expect(betaPost?.creator.local).toBe(false);
-  expect(betaPost?.counts.score).toBe(1);
-  await assertPostFederation(betaPost, postRes.post_view);
+  expect(betaPost.community.local).toBe(true);
+  expect(betaPost.creator.local).toBe(false);
+  expect(betaPost.counts.score).toBe(1);
+  assertPostFederation(betaPost, postRes.post_view);
 
   // Delta only follows beta, so it should not see an alpha ap_id
-  await expect(
-    resolvePost(delta, postRes.post_view.post),
-  ).rejects.toStrictEqual(Error("couldnt_find_object"));
+  let searchDelta = await searchPost(delta, postRes.post_view.post);
+  expect(searchDelta.posts[0]).toBeUndefined();
 
   // Epsilon has alpha blocked, it should not see the alpha post
-  await expect(
-    resolvePost(epsilon, postRes.post_view.post),
-  ).rejects.toStrictEqual(Error("couldnt_find_object"));
-
-  // remove added allow/blocklists
-  editSiteForm.allowed_instances = [];
-  editSiteForm.blocked_instances = [];
-  await delta.editSite(editSiteForm);
-  await epsilon.editSite(editSiteForm);
+  let searchEpsilon = await searchPost(epsilon, postRes.post_view.post);
+  expect(searchEpsilon.posts[0]).toBeUndefined();
 });
 
-test("Create a post in a non-existent community", async () => {
-  await expect(createPost(alpha, -2)).rejects.toStrictEqual(
-    Error("couldnt_find_community"),
-  );
+test('Create a post in a non-existent community', async () => {
+  let postRes = await createPost(alpha, -2);
+  expect(postRes).toStrictEqual({ error: 'couldnt_create_post' });
 });
 
-test("Unlike a post", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
+test('Unlike a post', async () => {
   let postRes = await createPost(alpha, betaCommunity.community.id);
   let unlike = await likePost(alpha, 0, postRes.post_view.post);
   expect(unlike.post_view.counts.score).toBe(0);
@@ -152,630 +103,257 @@ test("Unlike a post", async () => {
   expect(unlike2.post_view.counts.score).toBe(0);
 
   // Make sure that post is unliked on beta
-  const betaPost = await waitForPost(
-    beta,
-    postRes.post_view.post,
-    post => post?.counts.score === 0,
-  );
-
+  let searchBeta = await searchPost(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
   expect(betaPost).toBeDefined();
-  expect(betaPost?.community.local).toBe(true);
-  expect(betaPost?.creator.local).toBe(false);
-  expect(betaPost?.counts.score).toBe(0);
-  await assertPostFederation(betaPost, postRes.post_view);
+  expect(betaPost.community.local).toBe(true);
+  expect(betaPost.creator.local).toBe(false);
+  expect(betaPost.counts.score).toBe(0);
+  assertPostFederation(betaPost, postRes.post_view);
 });
 
-test("Update a post", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
+test('Update a post', async () => {
   let postRes = await createPost(alpha, betaCommunity.community.id);
-  await waitForPost(beta, postRes.post_view.post);
 
-  let updatedName = "A jest test federated post, updated";
+  let updatedName = 'A jest test federated post, updated';
   let updatedPost = await editPost(alpha, postRes.post_view.post);
   expect(updatedPost.post_view.post.name).toBe(updatedName);
   expect(updatedPost.post_view.community.local).toBe(false);
   expect(updatedPost.post_view.creator.local).toBe(true);
 
   // Make sure that post is updated on beta
-  let betaPost = await waitForPost(beta, updatedPost.post_view.post);
+  let searchBeta = await searchPost(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
   expect(betaPost.community.local).toBe(true);
   expect(betaPost.creator.local).toBe(false);
   expect(betaPost.post.name).toBe(updatedName);
-  await assertPostFederation(betaPost, updatedPost.post_view);
+  assertPostFederation(betaPost, updatedPost.post_view);
 
   // Make sure lemmy beta cannot update the post
-  await expect(editPost(beta, betaPost.post)).rejects.toStrictEqual(
-    Error("no_post_edit_allowed"),
-  );
+  let updatedPostBeta = await editPost(beta, betaPost.post);
+  expect(updatedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
 });
 
-test("Sticky a post", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
+test('Sticky a post', async () => {
   let postRes = await createPost(alpha, betaCommunity.community.id);
 
-  let betaPost1 = await waitForPost(beta, postRes.post_view.post);
-  if (!betaPost1) {
-    throw "Missing beta post1";
-  }
-  let stickiedPostRes = await featurePost(beta, true, betaPost1.post);
-  expect(stickiedPostRes.post_view.post.featured_community).toBe(true);
+  let stickiedPostRes = await stickyPost(alpha, true, postRes.post_view.post);
+  expect(stickiedPostRes.post_view.post.stickied).toBe(true);
 
   // Make sure that post is stickied on beta
-  let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
-  expect(betaPost?.community.local).toBe(true);
-  expect(betaPost?.creator.local).toBe(false);
-  expect(betaPost?.post.featured_community).toBe(true);
+  let searchBeta = await searchPost(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
+  expect(betaPost.community.local).toBe(true);
+  expect(betaPost.creator.local).toBe(false);
+  expect(betaPost.post.stickied).toBe(true);
 
   // Unsticky a post
-  let unstickiedPost = await featurePost(beta, false, betaPost1.post);
-  expect(unstickiedPost.post_view.post.featured_community).toBe(false);
+  let unstickiedPost = await stickyPost(alpha, false, postRes.post_view.post);
+  expect(unstickiedPost.post_view.post.stickied).toBe(false);
 
   // Make sure that post is unstickied on beta
-  let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
-  expect(betaPost2?.community.local).toBe(true);
-  expect(betaPost2?.creator.local).toBe(false);
-  expect(betaPost2?.post.featured_community).toBe(false);
+  let searchBeta2 = await searchPost(beta, postRes.post_view.post);
+  let betaPost2 = searchBeta2.posts[0];
+  expect(betaPost2.community.local).toBe(true);
+  expect(betaPost2.creator.local).toBe(false);
+  expect(betaPost2.post.stickied).toBe(false);
 
   // Make sure that gamma cannot sticky the post on beta
-  let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
-  if (!gammaPost) {
-    throw "Missing gamma post";
-  }
-  // This has been failing occasionally
-  await featurePost(gamma, true, gammaPost.post);
-  let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post;
-  // expect(gammaTrySticky.post_view.post.featured_community).toBe(true);
-  expect(betaPost3?.post.featured_community).toBe(false);
+  let searchGamma = await searchPost(gamma, postRes.post_view.post);
+  let gammaPost = searchGamma.posts[0];
+  let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
+  let searchBeta3 = await searchPost(beta, postRes.post_view.post);
+  let betaPost3 = searchBeta3.posts[0];
+  expect(gammaTrySticky.post_view.post.stickied).toBe(true);
+  expect(betaPost3.post.stickied).toBe(false);
 });
 
-test("Collection of featured posts gets federated", async () => {
-  // create a new community and feature a post
-  let community = await createCommunity(alpha);
-  let post = await createPost(alpha, community.community_view.community.id);
-  let featuredPost = await featurePost(alpha, true, post.post_view.post);
-  expect(featuredPost.post_view.post.featured_community).toBe(true);
-
-  // fetch the community, ensure that post is also fetched and marked as featured
-  let betaCommunity = await resolveCommunity(
-    beta,
-    community.community_view.community.actor_id,
-  );
-  expect(betaCommunity).toBeDefined();
-
-  const betaPost = await waitForPost(
-    beta,
-    post.post_view.post,
-    post => post?.post.featured_community === true,
-  );
-  expect(betaPost).toBeDefined();
-});
-
-test("Lock a post", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-  await followCommunity(alpha, true, betaCommunity.community.id);
-  await waitUntil(
-    () => resolveBetaCommunity(alpha),
-    c => c.community?.subscribed === "Subscribed",
-  );
-
+test('Lock a post', async () => {
   let postRes = await createPost(alpha, betaCommunity.community.id);
-  let betaPost1 = await waitForPost(beta, postRes.post_view.post);
+
   // Lock the post
-  let lockedPostRes = await lockPost(beta, true, betaPost1.post);
+  let lockedPostRes = await lockPost(alpha, true, postRes.post_view.post);
   expect(lockedPostRes.post_view.post.locked).toBe(true);
 
-  // Make sure that post is locked on alpha
-  let alphaPost1 = await waitForPost(
-    alpha,
-    postRes.post_view.post,
-    post => !!post && post.post.locked,
-  );
+  // Make sure that post is locked on beta
+  let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
+  let betaPost1 = searchBeta.posts[0];
+  expect(betaPost1.post.locked).toBe(true);
 
-  // Try to make a new comment there, on alpha. For this we need to create a normal
-  // user account because admins/mods can comment in locked posts.
-  let user = await registerUser(alpha, alphaUrl);
-  await expect(createComment(user, alphaPost1.post.id)).rejects.toStrictEqual(
-    Error("locked"),
-  );
+  // Try to make a new comment there, on alpha
+  let comment: any = await createComment(alpha, postRes.post_view.post.id);
+  expect(comment['error']).toBe('locked');
 
   // Unlock a post
-  let unlockedPost = await lockPost(beta, false, betaPost1.post);
+  let unlockedPost = await lockPost(alpha, false, postRes.post_view.post);
   expect(unlockedPost.post_view.post.locked).toBe(false);
 
-  // Make sure that post is unlocked on alpha
-  let alphaPost2 = await waitForPost(
-    alpha,
-    postRes.post_view.post,
-    post => !!post && !post.post.locked,
-  );
-  expect(alphaPost2.community.local).toBe(false);
-  expect(alphaPost2.creator.local).toBe(true);
-  expect(alphaPost2.post.locked).toBe(false);
+  // Make sure that post is unlocked on beta
+  let searchBeta2 = await searchPost(beta, postRes.post_view.post);
+  let betaPost2 = searchBeta2.posts[0];
+  expect(betaPost2.community.local).toBe(true);
+  expect(betaPost2.creator.local).toBe(false);
+  expect(betaPost2.post.locked).toBe(false);
 
-  // Try to create a new comment, on alpha
-  let commentAlpha = await createComment(user, alphaPost1.post.id);
-  expect(commentAlpha).toBeDefined();
+  // Try to create a new comment, on beta
+  let commentBeta = await createComment(beta, betaPost2.post.id);
+  expect(commentBeta).toBeDefined();
 });
 
-test("Delete a post", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-
+test('Delete a post', async () => {
   let postRes = await createPost(alpha, betaCommunity.community.id);
   expect(postRes.post_view.post).toBeDefined();
-  await waitForPost(beta, postRes.post_view.post);
 
   let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
   expect(deletedPost.post_view.post.deleted).toBe(true);
-  expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
 
   // Make sure lemmy beta sees post is deleted
+  let searchBeta = await searchPost(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
   // This will be undefined because of the tombstone
-  await waitForPost(beta, postRes.post_view.post, p => !p || p.post.deleted);
+  expect(betaPost).toBeUndefined();
 
   // Undelete
   let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
+  expect(undeletedPost.post_view.post.deleted).toBe(false);
 
   // Make sure lemmy beta sees post is undeleted
-  let betaPost2 = await waitForPost(
-    beta,
-    postRes.post_view.post,
-    p => !!p && !p.post.deleted,
-  );
-
-  if (!betaPost2) {
-    throw "Missing beta post 2";
-  }
+  let searchBeta2 = await searchPost(beta, postRes.post_view.post);
+  let betaPost2 = searchBeta2.posts[0];
   expect(betaPost2.post.deleted).toBe(false);
-  await assertPostFederation(betaPost2, undeletedPost.post_view);
+  assertPostFederation(betaPost2, undeletedPost.post_view);
 
   // Make sure lemmy beta cannot delete the post
-  await expect(deletePost(beta, true, betaPost2.post)).rejects.toStrictEqual(
-    Error("no_post_edit_allowed"),
-  );
+  let deletedPostBeta = await deletePost(beta, true, betaPost2.post);
+  expect(deletedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
 });
 
-test("Remove a post from admin and community on different instance", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
+test('Remove a post from admin and community on different instance', async () => {
+  let postRes = await createPost(alpha, betaCommunity.community.id);
 
-  let gammaCommunity = (
-    await resolveCommunity(gamma, betaCommunity.community.actor_id)
-  ).community?.community;
-  if (!gammaCommunity) {
-    throw "Missing gamma community";
-  }
-  let postRes = await createPost(gamma, gammaCommunity.id);
-
-  let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
-  if (!alphaPost) {
-    throw "Missing alpha post";
-  }
-  let removedPost = await removePost(alpha, true, alphaPost.post);
+  let removedPost = await removePost(alpha, true, postRes.post_view.post);
   expect(removedPost.post_view.post.removed).toBe(true);
-  expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
 
   // Make sure lemmy beta sees post is NOT removed
-  let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
-  if (!betaPost) {
-    throw "Missing beta post";
-  }
+  let searchBeta = await searchPost(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
   expect(betaPost.post.removed).toBe(false);
 
   // Undelete
-  let undeletedPost = await removePost(alpha, false, alphaPost.post);
+  let undeletedPost = await removePost(alpha, false, postRes.post_view.post);
   expect(undeletedPost.post_view.post.removed).toBe(false);
 
   // Make sure lemmy beta sees post is undeleted
-  let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
-  expect(betaPost2?.post.removed).toBe(false);
-  await assertPostFederation(betaPost2!, undeletedPost.post_view);
+  let searchBeta2 = await searchPost(beta, postRes.post_view.post);
+  let betaPost2 = searchBeta2.posts[0];
+  expect(betaPost2.post.removed).toBe(false);
+  assertPostFederation(betaPost2, undeletedPost.post_view);
 });
 
-test("Remove a post from admin and community on same instance", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
+test('Remove a post from admin and community on same instance', async () => {
   await followBeta(alpha);
-  let gammaCommunity = await resolveCommunity(
-    gamma,
-    betaCommunity.community.actor_id,
-  );
-  let postRes = await createPost(gamma, gammaCommunity.community!.community.id);
+  let postRes = await createPost(alpha, betaCommunity.community.id);
   expect(postRes.post_view.post).toBeDefined();
-  // Get the id for beta
-  let betaPost = await waitForPost(beta, postRes.post_view.post);
-  expect(betaPost).toBeDefined();
 
-  let alphaPost0 = await waitForPost(alpha, postRes.post_view.post);
-  expect(alphaPost0).toBeDefined();
+  // Get the id for beta
+  let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
+  expect(betaPost).toBeDefined();
 
   // The beta admin removes it (the community lives on beta)
   let removePostRes = await removePost(beta, true, betaPost.post);
   expect(removePostRes.post_view.post.removed).toBe(true);
 
   // Make sure lemmy alpha sees post is removed
-  let alphaPost = await waitUntil(
-    () => getPost(alpha, alphaPost0.post.id),
-    p => p?.post_view.post.removed ?? false,
-  );
-  expect(alphaPost?.post_view.post.removed).toBe(true);
-  await assertPostFederation(alphaPost.post_view, removePostRes.post_view);
+  let alphaPost = await getPost(alpha, postRes.post_view.post.id);
+  // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
+  // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
 
   // Undelete
   let undeletedPost = await removePost(beta, false, betaPost.post);
   expect(undeletedPost.post_view.post.removed).toBe(false);
 
   // Make sure lemmy alpha sees post is undeleted
-  let alphaPost2 = await waitForPost(
-    alpha,
-    postRes.post_view.post,
-    p => !!p && !p.post.removed,
-  );
-  expect(alphaPost2.post.removed).toBe(false);
-  await assertPostFederation(alphaPost2, undeletedPost.post_view);
+  let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
+  expect(alphaPost2.post_view.post.removed).toBe(false);
+  assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
   await unfollowRemotes(alpha);
 });
 
-test("Search for a post", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
+test('Search for a post', async () => {
   await unfollowRemotes(alpha);
   let postRes = await createPost(alpha, betaCommunity.community.id);
   expect(postRes.post_view.post).toBeDefined();
 
-  let betaPost = await waitForPost(beta, postRes.post_view.post);
-  expect(betaPost?.post.name).toBeDefined();
+  let searchBeta = await searchPost(beta, postRes.post_view.post);
+
+  expect(searchBeta.posts[0].post.name).toBeDefined();
 });
 
-test("Enforce site ban federation for local user", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
+test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
+  let postRes = await createPost(alpha, betaCommunity.community.id);
+  expect(postRes.post_view.post).toBeDefined();
 
-  // create a test user
-  let alphaUserHttp = await registerUser(alpha, alphaUrl);
-  let alphaUserPerson = (await getSite(alphaUserHttp)).my_user?.local_user_view
-    .person;
-  let alphaUserActorId = alphaUserPerson?.actor_id;
-  if (!alphaUserActorId) {
-    throw "Missing alpha user actor id";
-  }
-  expect(alphaUserActorId).toBeDefined();
-  await followBeta(alphaUserHttp);
-
-  let alphaPerson = (await resolvePerson(alphaUserHttp, alphaUserActorId!))
-    .person;
-  if (!alphaPerson) {
-    throw "Missing alpha person";
-  }
-  expect(alphaPerson).toBeDefined();
-
-  // alpha makes post in beta community, it federates to beta instance
-  let postRes1 = await createPost(alphaUserHttp, betaCommunity.community.id);
-  let searchBeta1 = await waitForPost(beta, postRes1.post_view.post);
-
-  // ban alpha from its own instance
-  let banAlpha = await banPersonFromSite(
-    alpha,
-    alphaPerson.person.id,
-    true,
-    true,
-  );
-  expect(banAlpha.banned).toBe(true);
-
-  // alpha ban should be federated to beta
-  let alphaUserOnBeta1 = await waitUntil(
-    () => resolvePerson(beta, alphaUserActorId!),
-    res => res.person?.person.banned ?? false,
-  );
-  expect(alphaUserOnBeta1.person?.person.banned).toBe(true);
-
-  // existing alpha post should be removed on beta
-  let betaBanRes = await waitUntil(
-    () => getPost(beta, searchBeta1.post.id),
-    s => s.post_view.post.removed,
-  );
-  expect(betaBanRes.post_view.post.removed).toBe(true);
-
-  // Unban alpha
-  let unBanAlpha = await banPersonFromSite(
-    alpha,
-    alphaPerson.person.id,
-    false,
-    false,
-  );
-  expect(unBanAlpha.banned).toBe(false);
-
-  // Login gets invalidated by ban, need to login again
-  if (!alphaUserPerson) {
-    throw "Missing alpha person";
-  }
-  let newAlphaUserJwt = await loginUser(alpha, alphaUserPerson.name);
-  alphaUserHttp.setHeaders({
-    Authorization: "Bearer " + newAlphaUserJwt.jwt ?? "",
-  });
-  // alpha makes new post in beta community, it federates
-  let postRes2 = await createPost(alphaUserHttp, betaCommunity!.community.id);
-  await waitForPost(beta, postRes2.post_view.post);
-
-  await unfollowRemotes(alpha);
+  let search2 = await searchPost(gamma, postRes.post_view.post);
+  expect(search2.posts[0].post.name).toBeDefined();
 });
 
-test("Enforce site ban federation for federated user", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-
-  // create a test user
-  let alphaUserHttp = await registerUser(alpha, alphaUrl);
-  let alphaUserPerson = (await getSite(alphaUserHttp)).my_user?.local_user_view
-    .person;
-  let alphaUserActorId = alphaUserPerson?.actor_id;
-  if (!alphaUserActorId) {
-    throw "Missing alpha user actor id";
-  }
-  expect(alphaUserActorId).toBeDefined();
-  await followBeta(alphaUserHttp);
-
-  let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId!);
-  expect(alphaUserOnBeta2.person?.person.banned).toBe(false);
-
-  if (!alphaUserOnBeta2.person) {
-    throw "Missing alpha person";
-  }
-
-  // alpha makes post in beta community, it federates to beta instance
-  let postRes1 = await createPost(alphaUserHttp, betaCommunity.community.id);
-  let searchBeta1 = await waitForPost(beta, postRes1.post_view.post);
-  expect(searchBeta1.post).toBeDefined();
-
-  // Now ban and remove their data from beta
-  let banAlphaOnBeta = await banPersonFromSite(
-    beta,
-    alphaUserOnBeta2.person.person.id,
-    true,
-    true,
-  );
-  expect(banAlphaOnBeta.banned).toBe(true);
-
-  // The beta site ban should NOT be federated to alpha
-  let alphaPerson2 = (await getSite(alphaUserHttp)).my_user!.local_user_view
-    .person;
-  expect(alphaPerson2.banned).toBe(false);
-
-  // existing alpha post should be removed on beta
-  let betaBanRes = await waitUntil(
-    () => getPost(beta, searchBeta1.post.id),
-    s => s.post_view.post.removed,
-  );
-  expect(betaBanRes.post_view.post.removed).toBe(true);
-
-  // existing alpha's post to the beta community should be removed on alpha
-  let alphaPostAfterRemoveOnBeta = await waitUntil(
-    () => getPost(alpha, postRes1.post_view.post.id),
-    s => s.post_view.post.removed,
-  );
-  expect(betaBanRes.post_view.post.removed).toBe(true);
-  expect(alphaPostAfterRemoveOnBeta.post_view.post.removed).toBe(true);
-  expect(
-    alphaPostAfterRemoveOnBeta.post_view.creator_banned_from_community,
-  ).toBe(true);
-
-  await unfollowRemotes(alpha);
-});
-
-test("Enforce community ban for federated user", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-  await followBeta(alpha);
+test('Enforce site ban for federated user', async () => {
   let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
-  let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
-  if (!alphaPerson) {
-    throw "Missing alpha person";
-  }
-  expect(alphaPerson).toBeDefined();
+  let userSearch = await searchForUser(beta, alphaShortname);
+  let alphaUser = userSearch.users[0];
+  expect(alphaUser).toBeDefined();
 
-  // make a post in beta, it goes through
-  let postRes1 = await createPost(alpha, betaCommunity.community.id);
-  let searchBeta1 = await waitForPost(beta, postRes1.post_view.post);
-  expect(searchBeta1.post).toBeDefined();
-
-  // ban alpha from beta community
-  let banAlpha = await banPersonFromCommunity(
-    beta,
-    alphaPerson.person.id,
-    searchBeta1.community.id,
-    true,
-    true,
-  );
+  // ban alpha from beta site
+  let banAlpha = await banUserFromSite(beta, alphaUser.user.id, true);
   expect(banAlpha.banned).toBe(true);
 
-  // ensure that the post by alpha got removed
-  let removePostRes = await waitUntil(
-    () => getPost(alpha, postRes1.post_view.post.id),
-    s => s.post_view.post.removed,
-  );
-  expect(removePostRes.post_view.post.removed).toBe(true);
-  expect(removePostRes.post_view.creator_banned_from_community).toBe(true);
-  expect(removePostRes.community_view.banned_from_community).toBe(true);
-
-  // Alpha tries to make post on beta, but it fails because of ban
-  await expect(
-    createPost(alpha, betaCommunity.community.id),
-  ).rejects.toStrictEqual(Error("banned_from_community"));
-
-  // Unban alpha
-  let unBanAlpha = await banPersonFromCommunity(
-    beta,
-    alphaPerson.person.id,
-    searchBeta1.community.id,
-    false,
-    false,
-  );
-  expect(unBanAlpha.banned).toBe(false);
-
-  // Need to re-follow the community
-  await followBeta(alpha);
-
-  let postRes3 = await createPost(alpha, betaCommunity.community.id);
-  expect(postRes3.post_view.post).toBeDefined();
-  expect(postRes3.post_view.community.local).toBe(false);
-  expect(postRes3.post_view.creator.local).toBe(true);
-  expect(postRes3.post_view.counts.score).toBe(1);
-
-  // Make sure that post makes it to beta community
-  let postRes4 = await waitForPost(beta, postRes3.post_view.post);
-  expect(postRes4.post).toBeDefined();
-  expect(postRes4.creator_banned_from_community).toBe(false);
-
-  await unfollowRemotes(alpha);
-});
-
-test("A and G subscribe to B (center) A posts, it gets announced to G", async () => {
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-  await followBeta(alpha);
-
+  // Alpha makes post on beta
   let postRes = await createPost(alpha, betaCommunity.community.id);
   expect(postRes.post_view.post).toBeDefined();
+  expect(postRes.post_view.community.local).toBe(false);
+  expect(postRes.post_view.creator.local).toBe(true);
+  expect(postRes.post_view.counts.score).toBe(1);
 
-  let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
-  expect(betaPost?.post.name).toBeDefined();
-  await unfollowRemotes(alpha);
+  // Make sure that post doesn't make it to beta
+  let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
+  expect(betaPost).toBeUndefined();
+
+  // Unban alpha
+  let unBanAlpha = await banUserFromSite(beta, alphaUser.user.id, false);
+  expect(unBanAlpha.banned).toBe(false);
 });
 
-test("Report a post", async () => {
-  // Create post from alpha
-  let alphaCommunity = (await resolveBetaCommunity(alpha)).community!;
-  await followBeta(alpha);
-  let postRes = await createPost(alpha, alphaCommunity.community.id);
+test('Enforce community ban for federated user', async () => {
+  let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
+  let userSearch = await searchForUser(beta, alphaShortname);
+  let alphaUser = userSearch.users[0];
+  expect(alphaUser).toBeDefined();
+
+  // ban alpha from beta site
+  await banUserFromCommunity(beta, alphaUser.user.id, 2, false);
+  let banAlpha = await banUserFromCommunity(beta, alphaUser.user.id, 2, true);
+  expect(banAlpha.banned).toBe(true);
+
+  // Alpha makes post on beta
+  let postRes = await createPost(alpha, betaCommunity.community.id);
   expect(postRes.post_view.post).toBeDefined();
+  expect(postRes.post_view.community.local).toBe(false);
+  expect(postRes.post_view.creator.local).toBe(true);
+  expect(postRes.post_view.counts.score).toBe(1);
 
-  let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
-  if (!alphaPost) {
-    throw "Missing alpha post";
-  }
+  // Make sure that post doesn't make it to beta community
+  let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
+  let betaPost = searchBeta.posts[0];
+  expect(betaPost).toBeUndefined();
 
-  // Send report from gamma
-  let gammaPost = (await resolvePost(gamma, alphaPost.post)).post!;
-  let gammaReport = (
-    await reportPost(gamma, gammaPost.post.id, randomString(10))
-  ).post_report_view.post_report;
-  expect(gammaReport).toBeDefined();
-
-  // Report was federated to community instance
-  let betaReport = (await waitUntil(
-    () =>
-      listPostReports(beta).then(p =>
-        p.post_reports.find(
-          r =>
-            r.post_report.original_post_name === gammaReport.original_post_name,
-        ),
-      ),
-    res => !!res,
-  ))!.post_report;
-  expect(betaReport).toBeDefined();
-  expect(betaReport.resolved).toBe(false);
-  expect(betaReport.original_post_name).toBe(gammaReport.original_post_name);
-  //expect(betaReport.original_post_url).toBe(gammaReport.original_post_url);
-  expect(betaReport.original_post_body).toBe(gammaReport.original_post_body);
-  expect(betaReport.reason).toBe(gammaReport.reason);
-  await unfollowRemotes(alpha);
-
-  // Report was federated to poster's instance
-  let alphaReport = (await waitUntil(
-    () =>
-      listPostReports(alpha).then(p =>
-        p.post_reports.find(
-          r =>
-            r.post_report.original_post_name === gammaReport.original_post_name,
-        ),
-      ),
-    res => !!res,
-  ))!.post_report;
-  expect(alphaReport).toBeDefined();
-  expect(alphaReport.resolved).toBe(false);
-  expect(alphaReport.original_post_name).toBe(gammaReport.original_post_name);
-  //expect(alphaReport.original_post_url).toBe(gammaReport.original_post_url);
-  expect(alphaReport.original_post_body).toBe(gammaReport.original_post_body);
-  expect(alphaReport.reason).toBe(gammaReport.reason);
-});
-
-test("Fetch post via redirect", async () => {
-  await followBeta(alpha);
-  let alphaPost = await createPost(alpha, betaCommunity!.community.id);
-  expect(alphaPost.post_view.post).toBeDefined();
-  // Make sure that post is liked on beta
-  const betaPost = await waitForPost(
+  // Unban alpha
+  let unBanAlpha = await banUserFromCommunity(
     beta,
-    alphaPost.post_view.post,
-    res => res?.counts.score === 1,
+    alphaUser.user.id,
+    2,
+    false
   );
-
-  expect(betaPost).toBeDefined();
-  expect(betaPost.post?.ap_id).toBe(alphaPost.post_view.post.ap_id);
-
-  // Fetch post from url on beta instance instead of ap_id
-  let q = `http://lemmy-beta:8551/post/${betaPost.post.id}`;
-  let form: ResolveObject = {
-    q,
-  };
-  let gammaPost = await gamma.resolveObject(form);
-  expect(gammaPost).toBeDefined();
-  expect(gammaPost.post?.post.ap_id).toBe(alphaPost.post_view.post.ap_id);
-  await unfollowRemotes(alpha);
-});
-
-test("Block post that contains banned URL", async () => {
-  let editSiteForm: EditSite = {
-    blocked_urls: ["https://evil.com/"],
-  };
-
-  await epsilon.editSite(editSiteForm);
-
-  await delay();
-
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-
-  expect(
-    createPost(epsilon, betaCommunity.community.id, "https://evil.com"),
-  ).rejects.toStrictEqual(Error("blocked_url"));
-
-  // Later tests need this to be empty
-  editSiteForm.blocked_urls = [];
-  await epsilon.editSite(editSiteForm);
-});
-
-test("Fetch post with redirect", async () => {
-  let alphaPost = await createPost(alpha, betaCommunity!.community.id);
-  expect(alphaPost.post_view.post).toBeDefined();
-
-  // beta fetches from alpha as usual
-  let betaPost = await resolvePost(beta, alphaPost.post_view.post);
-  expect(betaPost.post).toBeDefined();
-
-  // gamma fetches from beta, and gets redirected to alpha
-  let gammaPost = await resolvePost(gamma, betaPost.post!.post);
-  expect(gammaPost.post).toBeDefined();
-
-  // fetch remote object from local url, which redirects to the original url
-  let form: ResolveObject = {
-    q: `http://lemmy-gamma:8561/post/${gammaPost.post!.post.id}`,
-  };
-  let gammaPost2 = await gamma.resolveObject(form);
-  expect(gammaPost2.post).toBeDefined();
+  expect(unBanAlpha.banned).toBe(false);
 });

api_tests/src/private_message.spec.ts

@@ -8,142 +8,83 @@ import {
   editPrivateMessage,
   listPrivateMessages,
   deletePrivateMessage,
-  waitUntil,
-  reportPrivateMessage,
-  unfollows,
-} from "./shared";
+  unfollowRemotes,
+} from './shared';
 
 let recipient_id: number;
 
 beforeAll(async () => {
   await setupLogins();
-  await followBeta(alpha);
-  recipient_id = 3;
+  let follow = await followBeta(alpha);
+  recipient_id = follow.community_view.creator.id;
 });
 
-afterAll(unfollows);
+afterAll(async () => {
+  await unfollowRemotes(alpha);
+});
 
-test("Create a private message", async () => {
+test('Create a private message', async () => {
   let pmRes = await createPrivateMessage(alpha, recipient_id);
   expect(pmRes.private_message_view.private_message.content).toBeDefined();
   expect(pmRes.private_message_view.private_message.local).toBe(true);
   expect(pmRes.private_message_view.creator.local).toBe(true);
   expect(pmRes.private_message_view.recipient.local).toBe(false);
 
-  let betaPms = await waitUntil(
-    () => listPrivateMessages(beta),
-    e => !!e.private_messages[0],
-  );
+  let betaPms = await listPrivateMessages(beta);
   expect(betaPms.private_messages[0].private_message.content).toBeDefined();
   expect(betaPms.private_messages[0].private_message.local).toBe(false);
   expect(betaPms.private_messages[0].creator.local).toBe(false);
   expect(betaPms.private_messages[0].recipient.local).toBe(true);
 });
 
-test("Update a private message", async () => {
-  let updatedContent = "A jest test federated private message edited";
+test('Update a private message', async () => {
+  let updatedContent = 'A jest test federated private message edited';
 
   let pmRes = await createPrivateMessage(alpha, recipient_id);
   let pmUpdated = await editPrivateMessage(
     alpha,
-    pmRes.private_message_view.private_message.id,
+    pmRes.private_message_view.private_message.id
   );
   expect(pmUpdated.private_message_view.private_message.content).toBe(
-    updatedContent,
+    updatedContent
   );
 
-  let betaPms = await waitUntil(
-    () => listPrivateMessages(beta),
-    p => p.private_messages[0].private_message.content === updatedContent,
-  );
+  let betaPms = await listPrivateMessages(beta);
   expect(betaPms.private_messages[0].private_message.content).toBe(
-    updatedContent,
+    updatedContent
   );
 });
 
-test("Delete a private message", async () => {
+test('Delete a private message', async () => {
   let pmRes = await createPrivateMessage(alpha, recipient_id);
-  let betaPms1 = await waitUntil(
-    () => listPrivateMessages(beta),
-    m =>
-      !!m.private_messages.find(
-        e =>
-          e.private_message.ap_id ===
-          pmRes.private_message_view.private_message.ap_id,
-      ),
-  );
+  let betaPms1 = await listPrivateMessages(beta);
   let deletedPmRes = await deletePrivateMessage(
     alpha,
     true,
-    pmRes.private_message_view.private_message.id,
+    pmRes.private_message_view.private_message.id
   );
   expect(deletedPmRes.private_message_view.private_message.deleted).toBe(true);
 
   // The GetPrivateMessages filters out deleted,
   // even though they are in the actual database.
   // no reason to show them
-  let betaPms2 = await waitUntil(
-    () => listPrivateMessages(beta),
-    p => p.private_messages.length === betaPms1.private_messages.length - 1,
-  );
+  let betaPms2 = await listPrivateMessages(beta);
   expect(betaPms2.private_messages.length).toBe(
-    betaPms1.private_messages.length - 1,
+    betaPms1.private_messages.length - 1
   );
 
   // Undelete
   let undeletedPmRes = await deletePrivateMessage(
     alpha,
     false,
-    pmRes.private_message_view.private_message.id,
+    pmRes.private_message_view.private_message.id
   );
   expect(undeletedPmRes.private_message_view.private_message.deleted).toBe(
-    false,
+    false
   );
 
-  let betaPms3 = await waitUntil(
-    () => listPrivateMessages(beta),
-    p => p.private_messages.length === betaPms1.private_messages.length,
-  );
+  let betaPms3 = await listPrivateMessages(beta);
   expect(betaPms3.private_messages.length).toBe(
-    betaPms1.private_messages.length,
-  );
-});
-
-test("Create a private message report", async () => {
-  let pmRes = await createPrivateMessage(alpha, recipient_id);
-  let betaPms1 = await waitUntil(
-    () => listPrivateMessages(beta),
-    m =>
-      !!m.private_messages.find(
-        e =>
-          e.private_message.ap_id ===
-          pmRes.private_message_view.private_message.ap_id,
-      ),
-  );
-  let betaPm = betaPms1.private_messages[0];
-  expect(betaPm).toBeDefined();
-
-  // Make sure that only the recipient can report it, so this should fail
-  await expect(
-    reportPrivateMessage(
-      alpha,
-      pmRes.private_message_view.private_message.id,
-      "a reason",
-    ),
-  ).rejects.toStrictEqual(Error("couldnt_create_report"));
-
-  // This one should pass
-  let reason = "another reason";
-  let report = await reportPrivateMessage(
-    beta,
-    betaPm.private_message.id,
-    reason,
-  );
-
-  expect(report.private_message_report_view.private_message.id).toBe(
-    betaPm.private_message.id,
-  );
-  expect(report.private_message_report_view.private_message_report.reason).toBe(
-    reason,
+    betaPms1.private_messages.length
   );
 });

api_tests/src/user.spec.ts

@@ -1,195 +1,65 @@
 jest.setTimeout(120000);
-
-import { PersonView } from "lemmy-js-client/dist/types/PersonView";
 import {
   alpha,
   beta,
   registerUser,
-  resolvePerson,
-  getSite,
-  createPost,
-  resolveCommunity,
-  createComment,
-  resolveBetaCommunity,
-  deleteUser,
-  saveUserSettingsFederated,
-  setupLogins,
-  alphaUrl,
+  searchForUser,
   saveUserSettings,
-  getPost,
-  getComments,
-  fetchFunction,
-  alphaImage,
-  unfollows,
-} from "./shared";
-import { LemmyHttp, SaveUserSettings, UploadImage } from "lemmy-js-client";
-import { GetPosts } from "lemmy-js-client/dist/types/GetPosts";
-
-beforeAll(setupLogins);
-afterAll(unfollows);
+  getSite,
+} from './shared';
+import {
+  UserViewSafe,
+  SaveUserSettings,
+  SortType,
+  ListingType,
+} from 'lemmy-js-client';
 
+let auth: string;
 let apShortname: string;
 
-function assertUserFederation(userOne?: PersonView, userTwo?: PersonView) {
-  expect(userOne?.person.name).toBe(userTwo?.person.name);
-  expect(userOne?.person.display_name).toBe(userTwo?.person.display_name);
-  expect(userOne?.person.bio).toBe(userTwo?.person.bio);
-  expect(userOne?.person.actor_id).toBe(userTwo?.person.actor_id);
-  expect(userOne?.person.avatar).toBe(userTwo?.person.avatar);
-  expect(userOne?.person.banner).toBe(userTwo?.person.banner);
-  expect(userOne?.person.published).toBe(userTwo?.person.published);
+function assertUserFederation(userOne: UserViewSafe, userTwo: UserViewSafe) {
+  expect(userOne.user.name).toBe(userTwo.user.name);
+  expect(userOne.user.preferred_username).toBe(userTwo.user.preferred_username);
+  expect(userOne.user.bio).toBe(userTwo.user.bio);
+  expect(userOne.user.actor_id).toBe(userTwo.user.actor_id);
+  expect(userOne.user.avatar).toBe(userTwo.user.avatar);
+  expect(userOne.user.banner).toBe(userTwo.user.banner);
+  expect(userOne.user.published).toBe(userTwo.user.published);
 }
 
-test("Create user", async () => {
-  let user = await registerUser(alpha, alphaUrl);
+test('Create user', async () => {
+  let userRes = await registerUser(alpha);
+  expect(userRes.jwt).toBeDefined();
+  auth = userRes.jwt;
 
-  let site = await getSite(user);
+  let site = await getSite(alpha, auth);
   expect(site.my_user).toBeDefined();
-  if (!site.my_user) {
-    throw "Missing site user";
-  }
-  apShortname = `${site.my_user.local_user_view.person.name}@lemmy-alpha:8541`;
+  apShortname = `@${site.my_user.name}@lemmy-alpha:8541`;
 });
 
-test("Set some user settings, check that they are federated", async () => {
-  await saveUserSettingsFederated(alpha);
-  let alphaPerson = (await resolvePerson(alpha, apShortname)).person;
-  let betaPerson = (await resolvePerson(beta, apShortname)).person;
-  assertUserFederation(alphaPerson, betaPerson);
-
-  // Catches a bug where when only the person or local_user changed
+test('Set some user settings, check that they are federated', async () => {
+  let avatar = 'https://image.flaticon.com/icons/png/512/35/35896.png';
+  let banner = 'https://image.flaticon.com/icons/png/512/36/35896.png';
+  let bio = 'a changed bio';
   let form: SaveUserSettings = {
-    theme: "test",
+    show_nsfw: false,
+    theme: '',
+    default_sort_type: Object.keys(SortType).indexOf(SortType.Hot),
+    default_listing_type: Object.keys(ListingType).indexOf(ListingType.All),
+    lang: '',
+    avatar,
+    banner,
+    preferred_username: 'user321',
+    show_avatars: false,
+    send_notifications_to_email: false,
+    bio,
+    auth,
   };
-  await saveUserSettings(beta, form);
+  await saveUserSettings(alpha, form);
 
-  let site = await getSite(beta);
-  expect(site.my_user?.local_user_view.local_user.theme).toBe("test");
-});
-
-test("Delete user", async () => {
-  let user = await registerUser(alpha, alphaUrl);
-
-  // make a local post and comment
-  let alphaCommunity = (await resolveCommunity(user, "main@lemmy-alpha:8541"))
-    .community;
-  if (!alphaCommunity) {
-    throw "Missing alpha community";
-  }
-  let localPost = (await createPost(user, alphaCommunity.community.id))
-    .post_view.post;
-  expect(localPost).toBeDefined();
-  let localComment = (await createComment(user, localPost.id)).comment_view
-    .comment;
-  expect(localComment).toBeDefined();
-
-  // make a remote post and comment
-  let betaCommunity = (await resolveBetaCommunity(user)).community;
-  if (!betaCommunity) {
-    throw "Missing beta community";
-  }
-  let remotePost = (await createPost(user, betaCommunity.community.id))
-    .post_view.post;
-  expect(remotePost).toBeDefined();
-  let remoteComment = (await createComment(user, remotePost.id)).comment_view
-    .comment;
-  expect(remoteComment).toBeDefined();
-
-  await deleteUser(user);
-
-  // check that posts and comments are marked as deleted on other instances.
-  // use get methods to avoid refetching from origin instance
-  expect((await getPost(alpha, localPost.id)).post_view.post.deleted).toBe(
-    true,
-  );
-  expect((await getPost(alpha, remotePost.id)).post_view.post.deleted).toBe(
-    true,
-  );
-  expect(
-    (await getComments(alpha, localComment.post_id)).comments[0].comment
-      .deleted,
-  ).toBe(true);
-  expect(
-    (await getComments(alpha, remoteComment.post_id)).comments[0].comment
-      .deleted,
-  ).toBe(true);
-});
-
-test("Requests with invalid auth should be treated as unauthenticated", async () => {
-  let invalid_auth = new LemmyHttp(alphaUrl, {
-    headers: { Authorization: "Bearer foobar" },
-    fetchFunction,
-  });
-  let site = await getSite(invalid_auth);
-  expect(site.my_user).toBeUndefined();
-  expect(site.site_view).toBeDefined();
-
-  let form: GetPosts = {};
-  let posts = invalid_auth.getPosts(form);
-  expect((await posts).posts).toBeDefined();
-});
-
-test("Create user with Arabic name", async () => {
-  let user = await registerUser(alpha, alphaUrl, "تجريب");
-
-  let site = await getSite(user);
-  expect(site.my_user).toBeDefined();
-  if (!site.my_user) {
-    throw "Missing site user";
-  }
-  apShortname = `${site.my_user.local_user_view.person.name}@lemmy-alpha:8541`;
-
-  let alphaPerson = (await resolvePerson(alpha, apShortname)).person;
-  expect(alphaPerson).toBeDefined();
-});
-
-test("Create user with accept-language", async () => {
-  let lemmy_http = new LemmyHttp(alphaUrl, {
-    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language#syntax
-    headers: { "Accept-Language": "fr-CH, en;q=0.8, de;q=0.7, *;q=0.5" },
-  });
-  let user = await registerUser(lemmy_http, alphaUrl);
-
-  let site = await getSite(user);
-  expect(site.my_user).toBeDefined();
-  expect(site.my_user?.local_user_view.local_user.interface_language).toBe(
-    "fr",
-  );
-  let langs = site.all_languages
-    .filter(a => site.my_user?.discussion_languages.includes(a.id))
-    .map(l => l.code);
-  // should have languages from accept header, as well as "undetermined"
-  // which is automatically enabled by backend
-  expect(langs).toStrictEqual(["und", "de", "en", "fr"]);
-});
-
-test("Set a new avatar, old avatar is deleted", async () => {
-  const listMediaRes = await alphaImage.listMedia();
-  expect(listMediaRes.images.length).toBe(0);
-  const upload_form1: UploadImage = {
-    image: Buffer.from("test1"),
-  };
-  const upload1 = await alphaImage.uploadImage(upload_form1);
-  expect(upload1.url).toBeDefined();
-
-  let form1 = {
-    avatar: upload1.url,
-  };
-  await saveUserSettings(alpha, form1);
-  const listMediaRes1 = await alphaImage.listMedia();
-  expect(listMediaRes1.images.length).toBe(1);
-
-  const upload_form2: UploadImage = {
-    image: Buffer.from("test2"),
-  };
-  const upload2 = await alphaImage.uploadImage(upload_form2);
-  expect(upload2.url).toBeDefined();
-
-  let form2 = {
-    avatar: upload1.url,
-  };
-  await saveUserSettings(alpha, form2);
-  // make sure only the new avatar is kept
-  const listMediaRes2 = await alphaImage.listMedia();
-  expect(listMediaRes2.images.length).toBe(1);
+  let searchAlpha = await searchForUser(alpha, apShortname);
+  let userOnAlpha = searchAlpha.users[0];
+  let searchBeta = await searchForUser(beta, apShortname);
+  let userOnBeta = searchBeta.users[0];
+  assertUserFederation(userOnAlpha, userOnBeta);
 });

api_tests/tsconfig.json

@@ -6,10 +6,11 @@
     "noImplicitAny": true,
     "lib": ["es2017", "es7", "es6", "dom"],
     "outDir": "./dist",
-    "target": "ES2020",
-    "strictNullChecks": true,
+    "target": "ES5",
     "moduleResolution": "Node"
   },
-  "include": ["src/**/*"],
+  "include": [
+    "src/**/*"
+  ],
   "exclude": ["node_modules", "dist"]
 }

cliff.toml

@@ -1,86 +0,0 @@
-# git-cliff ~ configuration file
-# https://git-cliff.org/docs/configuration
-
-[remote.github]
-owner = "LemmyNet"
-repo = "lemmy"
-# token = ""
-
-[changelog]
-# template for the changelog body
-# https://keats.github.io/tera/docs/#introduction
-body = """
-## What's Changed
-
-{%- if version %} in {{ version }}{%- endif -%}
-{% for commit in commits %}
-  {% if commit.github.pr_title -%}
-    {%- set commit_message = commit.github.pr_title -%}
-  {%- else -%}
-    {%- set commit_message = commit.message -%}
-  {%- endif -%}
-  * {{ commit_message | split(pat="\n") | first | trim }}\
-    {% if commit.github.username %} by @{{ commit.github.username }}{%- endif -%}
-    {% if commit.github.pr_number %} in \
-      [#{{ commit.github.pr_number }}]({{ self::remote_url() }}/pull/{{ commit.github.pr_number }}) \
-    {%- endif %}
-{%- endfor -%}
-
-{% if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
-  {% raw %}\n{% endraw -%}
-  ## New Contributors
-{%- endif %}\
-{% for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
-  * @{{ contributor.username }} made their first contribution
-    {%- if contributor.pr_number %} in \
-      [#{{ contributor.pr_number }}]({{ self::remote_url() }}/pull/{{ contributor.pr_number }}) \
-    {%- endif %}
-{%- endfor -%}
-
-{% if version %}
-    {% if previous.version %}
-      **Full Changelog**: {{ self::remote_url() }}/compare/{{ previous.version }}...{{ version }}
-    {% endif %}
-{% else -%}
-  {% raw %}\n{% endraw %}
-{% endif %}
-
-{%- macro remote_url() -%}
-  https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}
-{%- endmacro -%}
-"""
-# remove the leading and trailing whitespace from the template
-trim = true
-# changelog footer
-footer = """
-<!-- generated by git-cliff -->
-"""
-# postprocessors
-postprocessors = []
-
-[git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = false
-# filter out the commits that are not conventional
-filter_unconventional = true
-# process each line of a commit as an individual commit
-split_commits = false
-# regex for preprocessing the commit messages
-commit_preprocessors = [
-  # remove issue numbers from commits
-  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "" },
-]
-# protect breaking changes from being skipped due to matching a skipping commit_parser
-protect_breaking_commits = false
-# filter out the commits that are not matched by commit parsers
-filter_commits = false
-# regex for matching git tags
-tag_pattern = "[0-9].*"
-# regex for skipping tags
-skip_tags = "beta|alpha"
-# regex for ignoring tags
-ignore_tags = "rc"
-# sort the tags topologically
-topo_order = false
-# sort the commits inside sections by oldest/newest order
-sort_commits = "newest"

config/config.hjson

@@ -1,5 +1,3 @@
-# See the documentation for available config fields and descriptions:
-# https://join-lemmy.org/docs/en/administration/configuration.html
 {
-  hostname: lemmy-alpha
+  hostname: "localhost:8536"
 }

config/defaults.hjson

@@ -1,122 +1,90 @@
 {
+#  # optional: parameters for automatic configuration of new instance (only used at first start)
+#  setup: {
+#    # username for the admin user
+#    admin_username: ""
+#    # password for the admin user
+#    admin_password: ""
+#    # optional: email for the admin user (can be omitted and set later through the website)
+#    admin_email: ""
+#    # name of the site (can be changed later)
+#    site_name: ""
+#  }
   # settings related to the postgresql database
   database: {
-    # Configure the database by specifying a URI
-    # 
-    # This is the preferred method to specify database connection details since
-    # it is the most flexible.
-    # Connection URI pointing to a postgres instance
-    # 
-    # This example uses peer authentication to obviate the need for creating,
-    # configuring, and managing passwords.
-    # 
-    # For an explanation of how to use connection URIs, see [here][0] in
-    # PostgreSQL's documentation.
-    # 
-    # [0]: https://www.postgresql.org/docs/current/libpq-connect.html#id-1.7.3.8.3.6
-    uri: "postgresql:///lemmy?user=lemmy&host=/var/run/postgresql"
-
-    # or
-
-    # Configure the database by specifying parts of a URI
-    # 
-    # Note that specifying the `uri` field should be preferred since it provides
-    # greater control over how the connection is made. This merely exists for
-    # backwards-compatibility.
-    # Username to connect to postgres
-    user: "string"
-    # Password to connect to postgres
-    password: "string"
-    # Host where postgres is running
-    host: "string"
-    # Port where postgres can be accessed
-    port: 123
-    # Name of the postgres database for lemmy
-    database: "string"
-    # Maximum number of active sql connections
-    pool_size: 30
+    # username to connect to postgres
+    user: "lemmy"
+    # password to connect to postgres
+    password: "password"
+    # host where postgres is running
+    host: "localhost"
+    # port where postgres can be accessed
+    port: 5432
+    # name of the postgres database for lemmy
+    database: "lemmy"
+    # maximum number of active sql connections
+    pool_size: 5
   }
-  # Pictrs image server configuration.
-  pictrs: {
-    # Address where pictrs is available (for image hosting)
-    url: "http://localhost:8080/"
-    # Set a custom pictrs API key. ( Required for deleting images )
-    api_key: "string"
-    # Backwards compatibility with 0.18.1. False is equivalent to `image_mode: None`, true is
-    # equivalent to `image_mode: StoreLinkPreviews`.
-    # 
-    # To be removed in 0.20
-    cache_external_link_previews: true
-    # Specifies how to handle remote images, so that users don't have to connect directly to remote
-    # servers.
-    image_mode: 
-      # Leave images unchanged, don't generate any local thumbnails for post urls. Instead the
-      # Opengraph image is directly returned as thumbnail
-      "None"
-
-      # or
-
-      # Generate thumbnails for external post urls and store them persistently in pict-rs. This
-      # ensures that they can be reliably retrieved and can be resized using pict-rs APIs. However
-      # it also increases storage usage.
-      # 
-      # This is the default behaviour, and also matches Lemmy 0.18.
-      "StoreLinkPreviews"
-
-      # or
-
-      # If enabled, all images from remote domains are rewritten to pass through
-      # `/api/v3/image_proxy`, including embedded images in markdown. Images are stored temporarily
-      # in pict-rs for caching. This improves privacy as users don't expose their IP to untrusted
-      # servers, and decreases load on other servers. However it increases bandwidth use for the
-      # local server.
-      # 
-      # Requires pict-rs 0.5
-      "ProxyAllImages"
-    # Timeout for uploading images to pictrs (in seconds)
-    upload_timeout: 30
-  }
-  # Email sending configuration. All options except login/password are mandatory
-  email: {
-    # Hostname and port of the smtp server
-    smtp_server: "localhost:25"
-    # Login name for smtp server
-    smtp_login: "string"
-    # Password to login to the smtp server
-    smtp_password: "string"
-    # Address to send emails from, eg "noreply@your-instance.com"
-    smtp_from_address: "noreply@example.com"
-    # Whether or not smtp connections should use tls. Can be none, tls, or starttls
-    tls_type: "none"
-  }
-  # Parameters for automatic configuration of new instance (only used at first start)
-  setup: {
-    # Username for the admin user
-    admin_username: "admin"
-    # Password for the admin user. It must be between 10 and 60 characters.
-    admin_password: "tf6HHDS4RolWfFhk4Rq9"
-    # Name of the site, can be changed later. Maximum 20 characters.
-    site_name: "My Lemmy Instance"
-    # Email for the admin user (optional, can be omitted and set later through the website)
-    admin_email: "user@example.com"
-  }
-  # the domain name of your instance (mandatory)
-  hostname: "unset"
-  # Address where lemmy should listen for incoming requests
+  # the domain name of your instance (eg "lemmy.ml")
+  hostname: null
+  # address where lemmy should listen for incoming requests
   bind: "0.0.0.0"
-  # Port where lemmy should listen for incoming requests
+  # port where lemmy should listen for incoming requests
   port: 8536
-  # Whether the site is available over TLS. Needs to be true for federation to work.
+  # whether tls is required for activitypub. only disable this for debugging, never for producion.
   tls_enabled: true
-  # The number of activitypub federation workers that can be in-flight concurrently
-  worker_count: 0
-  # The number of activitypub federation retry workers that can be in-flight concurrently
-  retry_count: 0
-  prometheus: {
-    bind: "127.0.0.1"
-    port: 10002
+  # json web token for authorization between server and client
+  jwt_secret: "changeme"
+  # address where pictrs is available
+  pictrs_url: "http://pictrs:8080"
+  # address where iframely is available
+  iframely_url: "http://iframely"
+  # rate limits for various user actions, by user ip
+  rate_limit: {
+    # maximum number of messages created in interval
+    message: 180
+    # interval length for message limit
+    message_per_second: 60
+    # maximum number of posts created in interval
+    post: 6
+    # interval length for post limit
+    post_per_second: 600
+    # maximum number of registrations in interval
+    register: 3
+    # interval length for registration limit
+    register_per_second: 3600
+    # maximum number of image uploads in interval
+    image: 6
+    # interval length for image uploads
+    image_per_second: 3600
   }
-  # Sets a response Access-Control-Allow-Origin CORS header
-  # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin
-  cors_origin: "*"
+  # settings related to activitypub federation
+  federation: {
+    # whether to enable activitypub federation. 
+    enabled: false
+    # Allows and blocks are described here:
+    # https://join.lemmy.ml/docs/en/federation/administration.html#instance-allowlist-and-blocklist
+    #
+    # comma separated list of instances with which federation is allowed
+    allowed_instances: ""
+    # comma separated list of instances which are blocked from federating
+    blocked_instances: ""
+  }
+  captcha: {
+    enabled: true
+    difficulty: medium # Can be easy, medium, or hard
+  }
+#  # email sending configuration
+#  email: {
+#    # hostname and port of the smtp server
+#    smtp_server: ""
+#    # login name for smtp server
+#    smtp_login: ""
+#    # password to login to the smtp server
+#    smtp_password: ""
+#    # address to send emails from, eg "noreply@your-instance.com"
+#    smtp_from_address: ""
+#    # whether or not smtp connections should use tls
+#    use_tls: true
+#  }
 }

crates/api/Cargo.toml

@@ -1,45 +1,50 @@
 [package]
 name = "lemmy_api"
-publish = false
-version.workspace = true
-edition.workspace = true
-description.workspace = true
-license.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-repository.workspace = true
+version = "0.1.0"
+authors = ["Felix Ableitner <me@nutomic.com>"]
+edition = "2018"
 
 [lib]
 name = "lemmy_api"
 path = "src/lib.rs"
-doctest = false
-
-[lints]
-workspace = true
 
 [dependencies]
-lemmy_utils = { workspace = true }
-lemmy_db_schema = { workspace = true, features = ["full"] }
-lemmy_db_views = { workspace = true, features = ["full"] }
-lemmy_db_views_moderator = { workspace = true, features = ["full"] }
-lemmy_db_views_actor = { workspace = true, features = ["full"] }
-lemmy_api_common = { workspace = true, features = ["full"] }
-activitypub_federation = { workspace = true }
-bcrypt = { workspace = true }
-actix-web = { workspace = true }
-base64 = { workspace = true }
-captcha = { workspace = true }
-anyhow = { workspace = true }
-tracing = { workspace = true }
-chrono = { workspace = true }
-url = { workspace = true }
-wav = "1.0.1"
-sitemap-rs = "0.2.1"
-totp-rs = { version = "5.5.1", features = ["gen_secret", "otpauth"] }
-actix-web-httpauth = "0.8.1"
-
-[dev-dependencies]
-serial_test = { workspace = true }
-tokio = { workspace = true }
-elementtree = "1.2.3"
-pretty_assertions = { workspace = true }
+lemmy_apub = { path = "../apub" }
+lemmy_utils = { path = "../utils" }
+lemmy_db_queries = { path = "../db_queries" }
+lemmy_db_schema = { path = "../db_schema" }
+lemmy_db_views = { path = "../db_views" }
+lemmy_db_views_moderator = { path = "../db_views_moderator" }
+lemmy_db_views_actor = { path = "../db_views_actor" }
+lemmy_structs = { path = "../structs" }
+lemmy_websocket = { path = "../websocket" }
+diesel = "1.4.5"
+bcrypt = "0.9.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+serde_json = { version = "1.0.61", features = ["preserve_order"] }
+serde = { version = "1.0.123", features = ["derive"] }
+actix = "0.10.0"
+actix-web = { version = "3.3.2", default-features = false }
+actix-rt = { version = "1.1.1", default-features = false }
+awc = { version = "2.0.3", default-features = false }
+log = "0.4.14"
+rand = "0.8.3"
+strum = "0.20.0"
+strum_macros = "0.20.1"
+lazy_static = "1.4.0"
+url = { version = "2.2.0", features = ["serde"] }
+openssl = "0.10.32"
+http = "0.2.3"
+http-signature-normalization-actix = { version = "0.4.1", default-features = false, features = ["sha-2"] }
+base64 = "0.13.0"
+tokio = "0.3.6"
+futures = "0.3.12"
+itertools = "0.10.0"
+uuid = { version = "0.8.2", features = ["serde", "v4"] }
+sha2 = "0.9.3"
+async-trait = "0.1.42"
+captcha = "0.0.8"
+anyhow = "1.0.38"
+thiserror = "1.0.23"
+background-jobs = "0.8.0"
+reqwest = { version = "0.10.10", features = ["json"] }

crates/api/src/comment.rs

@@ -0,0 +1,817 @@
+use crate::{
+  check_community_ban,
+  check_downvotes_enabled,
+  collect_moderated_communities,
+  get_post,
+  get_user_from_jwt,
+  get_user_from_jwt_opt,
+  is_mod_or_admin,
+  Perform,
+};
+use actix_web::web::Data;
+use lemmy_apub::{generate_apub_endpoint, ApubLikeableType, ApubObjectType, EndpointType};
+use lemmy_db_queries::{
+  source::comment::Comment_,
+  Crud,
+  Likeable,
+  ListingType,
+  Reportable,
+  Saveable,
+  SortType,
+};
+use lemmy_db_schema::source::{comment::*, comment_report::*, moderator::*};
+use lemmy_db_views::{
+  comment_report_view::{CommentReportQueryBuilder, CommentReportView},
+  comment_view::{CommentQueryBuilder, CommentView},
+};
+use lemmy_structs::{blocking, comment::*, send_local_notifs};
+use lemmy_utils::{
+  utils::{remove_slurs, scrape_text_for_mentions},
+  APIError,
+  ConnectionId,
+  LemmyError,
+};
+use lemmy_websocket::{
+  messages::{SendComment, SendModRoomMessage, SendUserRoomMessage},
+  LemmyContext,
+  UserOperation,
+};
+use std::str::FromStr;
+
+#[async_trait::async_trait(?Send)]
+impl Perform for CreateComment {
+  type Response = CommentResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommentResponse, LemmyError> {
+    let data: &CreateComment = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let content_slurs_removed = remove_slurs(&data.content.to_owned());
+
+    // Check for a community ban
+    let post_id = data.post_id;
+    let post = get_post(post_id, context.pool()).await?;
+
+    check_community_ban(user.id, post.community_id, context.pool()).await?;
+
+    // Check if post is locked, no new comments
+    if post.locked {
+      return Err(APIError::err("locked").into());
+    }
+
+    // If there's a parent_id, check to make sure that comment is in that post
+    if let Some(parent_id) = data.parent_id {
+      // Make sure the parent comment exists
+      let parent =
+        match blocking(context.pool(), move |conn| Comment::read(&conn, parent_id)).await? {
+          Ok(comment) => comment,
+          Err(_e) => return Err(APIError::err("couldnt_create_comment").into()),
+        };
+      if parent.post_id != post_id {
+        return Err(APIError::err("couldnt_create_comment").into());
+      }
+    }
+
+    let comment_form = CommentForm {
+      content: content_slurs_removed,
+      parent_id: data.parent_id.to_owned(),
+      post_id: data.post_id,
+      creator_id: user.id,
+      removed: None,
+      deleted: None,
+      read: None,
+      published: None,
+      updated: None,
+      ap_id: None,
+      local: true,
+    };
+
+    // Create the comment
+    let comment_form2 = comment_form.clone();
+    let inserted_comment = match blocking(context.pool(), move |conn| {
+      Comment::create(&conn, &comment_form2)
+    })
+    .await?
+    {
+      Ok(comment) => comment,
+      Err(_e) => return Err(APIError::err("couldnt_create_comment").into()),
+    };
+
+    // Necessary to update the ap_id
+    let inserted_comment_id = inserted_comment.id;
+    let updated_comment: Comment =
+      match blocking(context.pool(), move |conn| -> Result<Comment, LemmyError> {
+        let apub_id =
+          generate_apub_endpoint(EndpointType::Comment, &inserted_comment_id.to_string())?;
+        Ok(Comment::update_ap_id(&conn, inserted_comment_id, apub_id)?)
+      })
+      .await?
+      {
+        Ok(comment) => comment,
+        Err(_e) => return Err(APIError::err("couldnt_create_comment").into()),
+      };
+
+    updated_comment.send_create(&user, context).await?;
+
+    // Scan the comment for user mentions, add those rows
+    let post_id = post.id;
+    let mentions = scrape_text_for_mentions(&comment_form.content);
+    let recipient_ids = send_local_notifs(
+      mentions,
+      updated_comment.clone(),
+      &user,
+      post,
+      context.pool(),
+      true,
+    )
+    .await?;
+
+    // You like your own comment by default
+    let like_form = CommentLikeForm {
+      comment_id: inserted_comment.id,
+      post_id,
+      user_id: user.id,
+      score: 1,
+    };
+
+    let like = move |conn: &'_ _| CommentLike::like(&conn, &like_form);
+    if blocking(context.pool(), like).await?.is_err() {
+      return Err(APIError::err("couldnt_like_comment").into());
+    }
+
+    updated_comment.send_like(&user, context).await?;
+
+    let user_id = user.id;
+    let mut comment_view = blocking(context.pool(), move |conn| {
+      CommentView::read(&conn, inserted_comment.id, Some(user_id))
+    })
+    .await??;
+
+    // If its a comment to yourself, mark it as read
+    let comment_id = comment_view.comment.id;
+    if user.id == comment_view.get_recipient_id() {
+      match blocking(context.pool(), move |conn| {
+        Comment::update_read(conn, comment_id, true)
+      })
+      .await?
+      {
+        Ok(comment) => comment,
+        Err(_e) => return Err(APIError::err("couldnt_update_comment").into()),
+      };
+      comment_view.comment.read = true;
+    }
+
+    let mut res = CommentResponse {
+      comment_view,
+      recipient_ids,
+      form_id: data.form_id.to_owned(),
+    };
+
+    context.chat_server().do_send(SendComment {
+      op: UserOperation::CreateComment,
+      comment: res.clone(),
+      websocket_id,
+    });
+
+    res.recipient_ids = Vec::new(); // Necessary to avoid doubles
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for EditComment {
+  type Response = CommentResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommentResponse, LemmyError> {
+    let data: &EditComment = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let comment_id = data.comment_id;
+    let orig_comment = blocking(context.pool(), move |conn| {
+      CommentView::read(&conn, comment_id, None)
+    })
+    .await??;
+
+    check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
+
+    // Verify that only the creator can edit
+    if user.id != orig_comment.creator.id {
+      return Err(APIError::err("no_comment_edit_allowed").into());
+    }
+
+    // Do the update
+    let content_slurs_removed = remove_slurs(&data.content.to_owned());
+    let comment_id = data.comment_id;
+    let updated_comment = match blocking(context.pool(), move |conn| {
+      Comment::update_content(conn, comment_id, &content_slurs_removed)
+    })
+    .await?
+    {
+      Ok(comment) => comment,
+      Err(_e) => return Err(APIError::err("couldnt_update_comment").into()),
+    };
+
+    // Send the apub update
+    updated_comment.send_update(&user, context).await?;
+
+    // Do the mentions / recipients
+    let updated_comment_content = updated_comment.content.to_owned();
+    let mentions = scrape_text_for_mentions(&updated_comment_content);
+    let recipient_ids = send_local_notifs(
+      mentions,
+      updated_comment,
+      &user,
+      orig_comment.post,
+      context.pool(),
+      false,
+    )
+    .await?;
+
+    let comment_id = data.comment_id;
+    let user_id = user.id;
+    let comment_view = blocking(context.pool(), move |conn| {
+      CommentView::read(conn, comment_id, Some(user_id))
+    })
+    .await??;
+
+    let res = CommentResponse {
+      comment_view,
+      recipient_ids,
+      form_id: data.form_id.to_owned(),
+    };
+
+    context.chat_server().do_send(SendComment {
+      op: UserOperation::EditComment,
+      comment: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for DeleteComment {
+  type Response = CommentResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommentResponse, LemmyError> {
+    let data: &DeleteComment = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let comment_id = data.comment_id;
+    let orig_comment = blocking(context.pool(), move |conn| {
+      CommentView::read(&conn, comment_id, None)
+    })
+    .await??;
+
+    check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
+
+    // Verify that only the creator can delete
+    if user.id != orig_comment.creator.id {
+      return Err(APIError::err("no_comment_edit_allowed").into());
+    }
+
+    // Do the delete
+    let deleted = data.deleted;
+    let updated_comment = match blocking(context.pool(), move |conn| {
+      Comment::update_deleted(conn, comment_id, deleted)
+    })
+    .await?
+    {
+      Ok(comment) => comment,
+      Err(_e) => return Err(APIError::err("couldnt_update_comment").into()),
+    };
+
+    // Send the apub message
+    if deleted {
+      updated_comment.send_delete(&user, context).await?;
+    } else {
+      updated_comment.send_undo_delete(&user, context).await?;
+    }
+
+    // Refetch it
+    let comment_id = data.comment_id;
+    let user_id = user.id;
+    let comment_view = blocking(context.pool(), move |conn| {
+      CommentView::read(conn, comment_id, Some(user_id))
+    })
+    .await??;
+
+    // Build the recipients
+    let comment_view_2 = comment_view.clone();
+    let mentions = vec![];
+    let recipient_ids = send_local_notifs(
+      mentions,
+      updated_comment,
+      &user,
+      comment_view_2.post,
+      context.pool(),
+      false,
+    )
+    .await?;
+
+    let res = CommentResponse {
+      comment_view,
+      recipient_ids,
+      form_id: None, // TODO a comment delete might clear forms?
+    };
+
+    context.chat_server().do_send(SendComment {
+      op: UserOperation::DeleteComment,
+      comment: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for RemoveComment {
+  type Response = CommentResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommentResponse, LemmyError> {
+    let data: &RemoveComment = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let comment_id = data.comment_id;
+    let orig_comment = blocking(context.pool(), move |conn| {
+      CommentView::read(&conn, comment_id, None)
+    })
+    .await??;
+
+    check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
+
+    // Verify that only a mod or admin can remove
+    is_mod_or_admin(context.pool(), user.id, orig_comment.community.id).await?;
+
+    // Do the remove
+    let removed = data.removed;
+    let updated_comment = match blocking(context.pool(), move |conn| {
+      Comment::update_removed(conn, comment_id, removed)
+    })
+    .await?
+    {
+      Ok(comment) => comment,
+      Err(_e) => return Err(APIError::err("couldnt_update_comment").into()),
+    };
+
+    // Mod tables
+    let form = ModRemoveCommentForm {
+      mod_user_id: user.id,
+      comment_id: data.comment_id,
+      removed: Some(removed),
+      reason: data.reason.to_owned(),
+    };
+    blocking(context.pool(), move |conn| {
+      ModRemoveComment::create(conn, &form)
+    })
+    .await??;
+
+    // Send the apub message
+    if removed {
+      updated_comment.send_remove(&user, context).await?;
+    } else {
+      updated_comment.send_undo_remove(&user, context).await?;
+    }
+
+    // Refetch it
+    let comment_id = data.comment_id;
+    let user_id = user.id;
+    let comment_view = blocking(context.pool(), move |conn| {
+      CommentView::read(conn, comment_id, Some(user_id))
+    })
+    .await??;
+
+    // Build the recipients
+    let comment_view_2 = comment_view.clone();
+
+    let mentions = vec![];
+    let recipient_ids = send_local_notifs(
+      mentions,
+      updated_comment,
+      &user,
+      comment_view_2.post,
+      context.pool(),
+      false,
+    )
+    .await?;
+
+    let res = CommentResponse {
+      comment_view,
+      recipient_ids,
+      form_id: None, // TODO maybe this might clear other forms
+    };
+
+    context.chat_server().do_send(SendComment {
+      op: UserOperation::RemoveComment,
+      comment: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for MarkCommentAsRead {
+  type Response = CommentResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<CommentResponse, LemmyError> {
+    let data: &MarkCommentAsRead = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let comment_id = data.comment_id;
+    let orig_comment = blocking(context.pool(), move |conn| {
+      CommentView::read(&conn, comment_id, None)
+    })
+    .await??;
+
+    check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
+
+    // Verify that only the recipient can mark as read
+    if user.id != orig_comment.get_recipient_id() {
+      return Err(APIError::err("no_comment_edit_allowed").into());
+    }
+
+    // Do the mark as read
+    let read = data.read;
+    match blocking(context.pool(), move |conn| {
+      Comment::update_read(conn, comment_id, read)
+    })
+    .await?
+    {
+      Ok(comment) => comment,
+      Err(_e) => return Err(APIError::err("couldnt_update_comment").into()),
+    };
+
+    // Refetch it
+    let comment_id = data.comment_id;
+    let user_id = user.id;
+    let comment_view = blocking(context.pool(), move |conn| {
+      CommentView::read(conn, comment_id, Some(user_id))
+    })
+    .await??;
+
+    let res = CommentResponse {
+      comment_view,
+      recipient_ids: Vec::new(),
+      form_id: None,
+    };
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for SaveComment {
+  type Response = CommentResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<CommentResponse, LemmyError> {
+    let data: &SaveComment = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let comment_saved_form = CommentSavedForm {
+      comment_id: data.comment_id,
+      user_id: user.id,
+    };
+
+    if data.save {
+      let save_comment = move |conn: &'_ _| CommentSaved::save(conn, &comment_saved_form);
+      if blocking(context.pool(), save_comment).await?.is_err() {
+        return Err(APIError::err("couldnt_save_comment").into());
+      }
+    } else {
+      let unsave_comment = move |conn: &'_ _| CommentSaved::unsave(conn, &comment_saved_form);
+      if blocking(context.pool(), unsave_comment).await?.is_err() {
+        return Err(APIError::err("couldnt_save_comment").into());
+      }
+    }
+
+    let comment_id = data.comment_id;
+    let user_id = user.id;
+    let comment_view = blocking(context.pool(), move |conn| {
+      CommentView::read(conn, comment_id, Some(user_id))
+    })
+    .await??;
+
+    Ok(CommentResponse {
+      comment_view,
+      recipient_ids: Vec::new(),
+      form_id: None,
+    })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for CreateCommentLike {
+  type Response = CommentResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommentResponse, LemmyError> {
+    let data: &CreateCommentLike = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let mut recipient_ids = Vec::new();
+
+    // Don't do a downvote if site has downvotes disabled
+    check_downvotes_enabled(data.score, context.pool()).await?;
+
+    let comment_id = data.comment_id;
+    let orig_comment = blocking(context.pool(), move |conn| {
+      CommentView::read(&conn, comment_id, None)
+    })
+    .await??;
+
+    check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
+
+    // Add parent user to recipients
+    recipient_ids.push(orig_comment.get_recipient_id());
+
+    let like_form = CommentLikeForm {
+      comment_id: data.comment_id,
+      post_id: orig_comment.post.id,
+      user_id: user.id,
+      score: data.score,
+    };
+
+    // Remove any likes first
+    let user_id = user.id;
+    blocking(context.pool(), move |conn| {
+      CommentLike::remove(conn, user_id, comment_id)
+    })
+    .await??;
+
+    // Only add the like if the score isnt 0
+    let comment = orig_comment.comment;
+    let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
+    if do_add {
+      let like_form2 = like_form.clone();
+      let like = move |conn: &'_ _| CommentLike::like(conn, &like_form2);
+      if blocking(context.pool(), like).await?.is_err() {
+        return Err(APIError::err("couldnt_like_comment").into());
+      }
+
+      if like_form.score == 1 {
+        comment.send_like(&user, context).await?;
+      } else if like_form.score == -1 {
+        comment.send_dislike(&user, context).await?;
+      }
+    } else {
+      comment.send_undo_like(&user, context).await?;
+    }
+
+    // Have to refetch the comment to get the current state
+    let comment_id = data.comment_id;
+    let user_id = user.id;
+    let liked_comment = blocking(context.pool(), move |conn| {
+      CommentView::read(conn, comment_id, Some(user_id))
+    })
+    .await??;
+
+    let res = CommentResponse {
+      comment_view: liked_comment,
+      recipient_ids,
+      form_id: None,
+    };
+
+    context.chat_server().do_send(SendComment {
+      op: UserOperation::CreateCommentLike,
+      comment: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for GetComments {
+  type Response = GetCommentsResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetCommentsResponse, LemmyError> {
+    let data: &GetComments = &self;
+    let user = get_user_from_jwt_opt(&data.auth, context.pool()).await?;
+    let user_id = user.map(|u| u.id);
+
+    let type_ = ListingType::from_str(&data.type_)?;
+    let sort = SortType::from_str(&data.sort)?;
+
+    let community_id = data.community_id;
+    let community_name = data.community_name.to_owned();
+    let page = data.page;
+    let limit = data.limit;
+    let comments = blocking(context.pool(), move |conn| {
+      CommentQueryBuilder::create(conn)
+        .listing_type(type_)
+        .sort(&sort)
+        .community_id(community_id)
+        .community_name(community_name)
+        .my_user_id(user_id)
+        .page(page)
+        .limit(limit)
+        .list()
+    })
+    .await?;
+    let comments = match comments {
+      Ok(comments) => comments,
+      Err(_) => return Err(APIError::err("couldnt_get_comments").into()),
+    };
+
+    Ok(GetCommentsResponse { comments })
+  }
+}
+
+/// Creates a comment report and notifies the moderators of the community
+#[async_trait::async_trait(?Send)]
+impl Perform for CreateCommentReport {
+  type Response = CreateCommentReportResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CreateCommentReportResponse, LemmyError> {
+    let data: &CreateCommentReport = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    // check size of report and check for whitespace
+    let reason = data.reason.trim();
+    if reason.is_empty() {
+      return Err(APIError::err("report_reason_required").into());
+    }
+    if reason.chars().count() > 1000 {
+      return Err(APIError::err("report_too_long").into());
+    }
+
+    let user_id = user.id;
+    let comment_id = data.comment_id;
+    let comment_view = blocking(context.pool(), move |conn| {
+      CommentView::read(&conn, comment_id, None)
+    })
+    .await??;
+
+    check_community_ban(user_id, comment_view.community.id, context.pool()).await?;
+
+    let report_form = CommentReportForm {
+      creator_id: user_id,
+      comment_id,
+      original_comment_text: comment_view.comment.content,
+      reason: data.reason.to_owned(),
+    };
+
+    let report = match blocking(context.pool(), move |conn| {
+      CommentReport::report(conn, &report_form)
+    })
+    .await?
+    {
+      Ok(report) => report,
+      Err(_e) => return Err(APIError::err("couldnt_create_report").into()),
+    };
+
+    let res = CreateCommentReportResponse { success: true };
+
+    context.chat_server().do_send(SendUserRoomMessage {
+      op: UserOperation::CreateCommentReport,
+      response: res.clone(),
+      recipient_id: user.id,
+      websocket_id,
+    });
+
+    context.chat_server().do_send(SendModRoomMessage {
+      op: UserOperation::CreateCommentReport,
+      response: report,
+      community_id: comment_view.community.id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+/// Resolves or unresolves a comment report and notifies the moderators of the community
+#[async_trait::async_trait(?Send)]
+impl Perform for ResolveCommentReport {
+  type Response = ResolveCommentReportResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<ResolveCommentReportResponse, LemmyError> {
+    let data: &ResolveCommentReport = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let report_id = data.report_id;
+    let report = blocking(context.pool(), move |conn| {
+      CommentReportView::read(&conn, report_id)
+    })
+    .await??;
+
+    let user_id = user.id;
+    is_mod_or_admin(context.pool(), user_id, report.community.id).await?;
+
+    let resolved = data.resolved;
+    let resolve_fun = move |conn: &'_ _| {
+      if resolved {
+        CommentReport::resolve(conn, report_id, user_id)
+      } else {
+        CommentReport::unresolve(conn, report_id, user_id)
+      }
+    };
+
+    if blocking(context.pool(), resolve_fun).await?.is_err() {
+      return Err(APIError::err("couldnt_resolve_report").into());
+    };
+
+    let report_id = data.report_id;
+    let res = ResolveCommentReportResponse {
+      report_id,
+      resolved,
+    };
+
+    context.chat_server().do_send(SendModRoomMessage {
+      op: UserOperation::ResolveCommentReport,
+      response: res.clone(),
+      community_id: report.community.id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+/// Lists comment reports for a community if an id is supplied
+/// or returns all comment reports for communities a user moderates
+#[async_trait::async_trait(?Send)]
+impl Perform for ListCommentReports {
+  type Response = ListCommentReportsResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<ListCommentReportsResponse, LemmyError> {
+    let data: &ListCommentReports = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let user_id = user.id;
+    let community_id = data.community;
+    let community_ids =
+      collect_moderated_communities(user_id, community_id, context.pool()).await?;
+
+    let page = data.page;
+    let limit = data.limit;
+    let comments = blocking(context.pool(), move |conn| {
+      CommentReportQueryBuilder::create(conn)
+        .community_ids(community_ids)
+        .page(page)
+        .limit(limit)
+        .list()
+    })
+    .await??;
+
+    let res = ListCommentReportsResponse { comments };
+
+    context.chat_server().do_send(SendUserRoomMessage {
+      op: UserOperation::ListCommentReports,
+      response: res.clone(),
+      recipient_id: user.id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}

crates/api/src/comment/distinguish.rs

@@ -1,66 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  comment::{CommentResponse, DistinguishComment},
-  context::LemmyContext,
-  utils::{check_community_mod_action, check_community_user_action},
-};
-use lemmy_db_schema::{
-  source::comment::{Comment, CommentUpdateForm},
-  traits::Crud,
-};
-use lemmy_db_views::structs::{CommentView, LocalUserView};
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn distinguish_comment(
-  data: Json<DistinguishComment>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<CommentResponse>> {
-  let orig_comment = CommentView::read(&mut context.pool(), data.comment_id, None)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindComment)?;
-
-  check_community_user_action(
-    &local_user_view.person,
-    orig_comment.community.id,
-    &mut context.pool(),
-  )
-  .await?;
-
-  // Verify that only the creator can distinguish
-  if local_user_view.person.id != orig_comment.creator.id {
-    Err(LemmyErrorType::NoCommentEditAllowed)?
-  }
-
-  // Verify that only a mod or admin can distinguish a comment
-  check_community_mod_action(
-    &local_user_view.person,
-    orig_comment.community.id,
-    false,
-    &mut context.pool(),
-  )
-  .await?;
-
-  // Update the Comment
-  let form = CommentUpdateForm {
-    distinguished: Some(data.distinguished),
-    ..Default::default()
-  };
-  Comment::update(&mut context.pool(), data.comment_id, &form)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?;
-
-  let comment_view = CommentView::read(
-    &mut context.pool(),
-    data.comment_id,
-    Some(local_user_view.person.id),
-  )
-  .await?
-  .ok_or(LemmyErrorType::CouldntFindComment)?;
-
-  Ok(Json(CommentResponse {
-    comment_view,
-    recipient_ids: Vec::new(),
-  }))
-}

crates/api/src/comment/like.rs

@@ -1,100 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  build_response::build_comment_response,
-  comment::{CommentResponse, CreateCommentLike},
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::{check_bot_account, check_community_user_action, check_downvotes_enabled},
-};
-use lemmy_db_schema::{
-  newtypes::LocalUserId,
-  source::{
-    comment::{CommentLike, CommentLikeForm},
-    comment_reply::CommentReply,
-    local_site::LocalSite,
-  },
-  traits::Likeable,
-};
-use lemmy_db_views::structs::{CommentView, LocalUserView};
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-use std::ops::Deref;
-
-#[tracing::instrument(skip(context))]
-pub async fn like_comment(
-  data: Json<CreateCommentLike>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<CommentResponse>> {
-  let local_site = LocalSite::read(&mut context.pool()).await?;
-
-  let mut recipient_ids = Vec::<LocalUserId>::new();
-
-  // Don't do a downvote if site has downvotes disabled
-  check_downvotes_enabled(data.score, &local_site)?;
-  check_bot_account(&local_user_view.person)?;
-
-  let comment_id = data.comment_id;
-  let orig_comment = CommentView::read(&mut context.pool(), comment_id, None)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindComment)?;
-
-  check_community_user_action(
-    &local_user_view.person,
-    orig_comment.community.id,
-    &mut context.pool(),
-  )
-  .await?;
-
-  // Add parent poster or commenter to recipients
-  let comment_reply = CommentReply::read_by_comment(&mut context.pool(), comment_id).await;
-  if let Ok(Some(reply)) = comment_reply {
-    let recipient_id = reply.recipient_id;
-    if let Ok(Some(local_recipient)) =
-      LocalUserView::read_person(&mut context.pool(), recipient_id).await
-    {
-      recipient_ids.push(local_recipient.local_user.id);
-    }
-  }
-
-  let like_form = CommentLikeForm {
-    comment_id: data.comment_id,
-    post_id: orig_comment.post.id,
-    person_id: local_user_view.person.id,
-    score: data.score,
-  };
-
-  // Remove any likes first
-  let person_id = local_user_view.person.id;
-
-  CommentLike::remove(&mut context.pool(), person_id, comment_id).await?;
-
-  // Only add the like if the score isnt 0
-  let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
-  if do_add {
-    CommentLike::like(&mut context.pool(), &like_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CouldntLikeComment)?;
-  }
-
-  ActivityChannel::submit_activity(
-    SendActivityData::LikePostOrComment {
-      object_id: orig_comment.comment.ap_id,
-      actor: local_user_view.person.clone(),
-      community: orig_comment.community,
-      score: data.score,
-    },
-    &context,
-  )
-  .await?;
-
-  Ok(Json(
-    build_comment_response(
-      context.deref(),
-      comment_id,
-      Some(local_user_view),
-      recipient_ids,
-    )
-    .await?,
-  ))
-}

crates/api/src/comment/list_comment_likes.rs

@@ -1,36 +0,0 @@
-use actix_web::web::{Data, Json, Query};
-use lemmy_api_common::{
-  comment::{ListCommentLikes, ListCommentLikesResponse},
-  context::LemmyContext,
-  utils::is_mod_or_admin,
-};
-use lemmy_db_views::structs::{CommentView, LocalUserView, VoteView};
-use lemmy_utils::{error::LemmyResult, LemmyErrorType};
-
-/// Lists likes for a comment
-#[tracing::instrument(skip(context))]
-pub async fn list_comment_likes(
-  data: Query<ListCommentLikes>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<ListCommentLikesResponse>> {
-  let comment_view = CommentView::read(
-    &mut context.pool(),
-    data.comment_id,
-    Some(local_user_view.person.id),
-  )
-  .await?
-  .ok_or(LemmyErrorType::CouldntFindComment)?;
-
-  is_mod_or_admin(
-    &mut context.pool(),
-    &local_user_view.person,
-    comment_view.community.id,
-  )
-  .await?;
-
-  let comment_likes =
-    VoteView::list_for_comment(&mut context.pool(), data.comment_id, data.page, data.limit).await?;
-
-  Ok(Json(ListCommentLikesResponse { comment_likes }))
-}

crates/api/src/comment/mod.rs

@@ -1,4 +0,0 @@
-pub mod distinguish;
-pub mod like;
-pub mod list_comment_likes;
-pub mod save;

crates/api/src/comment/save.rs

@@ -1,44 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  comment::{CommentResponse, SaveComment},
-  context::LemmyContext,
-};
-use lemmy_db_schema::{
-  source::comment::{CommentSaved, CommentSavedForm},
-  traits::Saveable,
-};
-use lemmy_db_views::structs::{CommentView, LocalUserView};
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn save_comment(
-  data: Json<SaveComment>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<CommentResponse>> {
-  let comment_saved_form = CommentSavedForm {
-    comment_id: data.comment_id,
-    person_id: local_user_view.person.id,
-  };
-
-  if data.save {
-    CommentSaved::save(&mut context.pool(), &comment_saved_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CouldntSaveComment)?;
-  } else {
-    CommentSaved::unsave(&mut context.pool(), &comment_saved_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CouldntSaveComment)?;
-  }
-
-  let comment_id = data.comment_id;
-  let person_id = local_user_view.person.id;
-  let comment_view = CommentView::read(&mut context.pool(), comment_id, Some(person_id))
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindComment)?;
-
-  Ok(Json(CommentResponse {
-    comment_view,
-    recipient_ids: Vec::new(),
-  }))
-}

crates/api/src/comment_report/create.rs

@@ -1,92 +0,0 @@
-use crate::check_report_reason;
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  comment::{CommentReportResponse, CreateCommentReport},
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::{
-    check_comment_deleted_or_removed,
-    check_community_user_action,
-    send_new_report_email_to_admins,
-  },
-};
-use lemmy_db_schema::{
-  source::{
-    comment_report::{CommentReport, CommentReportForm},
-    local_site::LocalSite,
-  },
-  traits::Reportable,
-};
-use lemmy_db_views::structs::{CommentReportView, CommentView, LocalUserView};
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-/// Creates a comment report and notifies the moderators of the community
-#[tracing::instrument(skip(context))]
-pub async fn create_comment_report(
-  data: Json<CreateCommentReport>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<CommentReportResponse>> {
-  let local_site = LocalSite::read(&mut context.pool()).await?;
-
-  let reason = data.reason.trim().to_string();
-  check_report_reason(&reason, &local_site)?;
-
-  let person_id = local_user_view.person.id;
-  let comment_id = data.comment_id;
-  let comment_view = CommentView::read(&mut context.pool(), comment_id, None)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindComment)?;
-
-  check_community_user_action(
-    &local_user_view.person,
-    comment_view.community.id,
-    &mut context.pool(),
-  )
-  .await?;
-
-  // Don't allow creating reports for removed / deleted comments
-  check_comment_deleted_or_removed(&comment_view.comment)?;
-
-  let report_form = CommentReportForm {
-    creator_id: person_id,
-    comment_id,
-    original_comment_text: comment_view.comment.content,
-    reason,
-  };
-
-  let report = CommentReport::report(&mut context.pool(), &report_form)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntCreateReport)?;
-
-  let comment_report_view = CommentReportView::read(&mut context.pool(), report.id, person_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindCommentReport)?;
-
-  // Email the admins
-  if local_site.reports_email_admins {
-    send_new_report_email_to_admins(
-      &comment_report_view.creator.name,
-      &comment_report_view.comment_creator.name,
-      &mut context.pool(),
-      context.settings(),
-    )
-    .await?;
-  }
-
-  ActivityChannel::submit_activity(
-    SendActivityData::CreateReport {
-      object_id: comment_view.comment.ap_id.inner().clone(),
-      actor: local_user_view.person,
-      community: comment_view.community,
-      reason: data.reason.clone(),
-    },
-    &context,
-  )
-  .await?;
-
-  Ok(Json(CommentReportResponse {
-    comment_report_view,
-  }))
-}

crates/api/src/comment_report/list.rs

@@ -1,37 +0,0 @@
-use actix_web::web::{Data, Json, Query};
-use lemmy_api_common::{
-  comment::{ListCommentReports, ListCommentReportsResponse},
-  context::LemmyContext,
-  utils::check_community_mod_of_any_or_admin_action,
-};
-use lemmy_db_views::{comment_report_view::CommentReportQuery, structs::LocalUserView};
-use lemmy_utils::error::LemmyResult;
-
-/// Lists comment reports for a community if an id is supplied
-/// or returns all comment reports for communities a user moderates
-#[tracing::instrument(skip(context))]
-pub async fn list_comment_reports(
-  data: Query<ListCommentReports>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<ListCommentReportsResponse>> {
-  let community_id = data.community_id;
-  let comment_id = data.comment_id;
-  let unresolved_only = data.unresolved_only.unwrap_or_default();
-
-  check_community_mod_of_any_or_admin_action(&local_user_view, &mut context.pool()).await?;
-
-  let page = data.page;
-  let limit = data.limit;
-  let comment_reports = CommentReportQuery {
-    community_id,
-    comment_id,
-    unresolved_only,
-    page,
-    limit,
-  }
-  .list(&mut context.pool(), &local_user_view)
-  .await?;
-
-  Ok(Json(ListCommentReportsResponse { comment_reports }))
-}

crates/api/src/comment_report/mod.rs

@@ -1,3 +0,0 @@
-pub mod create;
-pub mod list;
-pub mod resolve;

crates/api/src/comment_report/resolve.rs

@@ -1,51 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  comment::{CommentReportResponse, ResolveCommentReport},
-  context::LemmyContext,
-  utils::check_community_mod_action,
-};
-use lemmy_db_schema::{source::comment_report::CommentReport, traits::Reportable};
-use lemmy_db_views::structs::{CommentReportView, LocalUserView};
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-/// Resolves or unresolves a comment report and notifies the moderators of the community
-#[tracing::instrument(skip(context))]
-pub async fn resolve_comment_report(
-  data: Json<ResolveCommentReport>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<CommentReportResponse>> {
-  let report_id = data.report_id;
-  let person_id = local_user_view.person.id;
-  let report = CommentReportView::read(&mut context.pool(), report_id, person_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindCommentReport)?;
-
-  let person_id = local_user_view.person.id;
-  check_community_mod_action(
-    &local_user_view.person,
-    report.community.id,
-    true,
-    &mut context.pool(),
-  )
-  .await?;
-
-  if data.resolved {
-    CommentReport::resolve(&mut context.pool(), report_id, person_id)
-      .await
-      .with_lemmy_type(LemmyErrorType::CouldntResolveReport)?;
-  } else {
-    CommentReport::unresolve(&mut context.pool(), report_id, person_id)
-      .await
-      .with_lemmy_type(LemmyErrorType::CouldntResolveReport)?;
-  }
-
-  let report_id = data.report_id;
-  let comment_report_view = CommentReportView::read(&mut context.pool(), report_id, person_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindCommentReport)?;
-
-  Ok(Json(CommentReportResponse {
-    comment_report_view,
-  }))
-}

crates/api/src/community.rs

@@ -0,0 +1,901 @@
+use crate::{
+  check_community_ban,
+  check_optional_url,
+  get_user_from_jwt,
+  get_user_from_jwt_opt,
+  is_admin,
+  is_mod_or_admin,
+  Perform,
+};
+use actix_web::web::Data;
+use anyhow::Context;
+use lemmy_apub::{
+  generate_apub_endpoint,
+  generate_followers_url,
+  generate_inbox_url,
+  generate_shared_inbox_url,
+  ActorType,
+  EndpointType,
+};
+use lemmy_db_queries::{
+  diesel_option_overwrite,
+  source::{
+    comment::Comment_,
+    community::{CommunityModerator_, Community_},
+    post::Post_,
+  },
+  ApubObject,
+  Bannable,
+  Crud,
+  Followable,
+  Joinable,
+  ListingType,
+  SortType,
+};
+use lemmy_db_schema::{
+  naive_now,
+  source::{comment::Comment, community::*, moderator::*, post::Post, site::*},
+};
+use lemmy_db_views::comment_view::CommentQueryBuilder;
+use lemmy_db_views_actor::{
+  community_follower_view::CommunityFollowerView,
+  community_moderator_view::CommunityModeratorView,
+  community_view::{CommunityQueryBuilder, CommunityView},
+  user_view::UserViewSafe,
+};
+use lemmy_structs::{blocking, community::*};
+use lemmy_utils::{
+  apub::generate_actor_keypair,
+  location_info,
+  utils::{check_slurs, check_slurs_opt, is_valid_community_name, naive_from_unix},
+  APIError,
+  ConnectionId,
+  LemmyError,
+};
+use lemmy_websocket::{
+  messages::{GetCommunityUsersOnline, SendCommunityRoomMessage},
+  LemmyContext,
+  UserOperation,
+};
+use std::str::FromStr;
+
+#[async_trait::async_trait(?Send)]
+impl Perform for GetCommunity {
+  type Response = GetCommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetCommunityResponse, LemmyError> {
+    let data: &GetCommunity = &self;
+    let user = get_user_from_jwt_opt(&data.auth, context.pool()).await?;
+    let user_id = user.map(|u| u.id);
+
+    let community_id = match data.id {
+      Some(id) => id,
+      None => {
+        let name = data.name.to_owned().unwrap_or_else(|| "main".to_string());
+        match blocking(context.pool(), move |conn| {
+          Community::read_from_name(conn, &name)
+        })
+        .await?
+        {
+          Ok(community) => community,
+          Err(_e) => return Err(APIError::err("couldnt_find_community").into()),
+        }
+        .id
+      }
+    };
+
+    let community_view = match blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, user_id)
+    })
+    .await?
+    {
+      Ok(community) => community,
+      Err(_e) => return Err(APIError::err("couldnt_find_community").into()),
+    };
+
+    let moderators: Vec<CommunityModeratorView> = match blocking(context.pool(), move |conn| {
+      CommunityModeratorView::for_community(conn, community_id)
+    })
+    .await?
+    {
+      Ok(moderators) => moderators,
+      Err(_e) => return Err(APIError::err("couldnt_find_community").into()),
+    };
+
+    let online = context
+      .chat_server()
+      .send(GetCommunityUsersOnline { community_id })
+      .await
+      .unwrap_or(1);
+
+    let res = GetCommunityResponse {
+      community_view,
+      moderators,
+      online,
+    };
+
+    // Return the jwt
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for CreateCommunity {
+  type Response = CommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<CommunityResponse, LemmyError> {
+    let data: &CreateCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    check_slurs(&data.name)?;
+    check_slurs(&data.title)?;
+    check_slurs_opt(&data.description)?;
+
+    if !is_valid_community_name(&data.name) {
+      return Err(APIError::err("invalid_community_name").into());
+    }
+
+    // Double check for duplicate community actor_ids
+    let community_actor_id = generate_apub_endpoint(EndpointType::Community, &data.name)?;
+    let actor_id_cloned = community_actor_id.to_owned();
+    let community_dupe = blocking(context.pool(), move |conn| {
+      Community::read_from_apub_id(conn, &actor_id_cloned)
+    })
+    .await?;
+    if community_dupe.is_ok() {
+      return Err(APIError::err("community_already_exists").into());
+    }
+
+    // Check to make sure the icon and banners are urls
+    let icon = diesel_option_overwrite(&data.icon);
+    let banner = diesel_option_overwrite(&data.banner);
+
+    check_optional_url(&icon)?;
+    check_optional_url(&banner)?;
+
+    // When you create a community, make sure the user becomes a moderator and a follower
+    let keypair = generate_actor_keypair()?;
+
+    let community_form = CommunityForm {
+      name: data.name.to_owned(),
+      title: data.title.to_owned(),
+      description: data.description.to_owned(),
+      icon,
+      banner,
+      category_id: data.category_id,
+      creator_id: user.id,
+      removed: None,
+      deleted: None,
+      nsfw: data.nsfw,
+      updated: None,
+      actor_id: Some(community_actor_id.to_owned()),
+      local: true,
+      private_key: Some(keypair.private_key),
+      public_key: Some(keypair.public_key),
+      last_refreshed_at: None,
+      published: None,
+      followers_url: Some(generate_followers_url(&community_actor_id)?),
+      inbox_url: Some(generate_inbox_url(&community_actor_id)?),
+      shared_inbox_url: Some(Some(generate_shared_inbox_url(&community_actor_id)?)),
+    };
+
+    let inserted_community = match blocking(context.pool(), move |conn| {
+      Community::create(conn, &community_form)
+    })
+    .await?
+    {
+      Ok(community) => community,
+      Err(_e) => return Err(APIError::err("community_already_exists").into()),
+    };
+
+    // The community creator becomes a moderator
+    let community_moderator_form = CommunityModeratorForm {
+      community_id: inserted_community.id,
+      user_id: user.id,
+    };
+
+    let join = move |conn: &'_ _| CommunityModerator::join(conn, &community_moderator_form);
+    if blocking(context.pool(), join).await?.is_err() {
+      return Err(APIError::err("community_moderator_already_exists").into());
+    }
+
+    // Follow your own community
+    let community_follower_form = CommunityFollowerForm {
+      community_id: inserted_community.id,
+      user_id: user.id,
+      pending: false,
+    };
+
+    let follow = move |conn: &'_ _| CommunityFollower::follow(conn, &community_follower_form);
+    if blocking(context.pool(), follow).await?.is_err() {
+      return Err(APIError::err("community_follower_already_exists").into());
+    }
+
+    let user_id = user.id;
+    let community_view = blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, inserted_community.id, Some(user_id))
+    })
+    .await??;
+
+    Ok(CommunityResponse { community_view })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for EditCommunity {
+  type Response = CommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommunityResponse, LemmyError> {
+    let data: &EditCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    check_slurs(&data.title)?;
+    check_slurs_opt(&data.description)?;
+
+    // Verify its a mod (only mods can edit it)
+    let community_id = data.community_id;
+    let mods: Vec<i32> = blocking(context.pool(), move |conn| {
+      CommunityModeratorView::for_community(conn, community_id)
+        .map(|v| v.into_iter().map(|m| m.moderator.id).collect())
+    })
+    .await??;
+    if !mods.contains(&user.id) {
+      return Err(APIError::err("not_a_moderator").into());
+    }
+
+    let community_id = data.community_id;
+    let read_community = blocking(context.pool(), move |conn| {
+      Community::read(conn, community_id)
+    })
+    .await??;
+
+    let icon = diesel_option_overwrite(&data.icon);
+    let banner = diesel_option_overwrite(&data.banner);
+
+    check_optional_url(&icon)?;
+    check_optional_url(&banner)?;
+
+    let community_form = CommunityForm {
+      name: read_community.name,
+      title: data.title.to_owned(),
+      description: data.description.to_owned(),
+      icon,
+      banner,
+      category_id: data.category_id.to_owned(),
+      creator_id: read_community.creator_id,
+      removed: Some(read_community.removed),
+      deleted: Some(read_community.deleted),
+      nsfw: data.nsfw,
+      updated: Some(naive_now()),
+      actor_id: Some(read_community.actor_id),
+      local: read_community.local,
+      private_key: read_community.private_key,
+      public_key: read_community.public_key,
+      last_refreshed_at: None,
+      published: None,
+      followers_url: None,
+      inbox_url: None,
+      shared_inbox_url: None,
+    };
+
+    let community_id = data.community_id;
+    match blocking(context.pool(), move |conn| {
+      Community::update(conn, community_id, &community_form)
+    })
+    .await?
+    {
+      Ok(community) => community,
+      Err(_e) => return Err(APIError::err("couldnt_update_community").into()),
+    };
+
+    // TODO there needs to be some kind of an apub update
+    // process for communities and users
+
+    let community_id = data.community_id;
+    let user_id = user.id;
+    let community_view = blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, Some(user_id))
+    })
+    .await??;
+
+    let res = CommunityResponse { community_view };
+
+    send_community_websocket(&res, context, websocket_id, UserOperation::EditCommunity);
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for DeleteCommunity {
+  type Response = CommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommunityResponse, LemmyError> {
+    let data: &DeleteCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    // Verify its the creator (only a creator can delete the community)
+    let community_id = data.community_id;
+    let read_community = blocking(context.pool(), move |conn| {
+      Community::read(conn, community_id)
+    })
+    .await??;
+    if read_community.creator_id != user.id {
+      return Err(APIError::err("no_community_edit_allowed").into());
+    }
+
+    // Do the delete
+    let community_id = data.community_id;
+    let deleted = data.deleted;
+    let updated_community = match blocking(context.pool(), move |conn| {
+      Community::update_deleted(conn, community_id, deleted)
+    })
+    .await?
+    {
+      Ok(community) => community,
+      Err(_e) => return Err(APIError::err("couldnt_update_community").into()),
+    };
+
+    // Send apub messages
+    if deleted {
+      updated_community.send_delete(context).await?;
+    } else {
+      updated_community.send_undo_delete(context).await?;
+    }
+
+    let community_id = data.community_id;
+    let user_id = user.id;
+    let community_view = blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, Some(user_id))
+    })
+    .await??;
+
+    let res = CommunityResponse { community_view };
+
+    send_community_websocket(&res, context, websocket_id, UserOperation::DeleteCommunity);
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for RemoveCommunity {
+  type Response = CommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CommunityResponse, LemmyError> {
+    let data: &RemoveCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    // Verify its an admin (only an admin can remove a community)
+    is_admin(context.pool(), user.id).await?;
+
+    // Do the remove
+    let community_id = data.community_id;
+    let removed = data.removed;
+    let updated_community = match blocking(context.pool(), move |conn| {
+      Community::update_removed(conn, community_id, removed)
+    })
+    .await?
+    {
+      Ok(community) => community,
+      Err(_e) => return Err(APIError::err("couldnt_update_community").into()),
+    };
+
+    // Mod tables
+    let expires = match data.expires {
+      Some(time) => Some(naive_from_unix(time)),
+      None => None,
+    };
+    let form = ModRemoveCommunityForm {
+      mod_user_id: user.id,
+      community_id: data.community_id,
+      removed: Some(removed),
+      reason: data.reason.to_owned(),
+      expires,
+    };
+    blocking(context.pool(), move |conn| {
+      ModRemoveCommunity::create(conn, &form)
+    })
+    .await??;
+
+    // Apub messages
+    if removed {
+      updated_community.send_remove(context).await?;
+    } else {
+      updated_community.send_undo_remove(context).await?;
+    }
+
+    let community_id = data.community_id;
+    let user_id = user.id;
+    let community_view = blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, Some(user_id))
+    })
+    .await??;
+
+    let res = CommunityResponse { community_view };
+
+    send_community_websocket(&res, context, websocket_id, UserOperation::RemoveCommunity);
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for ListCommunities {
+  type Response = ListCommunitiesResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<ListCommunitiesResponse, LemmyError> {
+    let data: &ListCommunities = &self;
+    let user = get_user_from_jwt_opt(&data.auth, context.pool()).await?;
+
+    let user_id = match &user {
+      Some(user) => Some(user.id),
+      None => None,
+    };
+
+    let show_nsfw = match &user {
+      Some(user) => user.show_nsfw,
+      None => false,
+    };
+
+    let type_ = ListingType::from_str(&data.type_)?;
+    let sort = SortType::from_str(&data.sort)?;
+
+    let page = data.page;
+    let limit = data.limit;
+    let communities = blocking(context.pool(), move |conn| {
+      CommunityQueryBuilder::create(conn)
+        .listing_type(&type_)
+        .sort(&sort)
+        .show_nsfw(show_nsfw)
+        .my_user_id(user_id)
+        .page(page)
+        .limit(limit)
+        .list()
+    })
+    .await??;
+
+    // Return the jwt
+    Ok(ListCommunitiesResponse { communities })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for FollowCommunity {
+  type Response = CommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<CommunityResponse, LemmyError> {
+    let data: &FollowCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let community_id = data.community_id;
+    let community = blocking(context.pool(), move |conn| {
+      Community::read(conn, community_id)
+    })
+    .await??;
+    let community_follower_form = CommunityFollowerForm {
+      community_id: data.community_id,
+      user_id: user.id,
+      pending: false,
+    };
+
+    if community.local {
+      if data.follow {
+        check_community_ban(user.id, community_id, context.pool()).await?;
+
+        let follow = move |conn: &'_ _| CommunityFollower::follow(conn, &community_follower_form);
+        if blocking(context.pool(), follow).await?.is_err() {
+          return Err(APIError::err("community_follower_already_exists").into());
+        }
+      } else {
+        let unfollow =
+          move |conn: &'_ _| CommunityFollower::unfollow(conn, &community_follower_form);
+        if blocking(context.pool(), unfollow).await?.is_err() {
+          return Err(APIError::err("community_follower_already_exists").into());
+        }
+      }
+    } else if data.follow {
+      // Dont actually add to the community followers here, because you need
+      // to wait for the accept
+      user.send_follow(&community.actor_id(), context).await?;
+    } else {
+      user.send_unfollow(&community.actor_id(), context).await?;
+      let unfollow = move |conn: &'_ _| CommunityFollower::unfollow(conn, &community_follower_form);
+      if blocking(context.pool(), unfollow).await?.is_err() {
+        return Err(APIError::err("community_follower_already_exists").into());
+      }
+    }
+
+    let community_id = data.community_id;
+    let user_id = user.id;
+    let mut community_view = blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, Some(user_id))
+    })
+    .await??;
+
+    // TODO: this needs to return a "pending" state, until Accept is received from the remote server
+    // For now, just assume that remote follows are accepted.
+    // Otherwise, the subscribed will be null
+    if !community.local {
+      community_view.subscribed = data.follow;
+    }
+
+    Ok(CommunityResponse { community_view })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for GetFollowedCommunities {
+  type Response = GetFollowedCommunitiesResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetFollowedCommunitiesResponse, LemmyError> {
+    let data: &GetFollowedCommunities = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let user_id = user.id;
+    let communities = match blocking(context.pool(), move |conn| {
+      CommunityFollowerView::for_user(conn, user_id)
+    })
+    .await?
+    {
+      Ok(communities) => communities,
+      _ => return Err(APIError::err("system_err_login").into()),
+    };
+
+    // Return the jwt
+    Ok(GetFollowedCommunitiesResponse { communities })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for BanFromCommunity {
+  type Response = BanFromCommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<BanFromCommunityResponse, LemmyError> {
+    let data: &BanFromCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let community_id = data.community_id;
+    let banned_user_id = data.user_id;
+
+    // Verify that only mods or admins can ban
+    is_mod_or_admin(context.pool(), user.id, community_id).await?;
+
+    let community_user_ban_form = CommunityUserBanForm {
+      community_id: data.community_id,
+      user_id: data.user_id,
+    };
+
+    if data.ban {
+      let ban = move |conn: &'_ _| CommunityUserBan::ban(conn, &community_user_ban_form);
+      if blocking(context.pool(), ban).await?.is_err() {
+        return Err(APIError::err("community_user_already_banned").into());
+      }
+
+      // Also unsubscribe them from the community, if they are subscribed
+      let community_follower_form = CommunityFollowerForm {
+        community_id: data.community_id,
+        user_id: banned_user_id,
+        pending: false,
+      };
+      blocking(context.pool(), move |conn: &'_ _| {
+        CommunityFollower::unfollow(conn, &community_follower_form)
+      })
+      .await?
+      .ok();
+    } else {
+      let unban = move |conn: &'_ _| CommunityUserBan::unban(conn, &community_user_ban_form);
+      if blocking(context.pool(), unban).await?.is_err() {
+        return Err(APIError::err("community_user_already_banned").into());
+      }
+    }
+
+    // Remove/Restore their data if that's desired
+    if data.remove_data {
+      // Posts
+      blocking(context.pool(), move |conn: &'_ _| {
+        Post::update_removed_for_creator(conn, banned_user_id, Some(community_id), true)
+      })
+      .await??;
+
+      // Comments
+      // TODO Diesel doesn't allow updates with joins, so this has to be a loop
+      let comments = blocking(context.pool(), move |conn| {
+        CommentQueryBuilder::create(conn)
+          .creator_id(banned_user_id)
+          .community_id(community_id)
+          .limit(std::i64::MAX)
+          .list()
+      })
+      .await??;
+
+      for comment_view in &comments {
+        let comment_id = comment_view.comment.id;
+        blocking(context.pool(), move |conn: &'_ _| {
+          Comment::update_removed(conn, comment_id, true)
+        })
+        .await??;
+      }
+    }
+
+    // Mod tables
+    // TODO eventually do correct expires
+    let expires = match data.expires {
+      Some(time) => Some(naive_from_unix(time)),
+      None => None,
+    };
+
+    let form = ModBanFromCommunityForm {
+      mod_user_id: user.id,
+      other_user_id: data.user_id,
+      community_id: data.community_id,
+      reason: data.reason.to_owned(),
+      banned: Some(data.ban),
+      expires,
+    };
+    blocking(context.pool(), move |conn| {
+      ModBanFromCommunity::create(conn, &form)
+    })
+    .await??;
+
+    let user_id = data.user_id;
+    let user_view = blocking(context.pool(), move |conn| {
+      UserViewSafe::read(conn, user_id)
+    })
+    .await??;
+
+    let res = BanFromCommunityResponse {
+      user_view,
+      banned: data.ban,
+    };
+
+    context.chat_server().do_send(SendCommunityRoomMessage {
+      op: UserOperation::BanFromCommunity,
+      response: res.clone(),
+      community_id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for AddModToCommunity {
+  type Response = AddModToCommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<AddModToCommunityResponse, LemmyError> {
+    let data: &AddModToCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let community_moderator_form = CommunityModeratorForm {
+      community_id: data.community_id,
+      user_id: data.user_id,
+    };
+
+    let community_id = data.community_id;
+
+    // Verify that only mods or admins can add mod
+    is_mod_or_admin(context.pool(), user.id, community_id).await?;
+
+    if data.added {
+      let join = move |conn: &'_ _| CommunityModerator::join(conn, &community_moderator_form);
+      if blocking(context.pool(), join).await?.is_err() {
+        return Err(APIError::err("community_moderator_already_exists").into());
+      }
+    } else {
+      let leave = move |conn: &'_ _| CommunityModerator::leave(conn, &community_moderator_form);
+      if blocking(context.pool(), leave).await?.is_err() {
+        return Err(APIError::err("community_moderator_already_exists").into());
+      }
+    }
+
+    // Mod tables
+    let form = ModAddCommunityForm {
+      mod_user_id: user.id,
+      other_user_id: data.user_id,
+      community_id: data.community_id,
+      removed: Some(!data.added),
+    };
+    blocking(context.pool(), move |conn| {
+      ModAddCommunity::create(conn, &form)
+    })
+    .await??;
+
+    let community_id = data.community_id;
+    let moderators = blocking(context.pool(), move |conn| {
+      CommunityModeratorView::for_community(conn, community_id)
+    })
+    .await??;
+
+    let res = AddModToCommunityResponse { moderators };
+
+    context.chat_server().do_send(SendCommunityRoomMessage {
+      op: UserOperation::AddModToCommunity,
+      response: res.clone(),
+      community_id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for TransferCommunity {
+  type Response = GetCommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetCommunityResponse, LemmyError> {
+    let data: &TransferCommunity = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let community_id = data.community_id;
+    let read_community = blocking(context.pool(), move |conn| {
+      Community::read(conn, community_id)
+    })
+    .await??;
+
+    let site_creator_id = blocking(context.pool(), move |conn| {
+      Site::read(conn, 1).map(|s| s.creator_id)
+    })
+    .await??;
+
+    let mut admins = blocking(context.pool(), move |conn| UserViewSafe::admins(conn)).await??;
+
+    // Making sure the creator, if an admin, is at the top
+    let creator_index = admins
+      .iter()
+      .position(|r| r.user.id == site_creator_id)
+      .context(location_info!())?;
+    let creator_user = admins.remove(creator_index);
+    admins.insert(0, creator_user);
+
+    // Make sure user is the creator, or an admin
+    if user.id != read_community.creator_id
+      && !admins.iter().map(|a| a.user.id).any(|x| x == user.id)
+    {
+      return Err(APIError::err("not_an_admin").into());
+    }
+
+    let community_id = data.community_id;
+    let new_creator = data.user_id;
+    let update = move |conn: &'_ _| Community::update_creator(conn, community_id, new_creator);
+    if blocking(context.pool(), update).await?.is_err() {
+      return Err(APIError::err("couldnt_update_community").into());
+    };
+
+    // You also have to re-do the community_moderator table, reordering it.
+    let community_id = data.community_id;
+    let mut community_mods = blocking(context.pool(), move |conn| {
+      CommunityModeratorView::for_community(conn, community_id)
+    })
+    .await??;
+    let creator_index = community_mods
+      .iter()
+      .position(|r| r.moderator.id == data.user_id)
+      .context(location_info!())?;
+    let creator_user = community_mods.remove(creator_index);
+    community_mods.insert(0, creator_user);
+
+    let community_id = data.community_id;
+    blocking(context.pool(), move |conn| {
+      CommunityModerator::delete_for_community(conn, community_id)
+    })
+    .await??;
+
+    // TODO: this should probably be a bulk operation
+    for cmod in &community_mods {
+      let community_moderator_form = CommunityModeratorForm {
+        community_id: cmod.community.id,
+        user_id: cmod.moderator.id,
+      };
+
+      let join = move |conn: &'_ _| CommunityModerator::join(conn, &community_moderator_form);
+      if blocking(context.pool(), join).await?.is_err() {
+        return Err(APIError::err("community_moderator_already_exists").into());
+      }
+    }
+
+    // Mod tables
+    let form = ModAddCommunityForm {
+      mod_user_id: user.id,
+      other_user_id: data.user_id,
+      community_id: data.community_id,
+      removed: Some(false),
+    };
+    blocking(context.pool(), move |conn| {
+      ModAddCommunity::create(conn, &form)
+    })
+    .await??;
+
+    let community_id = data.community_id;
+    let user_id = user.id;
+    let community_view = match blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, Some(user_id))
+    })
+    .await?
+    {
+      Ok(community) => community,
+      Err(_e) => return Err(APIError::err("couldnt_find_community").into()),
+    };
+
+    let community_id = data.community_id;
+    let moderators = match blocking(context.pool(), move |conn| {
+      CommunityModeratorView::for_community(conn, community_id)
+    })
+    .await?
+    {
+      Ok(moderators) => moderators,
+      Err(_e) => return Err(APIError::err("couldnt_find_community").into()),
+    };
+
+    // Return the jwt
+    Ok(GetCommunityResponse {
+      community_view,
+      moderators,
+      online: 0,
+    })
+  }
+}
+
+fn send_community_websocket(
+  res: &CommunityResponse,
+  context: &Data<LemmyContext>,
+  websocket_id: Option<ConnectionId>,
+  op: UserOperation,
+) {
+  // Strip out the user id and subscribed when sending to others
+  let mut res_sent = res.clone();
+  res_sent.community_view.subscribed = false;
+
+  context.chat_server().do_send(SendCommunityRoomMessage {
+    op,
+    response: res_sent,
+    community_id: res.community_view.community.id,
+    websocket_id,
+  });
+}

crates/api/src/community/add_mod.rs

@@ -1,97 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  community::{AddModToCommunity, AddModToCommunityResponse},
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::check_community_mod_action,
-};
-use lemmy_db_schema::{
-  source::{
-    community::{Community, CommunityModerator, CommunityModeratorForm},
-    moderator::{ModAddCommunity, ModAddCommunityForm},
-  },
-  traits::{Crud, Joinable},
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::CommunityModeratorView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn add_mod_to_community(
-  data: Json<AddModToCommunity>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<AddModToCommunityResponse>> {
-  let community_id = data.community_id;
-
-  // Verify that only mods or admins can add mod
-  check_community_mod_action(
-    &local_user_view.person,
-    community_id,
-    false,
-    &mut context.pool(),
-  )
-  .await?;
-  let community = Community::read(&mut context.pool(), community_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindCommunity)?;
-
-  // If user is admin and community is remote, explicitly check that he is a
-  // moderator. This is necessary because otherwise the action would be rejected
-  // by the community's home instance.
-  if local_user_view.local_user.admin && !community.local {
-    let is_mod = CommunityModeratorView::is_community_moderator(
-      &mut context.pool(),
-      community.id,
-      local_user_view.person.id,
-    )
-    .await?;
-    if !is_mod {
-      Err(LemmyErrorType::NotAModerator)?
-    }
-  }
-
-  // Update in local database
-  let community_moderator_form = CommunityModeratorForm {
-    community_id: data.community_id,
-    person_id: data.person_id,
-  };
-  if data.added {
-    CommunityModerator::join(&mut context.pool(), &community_moderator_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityModeratorAlreadyExists)?;
-  } else {
-    CommunityModerator::leave(&mut context.pool(), &community_moderator_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityModeratorAlreadyExists)?;
-  }
-
-  // Mod tables
-  let form = ModAddCommunityForm {
-    mod_person_id: local_user_view.person.id,
-    other_person_id: data.person_id,
-    community_id: data.community_id,
-    removed: Some(!data.added),
-  };
-
-  ModAddCommunity::create(&mut context.pool(), &form).await?;
-
-  // Note: in case a remote mod is added, this returns the old moderators list, it will only get
-  //       updated once we receive an activity from the community (like `Announce/Add/Moderator`)
-  let community_id = data.community_id;
-  let moderators = CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
-
-  ActivityChannel::submit_activity(
-    SendActivityData::AddModToCommunity {
-      moderator: local_user_view.person,
-      community_id: data.community_id,
-      target: data.person_id,
-      added: data.added,
-    },
-    &context,
-  )
-  .await?;
-
-  Ok(Json(AddModToCommunityResponse { moderators }))
-}

crates/api/src/community/ban.rs

@@ -1,111 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  community::{BanFromCommunity, BanFromCommunityResponse},
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::{check_community_mod_action, check_expire_time, remove_user_data_in_community},
-};
-use lemmy_db_schema::{
-  source::{
-    community::{
-      CommunityFollower,
-      CommunityFollowerForm,
-      CommunityPersonBan,
-      CommunityPersonBanForm,
-    },
-    moderator::{ModBanFromCommunity, ModBanFromCommunityForm},
-  },
-  traits::{Bannable, Crud, Followable},
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::PersonView;
-use lemmy_utils::{
-  error::{LemmyErrorExt, LemmyErrorType, LemmyResult},
-  utils::validation::is_valid_body_field,
-};
-
-#[tracing::instrument(skip(context))]
-pub async fn ban_from_community(
-  data: Json<BanFromCommunity>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<BanFromCommunityResponse>> {
-  let banned_person_id = data.person_id;
-  let remove_data = data.remove_data.unwrap_or(false);
-  let expires = check_expire_time(data.expires)?;
-
-  // Verify that only mods or admins can ban
-  check_community_mod_action(
-    &local_user_view.person,
-    data.community_id,
-    false,
-    &mut context.pool(),
-  )
-  .await?;
-  is_valid_body_field(&data.reason, false)?;
-
-  let community_user_ban_form = CommunityPersonBanForm {
-    community_id: data.community_id,
-    person_id: data.person_id,
-    expires: Some(expires),
-  };
-
-  if data.ban {
-    CommunityPersonBan::ban(&mut context.pool(), &community_user_ban_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityUserAlreadyBanned)?;
-
-    // Also unsubscribe them from the community, if they are subscribed
-    let community_follower_form = CommunityFollowerForm {
-      community_id: data.community_id,
-      person_id: banned_person_id,
-      pending: false,
-    };
-
-    CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
-      .await
-      .ok();
-  } else {
-    CommunityPersonBan::unban(&mut context.pool(), &community_user_ban_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityUserAlreadyBanned)?;
-  }
-
-  // Remove/Restore their data if that's desired
-  if remove_data {
-    remove_user_data_in_community(data.community_id, banned_person_id, &mut context.pool()).await?;
-  }
-
-  // Mod tables
-  let form = ModBanFromCommunityForm {
-    mod_person_id: local_user_view.person.id,
-    other_person_id: data.person_id,
-    community_id: data.community_id,
-    reason: data.reason.clone(),
-    banned: Some(data.ban),
-    expires,
-  };
-
-  ModBanFromCommunity::create(&mut context.pool(), &form).await?;
-
-  let person_view = PersonView::read(&mut context.pool(), data.person_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindPerson)?;
-
-  ActivityChannel::submit_activity(
-    SendActivityData::BanFromCommunity {
-      moderator: local_user_view.person,
-      community_id: data.community_id,
-      target: person_view.person.clone(),
-      data: data.0.clone(),
-    },
-    &context,
-  )
-  .await?;
-
-  Ok(Json(BanFromCommunityResponse {
-    person_view,
-    banned: data.ban,
-  }))
-}

crates/api/src/community/block.rs

@@ -1,72 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  community::{BlockCommunity, BlockCommunityResponse},
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-};
-use lemmy_db_schema::{
-  source::{
-    community::{CommunityFollower, CommunityFollowerForm},
-    community_block::{CommunityBlock, CommunityBlockForm},
-  },
-  traits::{Blockable, Followable},
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::CommunityView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn block_community(
-  data: Json<BlockCommunity>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<BlockCommunityResponse>> {
-  let community_id = data.community_id;
-  let person_id = local_user_view.person.id;
-  let community_block_form = CommunityBlockForm {
-    person_id,
-    community_id,
-  };
-
-  if data.block {
-    CommunityBlock::block(&mut context.pool(), &community_block_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityBlockAlreadyExists)?;
-
-    // Also, unfollow the community, and send a federated unfollow
-    let community_follower_form = CommunityFollowerForm {
-      community_id: data.community_id,
-      person_id,
-      pending: false,
-    };
-
-    CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
-      .await
-      .ok();
-  } else {
-    CommunityBlock::unblock(&mut context.pool(), &community_block_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityBlockAlreadyExists)?;
-  }
-
-  let community_view =
-    CommunityView::read(&mut context.pool(), community_id, Some(person_id), false)
-      .await?
-      .ok_or(LemmyErrorType::CouldntFindCommunity)?;
-
-  ActivityChannel::submit_activity(
-    SendActivityData::FollowCommunity(
-      community_view.community.clone(),
-      local_user_view.person.clone(),
-      false,
-    ),
-    &context,
-  )
-  .await?;
-
-  Ok(Json(BlockCommunityResponse {
-    blocked: data.block,
-    community_view,
-  }))
-}

crates/api/src/community/follow.rs

@@ -1,77 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  community::{CommunityResponse, FollowCommunity},
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::check_community_user_action,
-};
-use lemmy_db_schema::{
-  source::{
-    actor_language::CommunityLanguage,
-    community::{Community, CommunityFollower, CommunityFollowerForm},
-  },
-  traits::{Crud, Followable},
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::CommunityView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn follow_community(
-  data: Json<FollowCommunity>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<CommunityResponse>> {
-  let community = Community::read(&mut context.pool(), data.community_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindCommunity)?;
-  let mut community_follower_form = CommunityFollowerForm {
-    community_id: community.id,
-    person_id: local_user_view.person.id,
-    pending: false,
-  };
-
-  if data.follow {
-    if community.local {
-      check_community_user_action(&local_user_view.person, community.id, &mut context.pool())
-        .await?;
-
-      CommunityFollower::follow(&mut context.pool(), &community_follower_form)
-        .await
-        .with_lemmy_type(LemmyErrorType::CommunityFollowerAlreadyExists)?;
-    } else {
-      // Mark as pending, the actual federation activity is sent via `SendActivity` handler
-      community_follower_form.pending = true;
-      CommunityFollower::follow(&mut context.pool(), &community_follower_form)
-        .await
-        .with_lemmy_type(LemmyErrorType::CommunityFollowerAlreadyExists)?;
-    }
-  } else {
-    CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityFollowerAlreadyExists)?;
-  }
-
-  if !community.local {
-    ActivityChannel::submit_activity(
-      SendActivityData::FollowCommunity(community, local_user_view.person.clone(), data.follow),
-      &context,
-    )
-    .await?;
-  }
-
-  let community_id = data.community_id;
-  let person_id = local_user_view.person.id;
-  let community_view =
-    CommunityView::read(&mut context.pool(), community_id, Some(person_id), false)
-      .await?
-      .ok_or(LemmyErrorType::CouldntFindCommunity)?;
-
-  let discussion_languages = CommunityLanguage::read(&mut context.pool(), community_id).await?;
-
-  Ok(Json(CommunityResponse {
-    community_view,
-    discussion_languages,
-  }))
-}

crates/api/src/community/hide.rs

@@ -1,55 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  community::HideCommunity,
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::is_admin,
-  SuccessResponse,
-};
-use lemmy_db_schema::{
-  source::{
-    community::{Community, CommunityUpdateForm},
-    moderator::{ModHideCommunity, ModHideCommunityForm},
-  },
-  traits::Crud,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn hide_community(
-  data: Json<HideCommunity>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<SuccessResponse>> {
-  // Verify its a admin (only admin can hide or unhide it)
-  is_admin(&local_user_view)?;
-
-  let community_form = CommunityUpdateForm {
-    hidden: Some(data.hidden),
-    ..Default::default()
-  };
-
-  let mod_hide_community_form = ModHideCommunityForm {
-    community_id: data.community_id,
-    mod_person_id: local_user_view.person.id,
-    reason: data.reason.clone(),
-    hidden: Some(data.hidden),
-  };
-
-  let community_id = data.community_id;
-  let community = Community::update(&mut context.pool(), community_id, &community_form)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntUpdateCommunityHiddenStatus)?;
-
-  ModHideCommunity::create(&mut context.pool(), &mod_hide_community_form).await?;
-
-  ActivityChannel::submit_activity(
-    SendActivityData::UpdateCommunity(local_user_view.person.clone(), community),
-    &context,
-  )
-  .await?;
-
-  Ok(Json(SuccessResponse::default()))
-}

crates/api/src/community/mod.rs

@@ -1,6 +0,0 @@
-pub mod add_mod;
-pub mod ban;
-pub mod block;
-pub mod follow;
-pub mod hide;
-pub mod transfer;

crates/api/src/community/transfer.rs

@@ -1,97 +0,0 @@
-use actix_web::web::{Data, Json};
-use anyhow::Context;
-use lemmy_api_common::{
-  community::{GetCommunityResponse, TransferCommunity},
-  context::LemmyContext,
-  utils::{check_community_user_action, is_admin, is_top_mod},
-};
-use lemmy_db_schema::{
-  source::{
-    community::{CommunityModerator, CommunityModeratorForm},
-    moderator::{ModTransferCommunity, ModTransferCommunityForm},
-  },
-  traits::{Crud, Joinable},
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::{CommunityModeratorView, CommunityView};
-use lemmy_utils::{
-  error::{LemmyErrorExt, LemmyErrorType, LemmyResult},
-  location_info,
-};
-
-// TODO: we dont do anything for federation here, it should be updated the next time the community
-//       gets fetched. i hope we can get rid of the community creator role soon.
-#[tracing::instrument(skip(context))]
-pub async fn transfer_community(
-  data: Json<TransferCommunity>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<GetCommunityResponse>> {
-  let community_id = data.community_id;
-  let mut community_mods =
-    CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
-
-  check_community_user_action(&local_user_view.person, community_id, &mut context.pool()).await?;
-
-  // Make sure transferrer is either the top community mod, or an admin
-  if !(is_top_mod(&local_user_view, &community_mods).is_ok() || is_admin(&local_user_view).is_ok())
-  {
-    Err(LemmyErrorType::NotAnAdmin)?
-  }
-
-  // You have to re-do the community_moderator table, reordering it.
-  // Add the transferee to the top
-  let creator_index = community_mods
-    .iter()
-    .position(|r| r.moderator.id == data.person_id)
-    .context(location_info!())?;
-  let creator_person = community_mods.remove(creator_index);
-  community_mods.insert(0, creator_person);
-
-  // Delete all the mods
-  let community_id = data.community_id;
-
-  CommunityModerator::delete_for_community(&mut context.pool(), community_id).await?;
-
-  // TODO: this should probably be a bulk operation
-  // Re-add the mods, in the new order
-  for cmod in &community_mods {
-    let community_moderator_form = CommunityModeratorForm {
-      community_id: cmod.community.id,
-      person_id: cmod.moderator.id,
-    };
-
-    CommunityModerator::join(&mut context.pool(), &community_moderator_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::CommunityModeratorAlreadyExists)?;
-  }
-
-  // Mod tables
-  let form = ModTransferCommunityForm {
-    mod_person_id: local_user_view.person.id,
-    other_person_id: data.person_id,
-    community_id: data.community_id,
-  };
-
-  ModTransferCommunity::create(&mut context.pool(), &form).await?;
-
-  let community_id = data.community_id;
-  let person_id = local_user_view.person.id;
-  let community_view =
-    CommunityView::read(&mut context.pool(), community_id, Some(person_id), false)
-      .await?
-      .ok_or(LemmyErrorType::CouldntFindCommunity)?;
-
-  let community_id = data.community_id;
-  let moderators = CommunityModeratorView::for_community(&mut context.pool(), community_id)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntFindCommunity)?;
-
-  // Return the jwt
-  Ok(Json(GetCommunityResponse {
-    community_view,
-    site: None,
-    moderators,
-    discussion_languages: vec![],
-  }))
-}

crates/api/src/lib.rs

@@ -1,277 +1,469 @@
-use activitypub_federation::config::Data;
-use actix_web::{http::header::Header, HttpRequest};
-use actix_web_httpauth::headers::authorization::{Authorization, Bearer};
-use base64::{engine::general_purpose::STANDARD_NO_PAD as base64, Engine};
-use captcha::Captcha;
-use lemmy_api_common::{
-  claims::Claims,
-  community::BanFromCommunity,
-  context::LemmyContext,
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::{check_expire_time, check_user_valid, local_site_to_slur_regex, AUTH_COOKIE_NAME},
-};
-use lemmy_db_schema::{
+use actix_web::{web, web::Data};
+use lemmy_db_queries::{
   source::{
-    community::{
-      CommunityFollower,
-      CommunityFollowerForm,
-      CommunityPersonBan,
-      CommunityPersonBanForm,
-    },
-    local_site::LocalSite,
-    moderator::{ModBanFromCommunity, ModBanFromCommunityForm},
-    person::Person,
+    community::{CommunityModerator_, Community_},
+    site::Site_,
+    user::UserSafeSettings_,
   },
-  traits::{Bannable, Crud, Followable},
+  Crud,
+  DbPool,
 };
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::{
-  error::{LemmyErrorExt, LemmyErrorExt2, LemmyErrorType, LemmyResult},
-  utils::slurs::check_slurs,
+use lemmy_db_schema::source::{
+  community::{Community, CommunityModerator},
+  post::Post,
+  site::Site,
+  user::{UserSafeSettings, User_},
 };
-use std::io::Cursor;
-use totp_rs::{Secret, TOTP};
+use lemmy_db_views_actor::{
+  community_user_ban_view::CommunityUserBanView,
+  community_view::CommunityView,
+};
+use lemmy_structs::{blocking, comment::*, community::*, post::*, site::*, user::*, websocket::*};
+use lemmy_utils::{claims::Claims, settings::Settings, APIError, ConnectionId, LemmyError};
+use lemmy_websocket::{serialize_websocket_message, LemmyContext, UserOperation};
+use serde::Deserialize;
+use std::process::Command;
+use url::Url;
 
 pub mod comment;
-pub mod comment_report;
 pub mod community;
-pub mod local_user;
 pub mod post;
-pub mod post_report;
-pub mod private_message;
-pub mod private_message_report;
+pub mod routes;
 pub mod site;
-pub mod sitemap;
+pub mod user;
+pub mod websocket;
 
-/// Converts the captcha to a base64 encoded wav audio file
-#[allow(deprecated)]
-pub(crate) fn captcha_as_wav_base64(captcha: &Captcha) -> LemmyResult<String> {
-  let letters = captcha.as_wav();
+#[async_trait::async_trait(?Send)]
+pub trait Perform {
+  type Response: serde::ser::Serialize + Send;
 
-  // Decode each wav file, concatenate the samples
-  let mut concat_samples: Vec<i16> = Vec::new();
-  let mut any_header: Option<wav::Header> = None;
-  for letter in letters {
-    let mut cursor = Cursor::new(letter.unwrap_or_default());
-    let (header, samples) = wav::read(&mut cursor)?;
-    any_header = Some(header);
-    if let Some(samples16) = samples.as_sixteen() {
-      concat_samples.extend(samples16);
-    } else {
-      Err(LemmyErrorType::CouldntCreateAudioCaptcha)?
-    }
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<Self::Response, LemmyError>;
+}
+
+pub(crate) async fn is_mod_or_admin(
+  pool: &DbPool,
+  user_id: i32,
+  community_id: i32,
+) -> Result<(), LemmyError> {
+  let is_mod_or_admin = blocking(pool, move |conn| {
+    CommunityView::is_mod_or_admin(conn, user_id, community_id)
+  })
+  .await?;
+  if !is_mod_or_admin {
+    return Err(APIError::err("not_a_mod_or_admin").into());
   }
+  Ok(())
+}
+pub async fn is_admin(pool: &DbPool, user_id: i32) -> Result<(), LemmyError> {
+  let user = blocking(pool, move |conn| User_::read(conn, user_id)).await??;
+  if !user.admin {
+    return Err(APIError::err("not_an_admin").into());
+  }
+  Ok(())
+}
 
-  // Encode the concatenated result as a wav file
-  let mut output_buffer = Cursor::new(vec![]);
-  if let Some(header) = any_header {
-    wav::write(
-      header,
-      &wav::BitDepth::Sixteen(concat_samples),
-      &mut output_buffer,
-    )
-    .with_lemmy_type(LemmyErrorType::CouldntCreateAudioCaptcha)?;
-
-    Ok(base64.encode(output_buffer.into_inner()))
-  } else {
-    Err(LemmyErrorType::CouldntCreateAudioCaptcha)?
+pub(crate) async fn get_post(post_id: i32, pool: &DbPool) -> Result<Post, LemmyError> {
+  match blocking(pool, move |conn| Post::read(conn, post_id)).await? {
+    Ok(post) => Ok(post),
+    Err(_e) => Err(APIError::err("couldnt_find_post").into()),
   }
 }
 
-/// Check size of report
-pub(crate) fn check_report_reason(reason: &str, local_site: &LocalSite) -> LemmyResult<()> {
-  let slur_regex = &local_site_to_slur_regex(local_site);
+pub(crate) async fn get_user_from_jwt(jwt: &str, pool: &DbPool) -> Result<User_, LemmyError> {
+  let claims = match Claims::decode(&jwt) {
+    Ok(claims) => claims.claims,
+    Err(_e) => return Err(APIError::err("not_logged_in").into()),
+  };
+  let user_id = claims.id;
+  let user = blocking(pool, move |conn| User_::read(conn, user_id)).await??;
+  // Check for a site ban
+  if user.banned {
+    return Err(APIError::err("site_ban").into());
+  }
+  Ok(user)
+}
 
-  check_slurs(reason, slur_regex)?;
-  if reason.is_empty() {
-    Err(LemmyErrorType::ReportReasonRequired)?
-  } else if reason.chars().count() > 1000 {
-    Err(LemmyErrorType::ReportTooLong)?
+pub(crate) async fn get_user_from_jwt_opt(
+  jwt: &Option<String>,
+  pool: &DbPool,
+) -> Result<Option<User_>, LemmyError> {
+  match jwt {
+    Some(jwt) => Ok(Some(get_user_from_jwt(jwt, pool).await?)),
+    None => Ok(None),
+  }
+}
+
+pub(crate) async fn get_user_safe_settings_from_jwt(
+  jwt: &str,
+  pool: &DbPool,
+) -> Result<UserSafeSettings, LemmyError> {
+  let claims = match Claims::decode(&jwt) {
+    Ok(claims) => claims.claims,
+    Err(_e) => return Err(APIError::err("not_logged_in").into()),
+  };
+  let user_id = claims.id;
+  let user = blocking(pool, move |conn| UserSafeSettings::read(conn, user_id)).await??;
+  // Check for a site ban
+  if user.banned {
+    return Err(APIError::err("site_ban").into());
+  }
+  Ok(user)
+}
+
+pub(crate) async fn get_user_safe_settings_from_jwt_opt(
+  jwt: &Option<String>,
+  pool: &DbPool,
+) -> Result<Option<UserSafeSettings>, LemmyError> {
+  match jwt {
+    Some(jwt) => Ok(Some(get_user_safe_settings_from_jwt(jwt, pool).await?)),
+    None => Ok(None),
+  }
+}
+
+pub(crate) async fn check_community_ban(
+  user_id: i32,
+  community_id: i32,
+  pool: &DbPool,
+) -> Result<(), LemmyError> {
+  let is_banned = move |conn: &'_ _| CommunityUserBanView::get(conn, user_id, community_id).is_ok();
+  if blocking(pool, is_banned).await? {
+    Err(APIError::err("community_ban").into())
   } else {
     Ok(())
   }
 }
 
-pub fn read_auth_token(req: &HttpRequest) -> LemmyResult<Option<String>> {
-  // Try reading jwt from auth header
-  if let Ok(header) = Authorization::<Bearer>::parse(req) {
-    Ok(Some(header.as_ref().token().to_string()))
+pub(crate) async fn check_downvotes_enabled(score: i16, pool: &DbPool) -> Result<(), LemmyError> {
+  if score == -1 {
+    let site = blocking(pool, move |conn| Site::read_simple(conn)).await??;
+    if !site.enable_downvotes {
+      return Err(APIError::err("downvotes_disabled").into());
+    }
   }
-  // If that fails, try to read from cookie
-  else if let Some(cookie) = &req.cookie(AUTH_COOKIE_NAME) {
-    Ok(Some(cookie.value().to_string()))
+  Ok(())
+}
+
+/// Returns a list of communities that the user moderates
+/// or if a community_id is supplied validates the user is a moderator
+/// of that community and returns the community id in a vec
+///
+/// * `user_id` - the user id of the moderator
+/// * `community_id` - optional community id to check for moderator privileges
+/// * `pool` - the diesel db pool
+pub(crate) async fn collect_moderated_communities(
+  user_id: i32,
+  community_id: Option<i32>,
+  pool: &DbPool,
+) -> Result<Vec<i32>, LemmyError> {
+  if let Some(community_id) = community_id {
+    // if the user provides a community_id, just check for mod/admin privileges
+    is_mod_or_admin(pool, user_id, community_id).await?;
+    Ok(vec![community_id])
+  } else {
+    let ids = blocking(pool, move |conn: &'_ _| {
+      CommunityModerator::get_user_moderated_communities(conn, user_id)
+    })
+    .await??;
+    Ok(ids)
   }
-  // Otherwise, there's no auth
-  else {
+}
+
+pub(crate) fn check_optional_url(item: &Option<Option<String>>) -> Result<(), LemmyError> {
+  if let Some(Some(item)) = &item {
+    if Url::parse(item).is_err() {
+      return Err(APIError::err("invalid_url").into());
+    }
+  }
+  Ok(())
+}
+
+pub(crate) async fn build_federated_instances(
+  pool: &DbPool,
+) -> Result<Option<FederatedInstances>, LemmyError> {
+  if Settings::get().federation.enabled {
+    let distinct_communities = blocking(pool, move |conn| {
+      Community::distinct_federated_communities(conn)
+    })
+    .await??;
+
+    let allowed = Settings::get().get_allowed_instances();
+    let blocked = Settings::get().get_blocked_instances();
+
+    let mut linked = distinct_communities
+      .iter()
+      .map(|actor_id| Ok(Url::parse(actor_id)?.host_str().unwrap_or("").to_string()))
+      .collect::<Result<Vec<String>, LemmyError>>()?;
+
+    linked.extend_from_slice(&allowed);
+    linked.retain(|a| !blocked.contains(a) && !a.eq("") && !a.eq(&Settings::get().hostname));
+
+    // Sort and remove dupes
+    linked.sort_unstable();
+    linked.dedup();
+
+    Ok(Some(FederatedInstances {
+      linked,
+      allowed,
+      blocked,
+    }))
+  } else {
     Ok(None)
   }
 }
 
-pub(crate) fn check_totp_2fa_valid(
-  local_user_view: &LocalUserView,
-  totp_token: &Option<String>,
-  site_name: &str,
-) -> LemmyResult<()> {
-  // Throw an error if their token is missing
-  let token = totp_token
-    .as_deref()
-    .ok_or(LemmyErrorType::MissingTotpToken)?;
-  let secret = local_user_view
-    .local_user
-    .totp_2fa_secret
-    .as_deref()
-    .ok_or(LemmyErrorType::MissingTotpSecret)?;
+pub async fn match_websocket_operation(
+  context: LemmyContext,
+  id: ConnectionId,
+  op: UserOperation,
+  data: &str,
+) -> Result<String, LemmyError> {
+  match op {
+    // User ops
+    UserOperation::Login => do_websocket_operation::<Login>(context, id, op, data).await,
+    UserOperation::Register => do_websocket_operation::<Register>(context, id, op, data).await,
+    UserOperation::GetCaptcha => do_websocket_operation::<GetCaptcha>(context, id, op, data).await,
+    UserOperation::GetUserDetails => {
+      do_websocket_operation::<GetUserDetails>(context, id, op, data).await
+    }
+    UserOperation::GetReplies => do_websocket_operation::<GetReplies>(context, id, op, data).await,
+    UserOperation::AddAdmin => do_websocket_operation::<AddAdmin>(context, id, op, data).await,
+    UserOperation::BanUser => do_websocket_operation::<BanUser>(context, id, op, data).await,
+    UserOperation::GetUserMentions => {
+      do_websocket_operation::<GetUserMentions>(context, id, op, data).await
+    }
+    UserOperation::MarkUserMentionAsRead => {
+      do_websocket_operation::<MarkUserMentionAsRead>(context, id, op, data).await
+    }
+    UserOperation::MarkAllAsRead => {
+      do_websocket_operation::<MarkAllAsRead>(context, id, op, data).await
+    }
+    UserOperation::DeleteAccount => {
+      do_websocket_operation::<DeleteAccount>(context, id, op, data).await
+    }
+    UserOperation::PasswordReset => {
+      do_websocket_operation::<PasswordReset>(context, id, op, data).await
+    }
+    UserOperation::PasswordChange => {
+      do_websocket_operation::<PasswordChange>(context, id, op, data).await
+    }
+    UserOperation::UserJoin => do_websocket_operation::<UserJoin>(context, id, op, data).await,
+    UserOperation::PostJoin => do_websocket_operation::<PostJoin>(context, id, op, data).await,
+    UserOperation::CommunityJoin => {
+      do_websocket_operation::<CommunityJoin>(context, id, op, data).await
+    }
+    UserOperation::ModJoin => do_websocket_operation::<ModJoin>(context, id, op, data).await,
+    UserOperation::SaveUserSettings => {
+      do_websocket_operation::<SaveUserSettings>(context, id, op, data).await
+    }
+    UserOperation::GetReportCount => {
+      do_websocket_operation::<GetReportCount>(context, id, op, data).await
+    }
 
-  let totp = build_totp_2fa(site_name, &local_user_view.person.name, secret)?;
+    // Private Message ops
+    UserOperation::CreatePrivateMessage => {
+      do_websocket_operation::<CreatePrivateMessage>(context, id, op, data).await
+    }
+    UserOperation::EditPrivateMessage => {
+      do_websocket_operation::<EditPrivateMessage>(context, id, op, data).await
+    }
+    UserOperation::DeletePrivateMessage => {
+      do_websocket_operation::<DeletePrivateMessage>(context, id, op, data).await
+    }
+    UserOperation::MarkPrivateMessageAsRead => {
+      do_websocket_operation::<MarkPrivateMessageAsRead>(context, id, op, data).await
+    }
+    UserOperation::GetPrivateMessages => {
+      do_websocket_operation::<GetPrivateMessages>(context, id, op, data).await
+    }
 
-  let check_passed = totp.check_current(token)?;
-  if !check_passed {
-    return Err(LemmyErrorType::IncorrectTotpToken.into());
-  }
+    // Site ops
+    UserOperation::GetModlog => do_websocket_operation::<GetModlog>(context, id, op, data).await,
+    UserOperation::CreateSite => do_websocket_operation::<CreateSite>(context, id, op, data).await,
+    UserOperation::EditSite => do_websocket_operation::<EditSite>(context, id, op, data).await,
+    UserOperation::GetSite => do_websocket_operation::<GetSite>(context, id, op, data).await,
+    UserOperation::GetSiteConfig => {
+      do_websocket_operation::<GetSiteConfig>(context, id, op, data).await
+    }
+    UserOperation::SaveSiteConfig => {
+      do_websocket_operation::<SaveSiteConfig>(context, id, op, data).await
+    }
+    UserOperation::Search => do_websocket_operation::<Search>(context, id, op, data).await,
+    UserOperation::TransferCommunity => {
+      do_websocket_operation::<TransferCommunity>(context, id, op, data).await
+    }
+    UserOperation::TransferSite => {
+      do_websocket_operation::<TransferSite>(context, id, op, data).await
+    }
+    UserOperation::ListCategories => {
+      do_websocket_operation::<ListCategories>(context, id, op, data).await
+    }
 
-  Ok(())
-}
+    // Community ops
+    UserOperation::GetCommunity => {
+      do_websocket_operation::<GetCommunity>(context, id, op, data).await
+    }
+    UserOperation::ListCommunities => {
+      do_websocket_operation::<ListCommunities>(context, id, op, data).await
+    }
+    UserOperation::CreateCommunity => {
+      do_websocket_operation::<CreateCommunity>(context, id, op, data).await
+    }
+    UserOperation::EditCommunity => {
+      do_websocket_operation::<EditCommunity>(context, id, op, data).await
+    }
+    UserOperation::DeleteCommunity => {
+      do_websocket_operation::<DeleteCommunity>(context, id, op, data).await
+    }
+    UserOperation::RemoveCommunity => {
+      do_websocket_operation::<RemoveCommunity>(context, id, op, data).await
+    }
+    UserOperation::FollowCommunity => {
+      do_websocket_operation::<FollowCommunity>(context, id, op, data).await
+    }
+    UserOperation::GetFollowedCommunities => {
+      do_websocket_operation::<GetFollowedCommunities>(context, id, op, data).await
+    }
+    UserOperation::BanFromCommunity => {
+      do_websocket_operation::<BanFromCommunity>(context, id, op, data).await
+    }
+    UserOperation::AddModToCommunity => {
+      do_websocket_operation::<AddModToCommunity>(context, id, op, data).await
+    }
 
-pub(crate) fn generate_totp_2fa_secret() -> String {
-  Secret::generate_secret().to_string()
-}
+    // Post ops
+    UserOperation::CreatePost => do_websocket_operation::<CreatePost>(context, id, op, data).await,
+    UserOperation::GetPost => do_websocket_operation::<GetPost>(context, id, op, data).await,
+    UserOperation::GetPosts => do_websocket_operation::<GetPosts>(context, id, op, data).await,
+    UserOperation::EditPost => do_websocket_operation::<EditPost>(context, id, op, data).await,
+    UserOperation::DeletePost => do_websocket_operation::<DeletePost>(context, id, op, data).await,
+    UserOperation::RemovePost => do_websocket_operation::<RemovePost>(context, id, op, data).await,
+    UserOperation::LockPost => do_websocket_operation::<LockPost>(context, id, op, data).await,
+    UserOperation::StickyPost => do_websocket_operation::<StickyPost>(context, id, op, data).await,
+    UserOperation::CreatePostLike => {
+      do_websocket_operation::<CreatePostLike>(context, id, op, data).await
+    }
+    UserOperation::SavePost => do_websocket_operation::<SavePost>(context, id, op, data).await,
+    UserOperation::CreatePostReport => {
+      do_websocket_operation::<CreatePostReport>(context, id, op, data).await
+    }
+    UserOperation::ListPostReports => {
+      do_websocket_operation::<ListPostReports>(context, id, op, data).await
+    }
+    UserOperation::ResolvePostReport => {
+      do_websocket_operation::<ResolvePostReport>(context, id, op, data).await
+    }
 
-fn build_totp_2fa(hostname: &str, username: &str, secret: &str) -> LemmyResult<TOTP> {
-  let sec = Secret::Raw(secret.as_bytes().to_vec());
-  let sec_bytes = sec
-    .to_bytes()
-    .map_err(|_| LemmyErrorType::CouldntParseTotpSecret)?;
-
-  TOTP::new(
-    totp_rs::Algorithm::SHA1,
-    6,
-    1,
-    30,
-    sec_bytes,
-    Some(hostname.to_string()),
-    username.to_string(),
-  )
-  .with_lemmy_type(LemmyErrorType::CouldntGenerateTotp)
-}
-
-/// Site bans are only federated for local users.
-/// This is a problem, because site-banning non-local users will still leave content
-/// they've posted to our local communities, on other servers.
-///
-/// So when doing a site ban for a non-local user, you need to federate/send a
-/// community ban for every local community they've participated in.
-/// See https://github.com/LemmyNet/lemmy/issues/4118
-#[tracing::instrument(skip_all)]
-pub(crate) async fn ban_nonlocal_user_from_local_communities(
-  local_user_view: &LocalUserView,
-  target: &Person,
-  ban: bool,
-  reason: &Option<String>,
-  remove_data: &Option<bool>,
-  expires: &Option<i64>,
-  context: &Data<LemmyContext>,
-) -> LemmyResult<()> {
-  // Only run this code for federated users
-  if !target.local {
-    let ids = Person::list_local_community_ids(&mut context.pool(), target.id).await?;
-
-    for community_id in ids {
-      let expires_dt = check_expire_time(*expires)?;
-
-      // Ban / unban them from our local communities
-      let community_user_ban_form = CommunityPersonBanForm {
-        community_id,
-        person_id: target.id,
-        expires: Some(expires_dt),
-      };
-
-      if ban {
-        // Ignore all errors for these
-        CommunityPersonBan::ban(&mut context.pool(), &community_user_ban_form)
-          .await
-          .ok();
-
-        // Also unsubscribe them from the community, if they are subscribed
-        let community_follower_form = CommunityFollowerForm {
-          community_id,
-          person_id: target.id,
-          pending: false,
-        };
-
-        CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
-          .await
-          .ok();
-      } else {
-        CommunityPersonBan::unban(&mut context.pool(), &community_user_ban_form)
-          .await
-          .ok();
-      }
-
-      // Mod tables
-      let form = ModBanFromCommunityForm {
-        mod_person_id: local_user_view.person.id,
-        other_person_id: target.id,
-        community_id,
-        reason: reason.clone(),
-        banned: Some(ban),
-        expires: expires_dt,
-      };
-
-      ModBanFromCommunity::create(&mut context.pool(), &form).await?;
-
-      // Federate the ban from community
-      let ban_from_community = BanFromCommunity {
-        community_id,
-        person_id: target.id,
-        ban,
-        reason: reason.clone(),
-        remove_data: *remove_data,
-        expires: *expires,
-      };
-
-      ActivityChannel::submit_activity(
-        SendActivityData::BanFromCommunity {
-          moderator: local_user_view.person.clone(),
-          community_id,
-          target: target.clone(),
-          data: ban_from_community,
-        },
-        context,
-      )
-      .await?;
+    // Comment ops
+    UserOperation::CreateComment => {
+      do_websocket_operation::<CreateComment>(context, id, op, data).await
+    }
+    UserOperation::EditComment => {
+      do_websocket_operation::<EditComment>(context, id, op, data).await
+    }
+    UserOperation::DeleteComment => {
+      do_websocket_operation::<DeleteComment>(context, id, op, data).await
+    }
+    UserOperation::RemoveComment => {
+      do_websocket_operation::<RemoveComment>(context, id, op, data).await
+    }
+    UserOperation::MarkCommentAsRead => {
+      do_websocket_operation::<MarkCommentAsRead>(context, id, op, data).await
+    }
+    UserOperation::SaveComment => {
+      do_websocket_operation::<SaveComment>(context, id, op, data).await
+    }
+    UserOperation::GetComments => {
+      do_websocket_operation::<GetComments>(context, id, op, data).await
+    }
+    UserOperation::CreateCommentLike => {
+      do_websocket_operation::<CreateCommentLike>(context, id, op, data).await
+    }
+    UserOperation::CreateCommentReport => {
+      do_websocket_operation::<CreateCommentReport>(context, id, op, data).await
+    }
+    UserOperation::ListCommentReports => {
+      do_websocket_operation::<ListCommentReports>(context, id, op, data).await
+    }
+    UserOperation::ResolveCommentReport => {
+      do_websocket_operation::<ResolveCommentReport>(context, id, op, data).await
     }
   }
-
-  Ok(())
 }
 
-#[tracing::instrument(skip_all)]
-pub async fn local_user_view_from_jwt(
-  jwt: &str,
-  context: &LemmyContext,
-) -> LemmyResult<LocalUserView> {
-  let local_user_id = Claims::validate(jwt, context)
-    .await
-    .with_lemmy_type(LemmyErrorType::NotLoggedIn)?;
-  let local_user_view = LocalUserView::read(&mut context.pool(), local_user_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindLocalUser)?;
-  check_user_valid(&local_user_view.person)?;
+async fn do_websocket_operation<'a, 'b, Data>(
+  context: LemmyContext,
+  id: ConnectionId,
+  op: UserOperation,
+  data: &str,
+) -> Result<String, LemmyError>
+where
+  for<'de> Data: Deserialize<'de> + 'a,
+  Data: Perform,
+{
+  let parsed_data: Data = serde_json::from_str(&data)?;
+  let res = parsed_data
+    .perform(&web::Data::new(context), Some(id))
+    .await?;
+  serialize_websocket_message(&op, &res)
+}
 
-  Ok(local_user_view)
+pub(crate) fn captcha_espeak_wav_base64(captcha: &str) -> Result<String, LemmyError> {
+  let mut built_text = String::new();
+
+  // Building proper speech text for espeak
+  for mut c in captcha.chars() {
+    let new_str = if c.is_alphabetic() {
+      if c.is_lowercase() {
+        c.make_ascii_uppercase();
+        format!("lower case {} ... ", c)
+      } else {
+        c.make_ascii_uppercase();
+        format!("capital {} ... ", c)
+      }
+    } else {
+      format!("{} ...", c)
+    };
+
+    built_text.push_str(&new_str);
+  }
+
+  espeak_wav_base64(&built_text)
+}
+
+pub(crate) fn espeak_wav_base64(text: &str) -> Result<String, LemmyError> {
+  // Make a temp file path
+  let uuid = uuid::Uuid::new_v4().to_string();
+  let file_path = format!("/tmp/lemmy_espeak_{}.wav", &uuid);
+
+  // Write the wav file
+  Command::new("espeak")
+    .arg("-w")
+    .arg(&file_path)
+    .arg(text)
+    .status()?;
+
+  // Read the wav file bytes
+  let bytes = std::fs::read(&file_path)?;
+
+  // Delete the file
+  std::fs::remove_file(file_path)?;
+
+  // Convert to base64
+  let base64 = base64::encode(bytes);
+
+  Ok(base64)
 }
 
 #[cfg(test)]
-#[allow(clippy::unwrap_used)]
-#[allow(clippy::indexing_slicing)]
 mod tests {
-
-  use super::*;
+  use crate::captcha_espeak_wav_base64;
 
   #[test]
-  fn test_build_totp() {
-    let generated_secret = generate_totp_2fa_secret();
-    let totp = build_totp_2fa("lemmy.ml", "my_name", &generated_secret);
-    assert!(totp.is_ok());
+  fn test_espeak() {
+    assert!(captcha_espeak_wav_base64("WxRt2l").is_ok())
   }
 }

crates/api/src/local_user/add_admin.rs

@@ -1,55 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{AddAdmin, AddAdminResponse},
-  utils::is_admin,
-};
-use lemmy_db_schema::{
-  source::{
-    local_user::{LocalUser, LocalUserUpdateForm},
-    moderator::{ModAdd, ModAddForm},
-  },
-  traits::Crud,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::PersonView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn add_admin(
-  data: Json<AddAdmin>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<AddAdminResponse>> {
-  // Make sure user is an admin
-  is_admin(&local_user_view)?;
-
-  // Make sure that the person_id added is local
-  let added_local_user = LocalUserView::read_person(&mut context.pool(), data.person_id)
-    .await?
-    .ok_or(LemmyErrorType::ObjectNotLocal)?;
-
-  LocalUser::update(
-    &mut context.pool(),
-    added_local_user.local_user.id,
-    &LocalUserUpdateForm {
-      admin: Some(data.added),
-      ..Default::default()
-    },
-  )
-  .await
-  .with_lemmy_type(LemmyErrorType::CouldntUpdateUser)?;
-
-  // Mod tables
-  let form = ModAddForm {
-    mod_person_id: local_user_view.person.id,
-    other_person_id: added_local_user.person.id,
-    removed: Some(!data.added),
-  };
-
-  ModAdd::create(&mut context.pool(), &form).await?;
-
-  let admins = PersonView::admins(&mut context.pool()).await?;
-
-  Ok(Json(AddAdminResponse { admins }))
-}

crates/api/src/local_user/ban_person.rs

@@ -1,105 +0,0 @@
-use crate::ban_nonlocal_user_from_local_communities;
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{BanPerson, BanPersonResponse},
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::{check_expire_time, is_admin, remove_user_data},
-};
-use lemmy_db_schema::{
-  source::{
-    login_token::LoginToken,
-    moderator::{ModBan, ModBanForm},
-    person::{Person, PersonUpdateForm},
-  },
-  traits::Crud,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::PersonView;
-use lemmy_utils::{
-  error::{LemmyErrorExt, LemmyErrorType, LemmyResult},
-  utils::validation::is_valid_body_field,
-};
-
-#[tracing::instrument(skip(context))]
-pub async fn ban_from_site(
-  data: Json<BanPerson>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<BanPersonResponse>> {
-  // Make sure user is an admin
-  is_admin(&local_user_view)?;
-
-  is_valid_body_field(&data.reason, false)?;
-
-  let expires = check_expire_time(data.expires)?;
-
-  let person = Person::update(
-    &mut context.pool(),
-    data.person_id,
-    &PersonUpdateForm {
-      banned: Some(data.ban),
-      ban_expires: Some(expires),
-      ..Default::default()
-    },
-  )
-  .await
-  .with_lemmy_type(LemmyErrorType::CouldntUpdateUser)?;
-
-  // if its a local user, invalidate logins
-  let local_user = LocalUserView::read_person(&mut context.pool(), person.id).await;
-  if let Ok(Some(local_user)) = local_user {
-    LoginToken::invalidate_all(&mut context.pool(), local_user.local_user.id).await?;
-  }
-
-  // Remove their data if that's desired
-  let remove_data = data.remove_data.unwrap_or(false);
-  if remove_data {
-    remove_user_data(person.id, &context).await?;
-  }
-
-  // Mod tables
-  let form = ModBanForm {
-    mod_person_id: local_user_view.person.id,
-    other_person_id: person.id,
-    reason: data.reason.clone(),
-    banned: Some(data.ban),
-    expires,
-  };
-
-  ModBan::create(&mut context.pool(), &form).await?;
-
-  let person_view = PersonView::read(&mut context.pool(), person.id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindPerson)?;
-
-  ban_nonlocal_user_from_local_communities(
-    &local_user_view,
-    &person,
-    data.ban,
-    &data.reason,
-    &data.remove_data,
-    &data.expires,
-    &context,
-  )
-  .await?;
-
-  ActivityChannel::submit_activity(
-    SendActivityData::BanFromSite {
-      moderator: local_user_view.person,
-      banned_user: person_view.person.clone(),
-      reason: data.reason.clone(),
-      remove_data: data.remove_data,
-      ban: data.ban,
-      expires: data.expires,
-    },
-    &context,
-  )
-  .await?;
-
-  Ok(Json(BanPersonResponse {
-    person_view,
-    banned: data.ban,
-  }))
-}

crates/api/src/local_user/block.rs

@@ -1,59 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{BlockPerson, BlockPersonResponse},
-};
-use lemmy_db_schema::{
-  source::person_block::{PersonBlock, PersonBlockForm},
-  traits::Blockable,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::PersonView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn block_person(
-  data: Json<BlockPerson>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<BlockPersonResponse>> {
-  let target_id = data.person_id;
-  let person_id = local_user_view.person.id;
-
-  // Don't let a person block themselves
-  if target_id == person_id {
-    Err(LemmyErrorType::CantBlockYourself)?
-  }
-
-  let person_block_form = PersonBlockForm {
-    person_id,
-    target_id,
-  };
-
-  let target_user = LocalUserView::read_person(&mut context.pool(), target_id)
-    .await
-    .ok()
-    .flatten();
-
-  if target_user.is_some_and(|t| t.local_user.admin) {
-    Err(LemmyErrorType::CantBlockAdmin)?
-  }
-
-  if data.block {
-    PersonBlock::block(&mut context.pool(), &person_block_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::PersonBlockAlreadyExists)?;
-  } else {
-    PersonBlock::unblock(&mut context.pool(), &person_block_form)
-      .await
-      .with_lemmy_type(LemmyErrorType::PersonBlockAlreadyExists)?;
-  }
-
-  let person_view = PersonView::read(&mut context.pool(), target_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindPerson)?;
-  Ok(Json(BlockPersonResponse {
-    person_view,
-    blocked: data.block,
-  }))
-}

crates/api/src/local_user/change_password.rs

@@ -1,53 +0,0 @@
-use actix_web::{
-  web::{Data, Json},
-  HttpRequest,
-};
-use bcrypt::verify;
-use lemmy_api_common::{
-  claims::Claims,
-  context::LemmyContext,
-  person::{ChangePassword, LoginResponse},
-  utils::password_length_check,
-};
-use lemmy_db_schema::source::{local_user::LocalUser, login_token::LoginToken};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::error::{LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn change_password(
-  data: Json<ChangePassword>,
-  req: HttpRequest,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<LoginResponse>> {
-  password_length_check(&data.new_password)?;
-
-  // Make sure passwords match
-  if data.new_password != data.new_password_verify {
-    Err(LemmyErrorType::PasswordsDoNotMatch)?
-  }
-
-  // Check the old password
-  let valid: bool = verify(
-    &data.old_password,
-    &local_user_view.local_user.password_encrypted,
-  )
-  .unwrap_or(false);
-  if !valid {
-    Err(LemmyErrorType::IncorrectLogin)?
-  }
-
-  let local_user_id = local_user_view.local_user.id;
-  let new_password = data.new_password.clone();
-  let updated_local_user =
-    LocalUser::update_password(&mut context.pool(), local_user_id, &new_password).await?;
-
-  LoginToken::invalidate_all(&mut context.pool(), local_user_view.local_user.id).await?;
-
-  // Return the jwt
-  Ok(Json(LoginResponse {
-    jwt: Some(Claims::generate(updated_local_user.id, req, &context).await?),
-    verify_email_sent: false,
-    registration_created: false,
-  }))
-}

crates/api/src/local_user/change_password_after_reset.rs

@@ -1,43 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::PasswordChangeAfterReset,
-  utils::password_length_check,
-  SuccessResponse,
-};
-use lemmy_db_schema::source::{
-  local_user::LocalUser,
-  login_token::LoginToken,
-  password_reset_request::PasswordResetRequest,
-};
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn change_password_after_reset(
-  data: Json<PasswordChangeAfterReset>,
-  context: Data<LemmyContext>,
-) -> LemmyResult<Json<SuccessResponse>> {
-  // Fetch the user_id from the token
-  let token = data.token.clone();
-  let local_user_id = PasswordResetRequest::read_and_delete(&mut context.pool(), &token)
-    .await?
-    .ok_or(LemmyErrorType::TokenNotFound)?
-    .local_user_id;
-
-  password_length_check(&data.password)?;
-
-  // Make sure passwords match
-  if data.password != data.password_verify {
-    Err(LemmyErrorType::PasswordsDoNotMatch)?
-  }
-
-  // Update the user with the new password
-  let password = data.password.clone();
-  LocalUser::update_password(&mut context.pool(), local_user_id, &password)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntUpdateUser)?;
-
-  LoginToken::invalidate_all(&mut context.pool(), local_user_id).await?;
-
-  Ok(Json(SuccessResponse::default()))
-}

crates/api/src/local_user/generate_totp_secret.rs

@@ -1,42 +0,0 @@
-use crate::{build_totp_2fa, generate_totp_2fa_secret};
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{context::LemmyContext, person::GenerateTotpSecretResponse};
-use lemmy_db_schema::source::local_user::{LocalUser, LocalUserUpdateForm};
-use lemmy_db_views::structs::{LocalUserView, SiteView};
-use lemmy_utils::error::{LemmyErrorType, LemmyResult};
-
-/// Generate a new secret for two-factor-authentication. Afterwards you need to call [toggle_totp]
-/// to enable it. This can only be called if 2FA is currently disabled.
-#[tracing::instrument(skip(context))]
-pub async fn generate_totp_secret(
-  local_user_view: LocalUserView,
-  context: Data<LemmyContext>,
-) -> LemmyResult<Json<GenerateTotpSecretResponse>> {
-  let site_view = SiteView::read_local(&mut context.pool())
-    .await?
-    .ok_or(LemmyErrorType::LocalSiteNotSetup)?;
-
-  if local_user_view.local_user.totp_2fa_enabled {
-    return Err(LemmyErrorType::TotpAlreadyEnabled)?;
-  }
-
-  let secret = generate_totp_2fa_secret();
-  let secret_url =
-    build_totp_2fa(&site_view.site.name, &local_user_view.person.name, &secret)?.get_url();
-
-  let local_user_form = LocalUserUpdateForm {
-    totp_2fa_secret: Some(Some(secret)),
-    ..Default::default()
-  };
-  LocalUser::update(
-    &mut context.pool(),
-    local_user_view.local_user.id,
-    &local_user_form,
-  )
-  .await?;
-
-  Ok(Json(GenerateTotpSecretResponse {
-    totp_secret_url: secret_url.into(),
-  }))
-}

crates/api/src/local_user/get_captcha.rs

@@ -1,56 +0,0 @@
-use crate::captcha_as_wav_base64;
-use actix_web::{
-  http::{
-    header::{CacheControl, CacheDirective},
-    StatusCode,
-  },
-  web::{Data, Json},
-  HttpResponse,
-  HttpResponseBuilder,
-};
-use captcha::{gen, Difficulty};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{CaptchaResponse, GetCaptchaResponse},
-};
-use lemmy_db_schema::source::{
-  captcha_answer::{CaptchaAnswer, CaptchaAnswerForm},
-  local_site::LocalSite,
-};
-use lemmy_utils::error::LemmyResult;
-
-#[tracing::instrument(skip(context))]
-pub async fn get_captcha(context: Data<LemmyContext>) -> LemmyResult<HttpResponse> {
-  let local_site = LocalSite::read(&mut context.pool()).await?;
-  let mut res = HttpResponseBuilder::new(StatusCode::OK);
-  res.insert_header(CacheControl(vec![CacheDirective::NoStore]));
-
-  if !local_site.captcha_enabled {
-    return Ok(res.json(Json(GetCaptchaResponse { ok: None })));
-  }
-
-  let captcha = gen(match local_site.captcha_difficulty.as_str() {
-    "easy" => Difficulty::Easy,
-    "hard" => Difficulty::Hard,
-    _ => Difficulty::Medium,
-  });
-
-  let answer = captcha.chars_as_string();
-
-  let png = captcha.as_base64().expect("failed to generate captcha");
-
-  let wav = captcha_as_wav_base64(&captcha)?;
-
-  let captcha_form: CaptchaAnswerForm = CaptchaAnswerForm { answer };
-  // Stores the captcha item in the db
-  let captcha = CaptchaAnswer::insert(&mut context.pool(), &captcha_form).await?;
-
-  let json = Json(GetCaptchaResponse {
-    ok: Some(CaptchaResponse {
-      png,
-      wav,
-      uuid: captcha.uuid.to_string(),
-    }),
-  });
-  Ok(res.json(json))
-}

crates/api/src/local_user/list_banned.rs

@@ -1,17 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{context::LemmyContext, person::BannedPersonsResponse, utils::is_admin};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::PersonView;
-use lemmy_utils::error::LemmyResult;
-
-pub async fn list_banned_users(
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<BannedPersonsResponse>> {
-  // Make sure user is an admin
-  is_admin(&local_user_view)?;
-
-  let banned = PersonView::banned(&mut context.pool()).await?;
-
-  Ok(Json(BannedPersonsResponse { banned }))
-}

crates/api/src/local_user/list_logins.rs

@@ -1,14 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::context::LemmyContext;
-use lemmy_db_schema::source::login_token::LoginToken;
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::error::LemmyResult;
-
-pub async fn list_logins(
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<Vec<LoginToken>>> {
-  let logins = LoginToken::list(&mut context.pool(), local_user_view.local_user.id).await?;
-
-  Ok(Json(logins))
-}

crates/api/src/local_user/list_media.rs

@@ -1,25 +0,0 @@
-use actix_web::web::{Data, Json, Query};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{ListMedia, ListMediaResponse},
-};
-use lemmy_db_views::structs::{LocalImageView, LocalUserView};
-use lemmy_utils::error::LemmyResult;
-
-#[tracing::instrument(skip(context))]
-pub async fn list_media(
-  data: Query<ListMedia>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<ListMediaResponse>> {
-  let page = data.page;
-  let limit = data.limit;
-  let images = LocalImageView::get_all_paged_by_local_user_id(
-    &mut context.pool(),
-    local_user_view.local_user.id,
-    page,
-    limit,
-  )
-  .await?;
-  Ok(Json(ListMediaResponse { images }))
-}

crates/api/src/local_user/login.rs

@@ -1,94 +0,0 @@
-use crate::{check_totp_2fa_valid, local_user::check_email_verified};
-use actix_web::{
-  web::{Data, Json},
-  HttpRequest,
-};
-use bcrypt::verify;
-use lemmy_api_common::{
-  claims::Claims,
-  context::LemmyContext,
-  person::{Login, LoginResponse},
-  utils::check_user_valid,
-};
-use lemmy_db_schema::{
-  source::{local_site::LocalSite, registration_application::RegistrationApplication},
-  utils::DbPool,
-  RegistrationMode,
-};
-use lemmy_db_views::structs::{LocalUserView, SiteView};
-use lemmy_utils::error::{LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn login(
-  data: Json<Login>,
-  req: HttpRequest,
-  context: Data<LemmyContext>,
-) -> LemmyResult<Json<LoginResponse>> {
-  let site_view = SiteView::read_local(&mut context.pool())
-    .await?
-    .ok_or(LemmyErrorType::LocalSiteNotSetup)?;
-
-  // Fetch that username / email
-  let username_or_email = data.username_or_email.clone();
-  let local_user_view =
-    LocalUserView::find_by_email_or_name(&mut context.pool(), &username_or_email)
-      .await?
-      .ok_or(LemmyErrorType::IncorrectLogin)?;
-
-  // Verify the password
-  let valid: bool = verify(
-    &data.password,
-    &local_user_view.local_user.password_encrypted,
-  )
-  .unwrap_or(false);
-  if !valid {
-    Err(LemmyErrorType::IncorrectLogin)?
-  }
-  check_user_valid(&local_user_view.person)?;
-  check_email_verified(&local_user_view, &site_view)?;
-
-  check_registration_application(&local_user_view, &site_view.local_site, &mut context.pool())
-    .await?;
-
-  // Check the totp if enabled
-  if local_user_view.local_user.totp_2fa_enabled {
-    check_totp_2fa_valid(
-      &local_user_view,
-      &data.totp_2fa_token,
-      &context.settings().hostname,
-    )?;
-  }
-
-  let jwt = Claims::generate(local_user_view.local_user.id, req, &context).await?;
-
-  Ok(Json(LoginResponse {
-    jwt: Some(jwt.clone()),
-    verify_email_sent: false,
-    registration_created: false,
-  }))
-}
-
-async fn check_registration_application(
-  local_user_view: &LocalUserView,
-  local_site: &LocalSite,
-  pool: &mut DbPool<'_>,
-) -> LemmyResult<()> {
-  if (local_site.registration_mode == RegistrationMode::RequireApplication
-    || local_site.registration_mode == RegistrationMode::Closed)
-    && !local_user_view.local_user.accepted_application
-    && !local_user_view.local_user.admin
-  {
-    // Fetch the registration application. If no admin id is present its still pending. Otherwise it
-    // was processed (either accepted or denied).
-    let local_user_id = local_user_view.local_user.id;
-    let registration = RegistrationApplication::find_by_local_user_id(pool, local_user_id)
-      .await?
-      .ok_or(LemmyErrorType::CouldntFindRegistrationApplication)?;
-    if registration.admin_id.is_some() {
-      Err(LemmyErrorType::RegistrationDenied(registration.deny_reason))?
-    } else {
-      Err(LemmyErrorType::RegistrationApplicationIsPending)?
-    }
-  }
-  Ok(())
-}

crates/api/src/local_user/logout.rs

@@ -1,23 +0,0 @@
-use crate::read_auth_token;
-use activitypub_federation::config::Data;
-use actix_web::{cookie::Cookie, HttpRequest, HttpResponse};
-use lemmy_api_common::{context::LemmyContext, utils::AUTH_COOKIE_NAME, SuccessResponse};
-use lemmy_db_schema::source::login_token::LoginToken;
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::error::{LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn logout(
-  req: HttpRequest,
-  // require login
-  _local_user_view: LocalUserView,
-  context: Data<LemmyContext>,
-) -> LemmyResult<HttpResponse> {
-  let jwt = read_auth_token(&req)?.ok_or(LemmyErrorType::NotLoggedIn)?;
-  LoginToken::invalidate(&mut context.pool(), &jwt).await?;
-
-  let mut res = HttpResponse::Ok().json(SuccessResponse::default());
-  let cookie = Cookie::new(AUTH_COOKIE_NAME, "");
-  res.add_removal_cookie(&cookie)?;
-  Ok(res)
-}

crates/api/src/local_user/mod.rs

@@ -1,34 +0,0 @@
-use lemmy_db_views::structs::{LocalUserView, SiteView};
-use lemmy_utils::{error::LemmyResult, LemmyErrorType};
-
-pub mod add_admin;
-pub mod ban_person;
-pub mod block;
-pub mod change_password;
-pub mod change_password_after_reset;
-pub mod generate_totp_secret;
-pub mod get_captcha;
-pub mod list_banned;
-pub mod list_logins;
-pub mod list_media;
-pub mod login;
-pub mod logout;
-pub mod notifications;
-pub mod report_count;
-pub mod reset_password;
-pub mod save_settings;
-pub mod update_totp;
-pub mod validate_auth;
-pub mod verify_email;
-
-/// Check if the user's email is verified if email verification is turned on
-/// However, skip checking verification if the user is an admin
-fn check_email_verified(local_user_view: &LocalUserView, site_view: &SiteView) -> LemmyResult<()> {
-  if !local_user_view.local_user.admin
-    && site_view.local_site.require_email_verification
-    && !local_user_view.local_user.email_verified
-  {
-    Err(LemmyErrorType::EmailNotVerified)?
-  }
-  Ok(())
-}

crates/api/src/local_user/notifications/list_mentions.rs

@@ -1,36 +0,0 @@
-use actix_web::web::{Data, Json, Query};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{GetPersonMentions, GetPersonMentionsResponse},
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::person_mention_view::PersonMentionQuery;
-use lemmy_utils::error::LemmyResult;
-
-#[tracing::instrument(skip(context))]
-pub async fn list_mentions(
-  data: Query<GetPersonMentions>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<GetPersonMentionsResponse>> {
-  let sort = data.sort;
-  let page = data.page;
-  let limit = data.limit;
-  let unread_only = data.unread_only.unwrap_or_default();
-  let person_id = Some(local_user_view.person.id);
-  let show_bot_accounts = local_user_view.local_user.show_bot_accounts;
-
-  let mentions = PersonMentionQuery {
-    recipient_id: person_id,
-    my_person_id: person_id,
-    sort,
-    unread_only,
-    show_bot_accounts,
-    page,
-    limit,
-  }
-  .list(&mut context.pool())
-  .await?;
-
-  Ok(Json(GetPersonMentionsResponse { mentions }))
-}

crates/api/src/local_user/notifications/list_replies.rs

@@ -1,36 +0,0 @@
-use actix_web::web::{Data, Json, Query};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{GetReplies, GetRepliesResponse},
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::comment_reply_view::CommentReplyQuery;
-use lemmy_utils::error::LemmyResult;
-
-#[tracing::instrument(skip(context))]
-pub async fn list_replies(
-  data: Query<GetReplies>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<GetRepliesResponse>> {
-  let sort = data.sort;
-  let page = data.page;
-  let limit = data.limit;
-  let unread_only = data.unread_only.unwrap_or_default();
-  let person_id = Some(local_user_view.person.id);
-  let show_bot_accounts = local_user_view.local_user.show_bot_accounts;
-
-  let replies = CommentReplyQuery {
-    recipient_id: person_id,
-    my_person_id: person_id,
-    sort,
-    unread_only,
-    show_bot_accounts,
-    page,
-    limit,
-  }
-  .list(&mut context.pool())
-  .await?;
-
-  Ok(Json(GetRepliesResponse { replies }))
-}

crates/api/src/local_user/notifications/mark_all_read.rs

@@ -1,34 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{context::LemmyContext, person::GetRepliesResponse};
-use lemmy_db_schema::source::{
-  comment_reply::CommentReply,
-  person_mention::PersonMention,
-  private_message::PrivateMessage,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn mark_all_notifications_read(
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<GetRepliesResponse>> {
-  let person_id = local_user_view.person.id;
-
-  // Mark all comment_replies as read
-  CommentReply::mark_all_as_read(&mut context.pool(), person_id)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?;
-
-  // Mark all user mentions as read
-  PersonMention::mark_all_as_read(&mut context.pool(), person_id)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?;
-
-  // Mark all private_messages as read
-  PrivateMessage::mark_all_as_read(&mut context.pool(), person_id)
-    .await
-    .with_lemmy_type(LemmyErrorType::CouldntUpdatePrivateMessage)?;
-
-  Ok(Json(GetRepliesResponse { replies: vec![] }))
-}

crates/api/src/local_user/notifications/mark_mention_read.rs

@@ -1,49 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{MarkPersonMentionAsRead, PersonMentionResponse},
-};
-use lemmy_db_schema::{
-  source::person_mention::{PersonMention, PersonMentionUpdateForm},
-  traits::Crud,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::PersonMentionView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn mark_person_mention_as_read(
-  data: Json<MarkPersonMentionAsRead>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<PersonMentionResponse>> {
-  let person_mention_id = data.person_mention_id;
-  let read_person_mention = PersonMention::read(&mut context.pool(), person_mention_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindPersonMention)?;
-
-  if local_user_view.person.id != read_person_mention.recipient_id {
-    Err(LemmyErrorType::CouldntUpdateComment)?
-  }
-
-  let person_mention_id = read_person_mention.id;
-  let read = Some(data.read);
-  PersonMention::update(
-    &mut context.pool(),
-    person_mention_id,
-    &PersonMentionUpdateForm { read },
-  )
-  .await
-  .with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?;
-
-  let person_mention_id = read_person_mention.id;
-  let person_id = local_user_view.person.id;
-  let person_mention_view =
-    PersonMentionView::read(&mut context.pool(), person_mention_id, Some(person_id))
-      .await?
-      .ok_or(LemmyErrorType::CouldntFindPersonMention)?;
-
-  Ok(Json(PersonMentionResponse {
-    person_mention_view,
-  }))
-}

crates/api/src/local_user/notifications/mark_reply_read.rs

@@ -1,48 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{CommentReplyResponse, MarkCommentReplyAsRead},
-};
-use lemmy_db_schema::{
-  source::comment_reply::{CommentReply, CommentReplyUpdateForm},
-  traits::Crud,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_db_views_actor::structs::CommentReplyView;
-use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn mark_reply_as_read(
-  data: Json<MarkCommentReplyAsRead>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<CommentReplyResponse>> {
-  let comment_reply_id = data.comment_reply_id;
-  let read_comment_reply = CommentReply::read(&mut context.pool(), comment_reply_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindCommentReply)?;
-
-  if local_user_view.person.id != read_comment_reply.recipient_id {
-    Err(LemmyErrorType::CouldntUpdateComment)?
-  }
-
-  let comment_reply_id = read_comment_reply.id;
-  let read = Some(data.read);
-
-  CommentReply::update(
-    &mut context.pool(),
-    comment_reply_id,
-    &CommentReplyUpdateForm { read },
-  )
-  .await
-  .with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?;
-
-  let comment_reply_id = read_comment_reply.id;
-  let person_id = local_user_view.person.id;
-  let comment_reply_view =
-    CommentReplyView::read(&mut context.pool(), comment_reply_id, Some(person_id))
-      .await?
-      .ok_or(LemmyErrorType::CouldntFindCommentReply)?;
-
-  Ok(Json(CommentReplyResponse { comment_reply_view }))
-}

crates/api/src/local_user/notifications/mod.rs

@@ -1,6 +0,0 @@
-pub mod list_mentions;
-pub mod list_replies;
-pub mod mark_all_read;
-pub mod mark_mention_read;
-pub mod mark_reply_read;
-pub mod unread_count;

crates/api/src/local_user/notifications/unread_count.rs

@@ -1,26 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{context::LemmyContext, person::GetUnreadCountResponse};
-use lemmy_db_views::structs::{LocalUserView, PrivateMessageView};
-use lemmy_db_views_actor::structs::{CommentReplyView, PersonMentionView};
-use lemmy_utils::error::LemmyResult;
-
-#[tracing::instrument(skip(context))]
-pub async fn unread_count(
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<GetUnreadCountResponse>> {
-  let person_id = local_user_view.person.id;
-
-  let replies = CommentReplyView::get_unread_replies(&mut context.pool(), person_id).await?;
-
-  let mentions = PersonMentionView::get_unread_mentions(&mut context.pool(), person_id).await?;
-
-  let private_messages =
-    PrivateMessageView::get_unread_messages(&mut context.pool(), person_id).await?;
-
-  Ok(Json(GetUnreadCountResponse {
-    replies,
-    mentions,
-    private_messages,
-  }))
-}

crates/api/src/local_user/report_count.rs

@@ -1,46 +0,0 @@
-use actix_web::web::{Data, Json, Query};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{GetReportCount, GetReportCountResponse},
-  utils::check_community_mod_of_any_or_admin_action,
-};
-use lemmy_db_views::structs::{
-  CommentReportView,
-  LocalUserView,
-  PostReportView,
-  PrivateMessageReportView,
-};
-use lemmy_utils::error::LemmyResult;
-
-#[tracing::instrument(skip(context))]
-pub async fn report_count(
-  data: Query<GetReportCount>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<GetReportCountResponse>> {
-  let person_id = local_user_view.person.id;
-  let admin = local_user_view.local_user.admin;
-  let community_id = data.community_id;
-
-  check_community_mod_of_any_or_admin_action(&local_user_view, &mut context.pool()).await?;
-
-  let comment_reports =
-    CommentReportView::get_report_count(&mut context.pool(), person_id, admin, community_id)
-      .await?;
-
-  let post_reports =
-    PostReportView::get_report_count(&mut context.pool(), person_id, admin, community_id).await?;
-
-  let private_message_reports = if admin && community_id.is_none() {
-    Some(PrivateMessageReportView::get_report_count(&mut context.pool()).await?)
-  } else {
-    None
-  };
-
-  Ok(Json(GetReportCountResponse {
-    community_id,
-    comment_reports,
-    post_reports,
-    private_message_reports,
-  }))
-}

crates/api/src/local_user/reset_password.rs

@@ -1,31 +0,0 @@
-use crate::local_user::check_email_verified;
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::PasswordReset,
-  utils::send_password_reset_email,
-  SuccessResponse,
-};
-use lemmy_db_views::structs::{LocalUserView, SiteView};
-use lemmy_utils::error::{LemmyErrorType, LemmyResult};
-
-#[tracing::instrument(skip(context))]
-pub async fn reset_password(
-  data: Json<PasswordReset>,
-  context: Data<LemmyContext>,
-) -> LemmyResult<Json<SuccessResponse>> {
-  // Fetch that email
-  let email = data.email.to_lowercase();
-  let local_user_view = LocalUserView::find_by_email(&mut context.pool(), &email)
-    .await?
-    .ok_or(LemmyErrorType::IncorrectLogin)?;
-
-  let site_view = SiteView::read_local(&mut context.pool())
-    .await?
-    .ok_or(LemmyErrorType::LocalSiteNotSetup)?;
-  check_email_verified(&local_user_view, &site_view)?;
-
-  // Email the pure token to the user.
-  send_password_reset_email(&local_user_view, &mut context.pool(), context.settings()).await?;
-  Ok(Json(SuccessResponse::default()))
-}

crates/api/src/local_user/save_settings.rs

@@ -1,159 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::SaveUserSettings,
-  request::replace_image,
-  utils::{
-    get_url_blocklist,
-    local_site_to_slur_regex,
-    process_markdown_opt,
-    proxy_image_link_opt_api,
-    send_verification_email,
-  },
-  SuccessResponse,
-};
-use lemmy_db_schema::{
-  source::{
-    actor_language::LocalUserLanguage,
-    local_user::{LocalUser, LocalUserUpdateForm},
-    local_user_vote_display_mode::{LocalUserVoteDisplayMode, LocalUserVoteDisplayModeUpdateForm},
-    person::{Person, PersonUpdateForm},
-  },
-  traits::Crud,
-  utils::diesel_option_overwrite,
-};
-use lemmy_db_views::structs::{LocalUserView, SiteView};
-use lemmy_utils::{
-  error::{LemmyErrorType, LemmyResult},
-  utils::validation::{is_valid_bio_field, is_valid_display_name, is_valid_matrix_id},
-};
-use std::ops::Deref;
-
-#[tracing::instrument(skip(context))]
-pub async fn save_user_settings(
-  data: Json<SaveUserSettings>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<SuccessResponse>> {
-  let site_view = SiteView::read_local(&mut context.pool())
-    .await?
-    .ok_or(LemmyErrorType::LocalSiteNotSetup)?;
-
-  let slur_regex = local_site_to_slur_regex(&site_view.local_site);
-  let url_blocklist = get_url_blocklist(&context).await?;
-  let bio = diesel_option_overwrite(
-    process_markdown_opt(&data.bio, &slur_regex, &url_blocklist, &context).await?,
-  );
-  replace_image(&data.avatar, &local_user_view.person.avatar, &context).await?;
-  replace_image(&data.banner, &local_user_view.person.banner, &context).await?;
-
-  let avatar = proxy_image_link_opt_api(&data.avatar, &context).await?;
-  let banner = proxy_image_link_opt_api(&data.banner, &context).await?;
-  let display_name = diesel_option_overwrite(data.display_name.clone());
-  let matrix_user_id = diesel_option_overwrite(data.matrix_user_id.clone());
-  let email_deref = data.email.as_deref().map(str::to_lowercase);
-  let email = diesel_option_overwrite(email_deref.clone());
-
-  if let Some(Some(email)) = &email {
-    let previous_email = local_user_view.local_user.email.clone().unwrap_or_default();
-    // if email was changed, check that it is not taken and send verification mail
-    if previous_email.deref() != email {
-      if LocalUser::is_email_taken(&mut context.pool(), email).await? {
-        return Err(LemmyErrorType::EmailAlreadyExists)?;
-      }
-      send_verification_email(
-        &local_user_view,
-        email,
-        &mut context.pool(),
-        context.settings(),
-      )
-      .await?;
-    }
-  }
-
-  // When the site requires email, make sure email is not Some(None). IE, an overwrite to a None
-  // value
-  if let Some(email) = &email {
-    if email.is_none() && site_view.local_site.require_email_verification {
-      Err(LemmyErrorType::EmailRequired)?
-    }
-  }
-
-  if let Some(Some(bio)) = &bio {
-    is_valid_bio_field(bio)?;
-  }
-
-  if let Some(Some(display_name)) = &display_name {
-    is_valid_display_name(
-      display_name.trim(),
-      site_view.local_site.actor_name_max_length as usize,
-    )?;
-  }
-
-  if let Some(Some(matrix_user_id)) = &matrix_user_id {
-    is_valid_matrix_id(matrix_user_id)?;
-  }
-
-  let local_user_id = local_user_view.local_user.id;
-  let person_id = local_user_view.person.id;
-  let default_listing_type = data.default_listing_type;
-  let default_sort_type = data.default_sort_type;
-
-  let person_form = PersonUpdateForm {
-    display_name,
-    bio,
-    matrix_user_id,
-    bot_account: data.bot_account,
-    avatar,
-    banner,
-    ..Default::default()
-  };
-
-  // Ignore errors, because 'no fields updated' will return an error.
-  // https://github.com/LemmyNet/lemmy/issues/4076
-  Person::update(&mut context.pool(), person_id, &person_form)
-    .await
-    .ok();
-
-  if let Some(discussion_languages) = data.discussion_languages.clone() {
-    LocalUserLanguage::update(&mut context.pool(), discussion_languages, local_user_id).await?;
-  }
-
-  let local_user_form = LocalUserUpdateForm {
-    email,
-    show_avatars: data.show_avatars,
-    show_read_posts: data.show_read_posts,
-    send_notifications_to_email: data.send_notifications_to_email,
-    show_nsfw: data.show_nsfw,
-    blur_nsfw: data.blur_nsfw,
-    auto_expand: data.auto_expand,
-    show_bot_accounts: data.show_bot_accounts,
-    show_scores: data.show_scores,
-    default_sort_type,
-    default_listing_type,
-    theme: data.theme.clone(),
-    interface_language: data.interface_language.clone(),
-    open_links_in_new_tab: data.open_links_in_new_tab,
-    infinite_scroll_enabled: data.infinite_scroll_enabled,
-    post_listing_mode: data.post_listing_mode,
-    enable_keyboard_navigation: data.enable_keyboard_navigation,
-    enable_animated_images: data.enable_animated_images,
-    collapse_bot_comments: data.collapse_bot_comments,
-    ..Default::default()
-  };
-
-  LocalUser::update(&mut context.pool(), local_user_id, &local_user_form).await?;
-
-  // Update the vote display modes
-  let vote_display_modes_form = LocalUserVoteDisplayModeUpdateForm {
-    score: data.show_scores,
-    upvotes: data.show_upvotes,
-    downvotes: data.show_downvotes,
-    upvote_percentage: data.show_upvote_percentage,
-  };
-  LocalUserVoteDisplayMode::update(&mut context.pool(), local_user_id, &vote_display_modes_form)
-    .await?;
-
-  Ok(Json(SuccessResponse::default()))
-}

crates/api/src/local_user/update_totp.rs

@@ -1,49 +0,0 @@
-use crate::check_totp_2fa_valid;
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::{UpdateTotp, UpdateTotpResponse},
-};
-use lemmy_db_schema::source::local_user::{LocalUser, LocalUserUpdateForm};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::error::LemmyResult;
-
-/// Enable or disable two-factor-authentication. The current setting is determined from
-/// [LocalUser.totp_2fa_enabled].
-///
-/// To enable, you need to first call [generate_totp_secret] and then pass a valid token to this
-/// function.
-///
-/// Disabling is only possible if 2FA was previously enabled. Again it is necessary to pass a valid
-/// token.
-#[tracing::instrument(skip(context))]
-pub async fn update_totp(
-  data: Json<UpdateTotp>,
-  local_user_view: LocalUserView,
-  context: Data<LemmyContext>,
-) -> LemmyResult<Json<UpdateTotpResponse>> {
-  check_totp_2fa_valid(
-    &local_user_view,
-    &Some(data.totp_token.clone()),
-    &context.settings().hostname,
-  )?;
-
-  // toggle the 2fa setting
-  let local_user_form = LocalUserUpdateForm {
-    totp_2fa_enabled: Some(data.enabled),
-    // if totp is enabled, leave unchanged. otherwise clear secret
-    totp_2fa_secret: if data.enabled { None } else { Some(None) },
-    ..Default::default()
-  };
-
-  LocalUser::update(
-    &mut context.pool(),
-    local_user_view.local_user.id,
-    &local_user_form,
-  )
-  .await?;
-
-  Ok(Json(UpdateTotpResponse {
-    enabled: data.enabled,
-  }))
-}

crates/api/src/local_user/validate_auth.rs

@@ -1,23 +0,0 @@
-use crate::{local_user_view_from_jwt, read_auth_token};
-use actix_web::{
-  web::{Data, Json},
-  HttpRequest,
-};
-use lemmy_api_common::{context::LemmyContext, SuccessResponse};
-use lemmy_utils::error::{LemmyErrorType, LemmyResult};
-
-/// Returns an error message if the auth token is invalid for any reason. Necessary because other
-/// endpoints silently treat any call with invalid auth as unauthenticated.
-#[tracing::instrument(skip(context))]
-pub async fn validate_auth(
-  req: HttpRequest,
-  context: Data<LemmyContext>,
-) -> LemmyResult<Json<SuccessResponse>> {
-  let jwt = read_auth_token(&req)?;
-  if let Some(jwt) = jwt {
-    local_user_view_from_jwt(&jwt, &context).await?;
-  } else {
-    Err(LemmyErrorType::NotLoggedIn)?;
-  }
-  Ok(Json(SuccessResponse::default()))
-}

crates/api/src/local_user/verify_email.rs

@@ -1,60 +0,0 @@
-use actix_web::web::{Data, Json};
-use lemmy_api_common::{
-  context::LemmyContext,
-  person::VerifyEmail,
-  utils::send_new_applicant_email_to_admins,
-  SuccessResponse,
-};
-use lemmy_db_schema::{
-  source::{
-    email_verification::EmailVerification,
-    local_user::{LocalUser, LocalUserUpdateForm},
-  },
-  RegistrationMode,
-};
-use lemmy_db_views::structs::{LocalUserView, SiteView};
-use lemmy_utils::error::{LemmyErrorType, LemmyResult};
-
-pub async fn verify_email(
-  data: Json<VerifyEmail>,
-  context: Data<LemmyContext>,
-) -> LemmyResult<Json<SuccessResponse>> {
-  let site_view = SiteView::read_local(&mut context.pool())
-    .await?
-    .ok_or(LemmyErrorType::LocalSiteNotSetup)?;
-  let token = data.token.clone();
-  let verification = EmailVerification::read_for_token(&mut context.pool(), &token)
-    .await?
-    .ok_or(LemmyErrorType::TokenNotFound)?;
-
-  let form = LocalUserUpdateForm {
-    // necessary in case this is a new signup
-    email_verified: Some(true),
-    // necessary in case email of an existing user was changed
-    email: Some(Some(verification.email)),
-    ..Default::default()
-  };
-  let local_user_id = verification.local_user_id;
-
-  LocalUser::update(&mut context.pool(), local_user_id, &form).await?;
-
-  EmailVerification::delete_old_tokens_for_local_user(&mut context.pool(), local_user_id).await?;
-
-  // send out notification about registration application to admins if enabled
-  if site_view.local_site.registration_mode == RegistrationMode::RequireApplication
-    && site_view.local_site.application_email_admins
-  {
-    let local_user = LocalUserView::read(&mut context.pool(), local_user_id)
-      .await?
-      .ok_or(LemmyErrorType::CouldntFindPerson)?;
-
-    send_new_applicant_email_to_admins(
-      &local_user.person.name,
-      &mut context.pool(),
-      context.settings(),
-    )
-    .await?;
-  }
-
-  Ok(Json(SuccessResponse::default()))
-}

crates/api/src/post.rs

@@ -0,0 +1,895 @@
+use crate::{
+  check_community_ban,
+  check_downvotes_enabled,
+  check_optional_url,
+  collect_moderated_communities,
+  get_user_from_jwt,
+  get_user_from_jwt_opt,
+  is_mod_or_admin,
+  Perform,
+};
+use actix_web::web::Data;
+use lemmy_apub::{generate_apub_endpoint, ApubLikeableType, ApubObjectType, EndpointType};
+use lemmy_db_queries::{
+  source::post::Post_,
+  Crud,
+  Likeable,
+  ListingType,
+  Reportable,
+  Saveable,
+  SortType,
+};
+use lemmy_db_schema::{
+  naive_now,
+  source::{
+    moderator::*,
+    post::*,
+    post_report::{PostReport, PostReportForm},
+  },
+};
+use lemmy_db_views::{
+  comment_view::CommentQueryBuilder,
+  post_report_view::{PostReportQueryBuilder, PostReportView},
+  post_view::{PostQueryBuilder, PostView},
+};
+use lemmy_db_views_actor::{
+  community_moderator_view::CommunityModeratorView,
+  community_view::CommunityView,
+};
+use lemmy_structs::{blocking, post::*};
+use lemmy_utils::{
+  request::fetch_iframely_and_pictrs_data,
+  utils::{check_slurs, check_slurs_opt, is_valid_post_title},
+  APIError,
+  ConnectionId,
+  LemmyError,
+};
+use lemmy_websocket::{
+  messages::{GetPostUsersOnline, SendModRoomMessage, SendPost, SendUserRoomMessage},
+  LemmyContext,
+  UserOperation,
+};
+use std::str::FromStr;
+
+#[async_trait::async_trait(?Send)]
+impl Perform for CreatePost {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &CreatePost = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    check_slurs(&data.name)?;
+    check_slurs_opt(&data.body)?;
+
+    if !is_valid_post_title(&data.name) {
+      return Err(APIError::err("invalid_post_title").into());
+    }
+
+    check_community_ban(user.id, data.community_id, context.pool()).await?;
+
+    check_optional_url(&Some(data.url.to_owned()))?;
+
+    // Fetch Iframely and pictrs cached image
+    let (iframely_title, iframely_description, iframely_html, pictrs_thumbnail) =
+      fetch_iframely_and_pictrs_data(context.client(), data.url.to_owned()).await;
+
+    let post_form = PostForm {
+      name: data.name.trim().to_owned(),
+      url: data.url.to_owned(),
+      body: data.body.to_owned(),
+      community_id: data.community_id,
+      creator_id: user.id,
+      removed: None,
+      deleted: None,
+      nsfw: data.nsfw,
+      locked: None,
+      stickied: None,
+      updated: None,
+      embed_title: iframely_title,
+      embed_description: iframely_description,
+      embed_html: iframely_html,
+      thumbnail_url: pictrs_thumbnail,
+      ap_id: None,
+      local: true,
+      published: None,
+    };
+
+    let inserted_post =
+      match blocking(context.pool(), move |conn| Post::create(conn, &post_form)).await? {
+        Ok(post) => post,
+        Err(e) => {
+          let err_type = if e.to_string() == "value too long for type character varying(200)" {
+            "post_title_too_long"
+          } else {
+            "couldnt_create_post"
+          };
+
+          return Err(APIError::err(err_type).into());
+        }
+      };
+
+    let inserted_post_id = inserted_post.id;
+    let updated_post = match blocking(context.pool(), move |conn| -> Result<Post, LemmyError> {
+      let apub_id = generate_apub_endpoint(EndpointType::Post, &inserted_post_id.to_string())?;
+      Ok(Post::update_ap_id(conn, inserted_post_id, apub_id)?)
+    })
+    .await?
+    {
+      Ok(post) => post,
+      Err(_e) => return Err(APIError::err("couldnt_create_post").into()),
+    };
+
+    updated_post.send_create(&user, context).await?;
+
+    // They like their own post by default
+    let like_form = PostLikeForm {
+      post_id: inserted_post.id,
+      user_id: user.id,
+      score: 1,
+    };
+
+    let like = move |conn: &'_ _| PostLike::like(conn, &like_form);
+    if blocking(context.pool(), like).await?.is_err() {
+      return Err(APIError::err("couldnt_like_post").into());
+    }
+
+    updated_post.send_like(&user, context).await?;
+
+    // Refetch the view
+    let inserted_post_id = inserted_post.id;
+    let post_view = match blocking(context.pool(), move |conn| {
+      PostView::read(conn, inserted_post_id, Some(user.id))
+    })
+    .await?
+    {
+      Ok(post) => post,
+      Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
+    };
+
+    let res = PostResponse { post_view };
+
+    context.chat_server().do_send(SendPost {
+      op: UserOperation::CreatePost,
+      post: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for GetPost {
+  type Response = GetPostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetPostResponse, LemmyError> {
+    let data: &GetPost = &self;
+    let user = get_user_from_jwt_opt(&data.auth, context.pool()).await?;
+    let user_id = user.map(|u| u.id);
+
+    let id = data.id;
+    let post_view = match blocking(context.pool(), move |conn| {
+      PostView::read(conn, id, user_id)
+    })
+    .await?
+    {
+      Ok(post) => post,
+      Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
+    };
+
+    let id = data.id;
+    let comments = blocking(context.pool(), move |conn| {
+      CommentQueryBuilder::create(conn)
+        .my_user_id(user_id)
+        .post_id(id)
+        .limit(9999)
+        .list()
+    })
+    .await??;
+
+    let community_id = post_view.community.id;
+    let moderators = blocking(context.pool(), move |conn| {
+      CommunityModeratorView::for_community(conn, community_id)
+    })
+    .await??;
+
+    // Necessary for the sidebar
+    let community_view = match blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, user_id)
+    })
+    .await?
+    {
+      Ok(community) => community,
+      Err(_e) => return Err(APIError::err("couldnt_find_community").into()),
+    };
+
+    let online = context
+      .chat_server()
+      .send(GetPostUsersOnline { post_id: data.id })
+      .await
+      .unwrap_or(1);
+
+    // Return the jwt
+    Ok(GetPostResponse {
+      post_view,
+      community_view,
+      comments,
+      moderators,
+      online,
+    })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for GetPosts {
+  type Response = GetPostsResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetPostsResponse, LemmyError> {
+    let data: &GetPosts = &self;
+    let user = get_user_from_jwt_opt(&data.auth, context.pool()).await?;
+
+    let user_id = match &user {
+      Some(user) => Some(user.id),
+      None => None,
+    };
+
+    let show_nsfw = match &user {
+      Some(user) => user.show_nsfw,
+      None => false,
+    };
+
+    let type_ = ListingType::from_str(&data.type_)?;
+    let sort = SortType::from_str(&data.sort)?;
+
+    let page = data.page;
+    let limit = data.limit;
+    let community_id = data.community_id;
+    let community_name = data.community_name.to_owned();
+    let posts = match blocking(context.pool(), move |conn| {
+      PostQueryBuilder::create(conn)
+        .listing_type(&type_)
+        .sort(&sort)
+        .show_nsfw(show_nsfw)
+        .community_id(community_id)
+        .community_name(community_name)
+        .my_user_id(user_id)
+        .page(page)
+        .limit(limit)
+        .list()
+    })
+    .await?
+    {
+      Ok(posts) => posts,
+      Err(_e) => return Err(APIError::err("couldnt_get_posts").into()),
+    };
+
+    Ok(GetPostsResponse { posts })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for CreatePostLike {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &CreatePostLike = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    // Don't do a downvote if site has downvotes disabled
+    check_downvotes_enabled(data.score, context.pool()).await?;
+
+    // Check for a community ban
+    let post_id = data.post_id;
+    let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+
+    check_community_ban(user.id, post.community_id, context.pool()).await?;
+
+    let like_form = PostLikeForm {
+      post_id: data.post_id,
+      user_id: user.id,
+      score: data.score,
+    };
+
+    // Remove any likes first
+    let user_id = user.id;
+    blocking(context.pool(), move |conn| {
+      PostLike::remove(conn, user_id, post_id)
+    })
+    .await??;
+
+    // Only add the like if the score isnt 0
+    let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
+    if do_add {
+      let like_form2 = like_form.clone();
+      let like = move |conn: &'_ _| PostLike::like(conn, &like_form2);
+      if blocking(context.pool(), like).await?.is_err() {
+        return Err(APIError::err("couldnt_like_post").into());
+      }
+
+      if like_form.score == 1 {
+        post.send_like(&user, context).await?;
+      } else if like_form.score == -1 {
+        post.send_dislike(&user, context).await?;
+      }
+    } else {
+      post.send_undo_like(&user, context).await?;
+    }
+
+    let post_id = data.post_id;
+    let user_id = user.id;
+    let post_view = match blocking(context.pool(), move |conn| {
+      PostView::read(conn, post_id, Some(user_id))
+    })
+    .await?
+    {
+      Ok(post) => post,
+      Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
+    };
+
+    let res = PostResponse { post_view };
+
+    context.chat_server().do_send(SendPost {
+      op: UserOperation::CreatePostLike,
+      post: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for EditPost {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &EditPost = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    check_slurs(&data.name)?;
+    check_slurs_opt(&data.body)?;
+
+    if !is_valid_post_title(&data.name) {
+      return Err(APIError::err("invalid_post_title").into());
+    }
+
+    let post_id = data.post_id;
+    let orig_post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+
+    check_community_ban(user.id, orig_post.community_id, context.pool()).await?;
+
+    // Verify that only the creator can edit
+    if !Post::is_post_creator(user.id, orig_post.creator_id) {
+      return Err(APIError::err("no_post_edit_allowed").into());
+    }
+
+    // Fetch Iframely and Pictrs cached image
+    let (iframely_title, iframely_description, iframely_html, pictrs_thumbnail) =
+      fetch_iframely_and_pictrs_data(context.client(), data.url.to_owned()).await;
+
+    let post_form = PostForm {
+      name: data.name.trim().to_owned(),
+      url: data.url.to_owned(),
+      body: data.body.to_owned(),
+      nsfw: data.nsfw,
+      creator_id: orig_post.creator_id.to_owned(),
+      community_id: orig_post.community_id,
+      removed: Some(orig_post.removed),
+      deleted: Some(orig_post.deleted),
+      locked: Some(orig_post.locked),
+      stickied: Some(orig_post.stickied),
+      updated: Some(naive_now()),
+      embed_title: iframely_title,
+      embed_description: iframely_description,
+      embed_html: iframely_html,
+      thumbnail_url: pictrs_thumbnail,
+      ap_id: Some(orig_post.ap_id),
+      local: orig_post.local,
+      published: None,
+    };
+
+    let post_id = data.post_id;
+    let res = blocking(context.pool(), move |conn| {
+      Post::update(conn, post_id, &post_form)
+    })
+    .await?;
+    let updated_post: Post = match res {
+      Ok(post) => post,
+      Err(e) => {
+        let err_type = if e.to_string() == "value too long for type character varying(200)" {
+          "post_title_too_long"
+        } else {
+          "couldnt_update_post"
+        };
+
+        return Err(APIError::err(err_type).into());
+      }
+    };
+
+    // Send apub update
+    updated_post.send_update(&user, context).await?;
+
+    let post_id = data.post_id;
+    let post_view = blocking(context.pool(), move |conn| {
+      PostView::read(conn, post_id, Some(user.id))
+    })
+    .await??;
+
+    let res = PostResponse { post_view };
+
+    context.chat_server().do_send(SendPost {
+      op: UserOperation::EditPost,
+      post: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for DeletePost {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &DeletePost = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let post_id = data.post_id;
+    let orig_post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+
+    check_community_ban(user.id, orig_post.community_id, context.pool()).await?;
+
+    // Verify that only the creator can delete
+    if !Post::is_post_creator(user.id, orig_post.creator_id) {
+      return Err(APIError::err("no_post_edit_allowed").into());
+    }
+
+    // Update the post
+    let post_id = data.post_id;
+    let deleted = data.deleted;
+    let updated_post = blocking(context.pool(), move |conn| {
+      Post::update_deleted(conn, post_id, deleted)
+    })
+    .await??;
+
+    // apub updates
+    if deleted {
+      updated_post.send_delete(&user, context).await?;
+    } else {
+      updated_post.send_undo_delete(&user, context).await?;
+    }
+
+    // Refetch the post
+    let post_id = data.post_id;
+    let post_view = blocking(context.pool(), move |conn| {
+      PostView::read(conn, post_id, Some(user.id))
+    })
+    .await??;
+
+    let res = PostResponse { post_view };
+
+    context.chat_server().do_send(SendPost {
+      op: UserOperation::DeletePost,
+      post: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for RemovePost {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &RemovePost = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let post_id = data.post_id;
+    let orig_post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+
+    check_community_ban(user.id, orig_post.community_id, context.pool()).await?;
+
+    // Verify that only the mods can remove
+    is_mod_or_admin(context.pool(), user.id, orig_post.community_id).await?;
+
+    // Update the post
+    let post_id = data.post_id;
+    let removed = data.removed;
+    let updated_post = blocking(context.pool(), move |conn| {
+      Post::update_removed(conn, post_id, removed)
+    })
+    .await??;
+
+    // Mod tables
+    let form = ModRemovePostForm {
+      mod_user_id: user.id,
+      post_id: data.post_id,
+      removed: Some(removed),
+      reason: data.reason.to_owned(),
+    };
+    blocking(context.pool(), move |conn| {
+      ModRemovePost::create(conn, &form)
+    })
+    .await??;
+
+    // apub updates
+    if removed {
+      updated_post.send_remove(&user, context).await?;
+    } else {
+      updated_post.send_undo_remove(&user, context).await?;
+    }
+
+    // Refetch the post
+    let post_id = data.post_id;
+    let user_id = user.id;
+    let post_view = blocking(context.pool(), move |conn| {
+      PostView::read(conn, post_id, Some(user_id))
+    })
+    .await??;
+
+    let res = PostResponse { post_view };
+
+    context.chat_server().do_send(SendPost {
+      op: UserOperation::RemovePost,
+      post: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for LockPost {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &LockPost = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let post_id = data.post_id;
+    let orig_post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+
+    check_community_ban(user.id, orig_post.community_id, context.pool()).await?;
+
+    // Verify that only the mods can lock
+    is_mod_or_admin(context.pool(), user.id, orig_post.community_id).await?;
+
+    // Update the post
+    let post_id = data.post_id;
+    let locked = data.locked;
+    let updated_post = blocking(context.pool(), move |conn| {
+      Post::update_locked(conn, post_id, locked)
+    })
+    .await??;
+
+    // Mod tables
+    let form = ModLockPostForm {
+      mod_user_id: user.id,
+      post_id: data.post_id,
+      locked: Some(locked),
+    };
+    blocking(context.pool(), move |conn| ModLockPost::create(conn, &form)).await??;
+
+    // apub updates
+    updated_post.send_update(&user, context).await?;
+
+    // Refetch the post
+    let post_id = data.post_id;
+    let post_view = blocking(context.pool(), move |conn| {
+      PostView::read(conn, post_id, Some(user.id))
+    })
+    .await??;
+
+    let res = PostResponse { post_view };
+
+    context.chat_server().do_send(SendPost {
+      op: UserOperation::LockPost,
+      post: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for StickyPost {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &StickyPost = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let post_id = data.post_id;
+    let orig_post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+
+    check_community_ban(user.id, orig_post.community_id, context.pool()).await?;
+
+    // Verify that only the mods can sticky
+    is_mod_or_admin(context.pool(), user.id, orig_post.community_id).await?;
+
+    // Update the post
+    let post_id = data.post_id;
+    let stickied = data.stickied;
+    let updated_post = blocking(context.pool(), move |conn| {
+      Post::update_stickied(conn, post_id, stickied)
+    })
+    .await??;
+
+    // Mod tables
+    let form = ModStickyPostForm {
+      mod_user_id: user.id,
+      post_id: data.post_id,
+      stickied: Some(stickied),
+    };
+    blocking(context.pool(), move |conn| {
+      ModStickyPost::create(conn, &form)
+    })
+    .await??;
+
+    // Apub updates
+    // TODO stickied should pry work like locked for ease of use
+    updated_post.send_update(&user, context).await?;
+
+    // Refetch the post
+    let post_id = data.post_id;
+    let post_view = blocking(context.pool(), move |conn| {
+      PostView::read(conn, post_id, Some(user.id))
+    })
+    .await??;
+
+    let res = PostResponse { post_view };
+
+    context.chat_server().do_send(SendPost {
+      op: UserOperation::StickyPost,
+      post: res.clone(),
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for SavePost {
+  type Response = PostResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<PostResponse, LemmyError> {
+    let data: &SavePost = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let post_saved_form = PostSavedForm {
+      post_id: data.post_id,
+      user_id: user.id,
+    };
+
+    if data.save {
+      let save = move |conn: &'_ _| PostSaved::save(conn, &post_saved_form);
+      if blocking(context.pool(), save).await?.is_err() {
+        return Err(APIError::err("couldnt_save_post").into());
+      }
+    } else {
+      let unsave = move |conn: &'_ _| PostSaved::unsave(conn, &post_saved_form);
+      if blocking(context.pool(), unsave).await?.is_err() {
+        return Err(APIError::err("couldnt_save_post").into());
+      }
+    }
+
+    let post_id = data.post_id;
+    let user_id = user.id;
+    let post_view = blocking(context.pool(), move |conn| {
+      PostView::read(conn, post_id, Some(user_id))
+    })
+    .await??;
+
+    Ok(PostResponse { post_view })
+  }
+}
+
+/// Creates a post report and notifies the moderators of the community
+#[async_trait::async_trait(?Send)]
+impl Perform for CreatePostReport {
+  type Response = CreatePostReportResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<CreatePostReportResponse, LemmyError> {
+    let data: &CreatePostReport = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    // check size of report and check for whitespace
+    let reason = data.reason.trim();
+    if reason.is_empty() {
+      return Err(APIError::err("report_reason_required").into());
+    }
+    if reason.chars().count() > 1000 {
+      return Err(APIError::err("report_too_long").into());
+    }
+
+    let user_id = user.id;
+    let post_id = data.post_id;
+    let post_view = blocking(context.pool(), move |conn| {
+      PostView::read(&conn, post_id, None)
+    })
+    .await??;
+
+    check_community_ban(user_id, post_view.community.id, context.pool()).await?;
+
+    let report_form = PostReportForm {
+      creator_id: user_id,
+      post_id,
+      original_post_name: post_view.post.name,
+      original_post_url: post_view.post.url,
+      original_post_body: post_view.post.body,
+      reason: data.reason.to_owned(),
+    };
+
+    let report = match blocking(context.pool(), move |conn| {
+      PostReport::report(conn, &report_form)
+    })
+    .await?
+    {
+      Ok(report) => report,
+      Err(_e) => return Err(APIError::err("couldnt_create_report").into()),
+    };
+
+    let res = CreatePostReportResponse { success: true };
+
+    context.chat_server().do_send(SendUserRoomMessage {
+      op: UserOperation::CreatePostReport,
+      response: res.clone(),
+      recipient_id: user.id,
+      websocket_id,
+    });
+
+    context.chat_server().do_send(SendModRoomMessage {
+      op: UserOperation::CreatePostReport,
+      response: report,
+      community_id: post_view.community.id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+/// Resolves or unresolves a post report and notifies the moderators of the community
+#[async_trait::async_trait(?Send)]
+impl Perform for ResolvePostReport {
+  type Response = ResolvePostReportResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<ResolvePostReportResponse, LemmyError> {
+    let data: &ResolvePostReport = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let report_id = data.report_id;
+    let report = blocking(context.pool(), move |conn| {
+      PostReportView::read(&conn, report_id)
+    })
+    .await??;
+
+    let user_id = user.id;
+    is_mod_or_admin(context.pool(), user_id, report.community.id).await?;
+
+    let resolved = data.resolved;
+    let resolve_fun = move |conn: &'_ _| {
+      if resolved {
+        PostReport::resolve(conn, report_id, user_id)
+      } else {
+        PostReport::unresolve(conn, report_id, user_id)
+      }
+    };
+
+    let res = ResolvePostReportResponse {
+      report_id,
+      resolved: true,
+    };
+
+    if blocking(context.pool(), resolve_fun).await?.is_err() {
+      return Err(APIError::err("couldnt_resolve_report").into());
+    };
+
+    context.chat_server().do_send(SendModRoomMessage {
+      op: UserOperation::ResolvePostReport,
+      response: res.clone(),
+      community_id: report.community.id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}
+
+/// Lists post reports for a community if an id is supplied
+/// or returns all post reports for communities a user moderates
+#[async_trait::async_trait(?Send)]
+impl Perform for ListPostReports {
+  type Response = ListPostReportsResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    websocket_id: Option<ConnectionId>,
+  ) -> Result<ListPostReportsResponse, LemmyError> {
+    let data: &ListPostReports = &self;
+    let user = get_user_from_jwt(&data.auth, context.pool()).await?;
+
+    let user_id = user.id;
+    let community_id = data.community;
+    let community_ids =
+      collect_moderated_communities(user_id, community_id, context.pool()).await?;
+
+    let page = data.page;
+    let limit = data.limit;
+    let posts = blocking(context.pool(), move |conn| {
+      PostReportQueryBuilder::create(conn)
+        .community_ids(community_ids)
+        .page(page)
+        .limit(limit)
+        .list()
+    })
+    .await??;
+
+    let res = ListPostReportsResponse { posts };
+
+    context.chat_server().do_send(SendUserRoomMessage {
+      op: UserOperation::ListPostReports,
+      response: res.clone(),
+      recipient_id: user.id,
+      websocket_id,
+    });
+
+    Ok(res)
+  }
+}

crates/api/src/post/feature.rs

@@ -1,82 +0,0 @@
-use activitypub_federation::config::Data;
-use actix_web::web::Json;
-use lemmy_api_common::{
-  build_response::build_post_response,
-  context::LemmyContext,
-  post::{FeaturePost, PostResponse},
-  send_activity::{ActivityChannel, SendActivityData},
-  utils::{check_community_mod_action, is_admin},
-};
-use lemmy_db_schema::{
-  source::{
-    moderator::{ModFeaturePost, ModFeaturePostForm},
-    post::{Post, PostUpdateForm},
-  },
-  traits::Crud,
-  PostFeatureType,
-};
-use lemmy_db_views::structs::LocalUserView;
-use lemmy_utils::{error::LemmyResult, LemmyErrorType};
-
-#[tracing::instrument(skip(context))]
-pub async fn feature_post(
-  data: Json<FeaturePost>,
-  context: Data<LemmyContext>,
-  local_user_view: LocalUserView,
-) -> LemmyResult<Json<PostResponse>> {
-  let post_id = data.post_id;
-  let orig_post = Post::read(&mut context.pool(), post_id)
-    .await?
-    .ok_or(LemmyErrorType::CouldntFindPost)?;
-
-  check_community_mod_action(
-    &local_user_view.person,
-    orig_post.community_id,
-    false,
-    &mut context.pool(),
-  )
-  .await?;
-
-  if data.feature_type == PostFeatureType::Local {
-    is_admin(&local_user_view)?;
-  }
-
-  // Update the post
-  let post_id = data.post_id;
-  let new_post: PostUpdateForm = if data.feature_type == PostFeatureType::Community {
-    PostUpdateForm {
-      featured_community: Some(data.featured),
-      ..Default::default()
-    }
-  } else {
-    PostUpdateForm {
-      featured_local: Some(data.featured),
-      ..Default::default()
-    }
-  };
-  let post = Post::update(&mut context.pool(), post_id, &new_post).await?;
-
-  // Mod tables
-  let form = ModFeaturePostForm {
-    mod_person_id: local_user_view.person.id,
-    post_id: data.post_id,
-    featured: data.featured,
-    is_featured_community: data.feature_type == PostFeatureType::Community,
-  };
-
-  ModFeaturePost::create(&mut context.pool(), &form).await?;
-
-  ActivityChannel::submit_activity(
-    SendActivityData::FeaturePost(post, local_user_view.person.clone(), data.featured),
-    &context,
-  )
-  .await?;
-
-  build_post_response(
-    &context,
-    orig_post.community_id,
-    &local_user_view.person,
-    post_id,
-  )
-  .await
-}