entrypoint

Reviewed-on: #7

.circleci/config.yml

@@ -10,7 +10,7 @@ executors:
         type: boolean
         default: false
     docker:
-    - image: plumeorg/plume-buildenv:v0.4.0
+    - image: plumeorg/plume-buildenv:v0.8.0
     - image: <<#parameters.postgres>>cimg/postgres:14.2<</parameters.postgres>><<^parameters.postgres>>alpine:latest<</parameters.postgres>>
       environment:
         POSTGRES_USER: postgres
@@ -38,7 +38,7 @@ commands:
     - restore_cache:
         keys:
         - v0-<< parameters.cache >>-{{ checksum "Cargo.lock" }}-{{ .Branch }}
-        - v0-<< parameters.cache >>-{{ checksum "Cargo.lock" }}-master
+        - v0-<< parameters.cache >>-{{ checksum "Cargo.lock" }}-main
 
   cache:
     description: push cache
@@ -63,6 +63,7 @@ commands:
         type: boolean
         default: false
     steps:
+    - run: rustup component add clippy --toolchain nightly-2022-07-19-x86_64-unknown-linux-gnu
     - run: cargo clippy <<^parameters.no_feature>>--no-default-features --features="${FEATURES}"<</parameters.no_feature>> --release -p <<parameters.package>> -- -D warnings
 
   run_with_coverage:
@@ -111,6 +112,7 @@ jobs:
       name: default
     steps:
     - restore_env
+    - run: rustup component add rustfmt --toolchain nightly-2022-07-19-x86_64-unknown-linux-gnu
     - run: cargo fmt --all -- --check
 
   clippy:
@@ -258,4 +260,4 @@ workflows:
         filters:
           branches:
             only:
-              - /^master/
+              - /^main/

.circleci/images/plume-buildenv/Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:buster-20210208
+FROM rust:1
 ENV PATH="/root/.cargo/bin:${PATH}"
 
 #install native/circleci/build dependancies
@@ -6,19 +6,19 @@ RUN apt update &&\
     apt install -y --no-install-recommends git ssh tar gzip ca-certificates default-jre&&\
     echo "deb [trusted=yes] https://apt.fury.io/caddy/ /" \
     | tee -a /etc/apt/sources.list.d/caddy-fury.list &&\
+    wget -qO - https://artifacts.crowdin.com/repo/GPG-KEY-crowdin | apt-key add - &&\
+    echo "deb https://artifacts.crowdin.com/repo/deb/ /" > /etc/apt/sources.list.d/crowdin.list &&\
     apt update &&\
-    apt install -y --no-install-recommends binutils-dev build-essential cmake curl gcc gettext git libcurl4-openssl-dev libdw-dev libelf-dev libiberty-dev libpq-dev libsqlite3-dev libssl-dev make openssl pkg-config postgresql postgresql-contrib python zlib1g-dev python3-pip zip unzip libclang-dev clang caddy&&\
+    apt install -y --no-install-recommends binutils-dev build-essential cmake curl gcc gettext git libcurl4-openssl-dev libdw-dev libelf-dev libiberty-dev libpq-dev libsqlite3-dev libssl-dev make openssl pkg-config postgresql postgresql-contrib python zlib1g-dev python3-dev python3-pip python3-setuptools zip unzip libclang-dev clang caddy crowdin3 &&\
     rm -rf /var/lib/apt/lists/*
 
-#install and configure rust
+#stick rust environment
-RUN curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2021-11-27 -y &&\
+COPY rust-toolchain ./
-    rustup component add rustfmt clippy &&\
+RUN rustup component add rustfmt clippy
-    rustup component add rust-std --target wasm32-unknown-unknown
 
 #compile some deps
 RUN cargo install wasm-pack &&\
     cargo install grcov &&\
-    strip /root/.cargo/bin/* &&\
     rm -fr ~/.cargo/registry
 
 #set some compilation parametters
@@ -29,11 +29,3 @@ RUN pip3 install selenium
 
 #configure caddy
 COPY Caddyfile /Caddyfile
-
-#install crowdin
-RUN mkdir /crowdin && cd /crowdin &&\
-    curl -O https://downloads.crowdin.com/cli/v2/crowdin-cli.zip &&\
-    unzip crowdin-cli.zip && rm crowdin-cli.zip &&\
-    cd * && mv crowdin-cli.jar /usr/local/bin && cd && rm -rf /crowdin &&\
-    /bin/echo -e '#!/bin/sh\njava -jar /usr/local/bin/crowdin-cli.jar $@' > /usr/local/bin/crowdin &&\
-    chmod +x /usr/local/bin/crowdin

.circleci/images/plume-buildenv/rust-toolchain

@@ -0,0 +1 @@
+nightly-2022-07-19

.dockerignore

@@ -3,3 +3,5 @@ data
 Dockerfile
 docker-compose.yml
 .env
+target
+data

.envrc

@@ -0,0 +1 @@
+use flake

.github/workflows/deploy-docker-latest.yaml

@@ -11,20 +11,20 @@ jobs:
     steps:
       -
         name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v2
       -
         name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
       -
         name: Login to DockerHub
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
       -
         name: Build and push
         id: docker_build
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
           push: true
           tags: plumeorg/plume:latest

.github/workflows/deploy-docker-tag.yaml

@@ -11,10 +11,10 @@ jobs:
     steps:
       -
         name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v2
       -
         name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
       -
         name: Docker meta
         id: meta
@@ -23,14 +23,14 @@ jobs:
           images: plumeorg/plume
       -
         name: Login to DockerHub
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
       -
         name: Build and push
         id: docker_build
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
           push: true
           tags: ${{ steps.meta.outputs.tags }}

.gitignore

@@ -20,3 +20,5 @@ search_index
 __pycache__
 .vscode/
 *-journal
+.direnv/
+build.log*

CHANGELOG.md

@@ -4,6 +4,39 @@
 
 ## [Unreleased] - ReleaseDate
 
+### Added
+
+- Add 'My feed' to i18n timeline name (#1084)
+- Bidirectional support for user page header (#1092)
+- Add non anonymous bind to LDAP server, taken from https://git.joinplu.me/Plume/Plume/src/branch/ldap-non-anon PR
+
+### Changed
+
+- Use blog title as slug (#1094, #1126, #1127)
+- Bump Rust to nightly 2022-07-19 (#1119)
+- Force LDAP simple bind with *cn* rdn instead of *uid*
+- Update rust-toolchain to nightly-2023-04-14
+- Update chrono from 0.4.0 to 0.4.31
+- Update scheduled-thread-pool from 0.2.6 to 0.2.7
+- Change blockquote color to `lightpurple`
+- Some colour has been added to the tables to make them more visible
+
+### Fixed
+
+- Malfunction while creating a blog post in Persian (#1116)
+- Email block list is ignored when email sign-up (#1122)
+- Bug that some Activity Sytreams properties are not parsed properly (#1129)
+- Allow empty avatar for remote users (#1129)
+- Percent encode blog FQN for federation interoperability (#1129)
+- The same to `preferredUsername` (#1129)
+- Deprecation warnings during build process(see rust crate updates)
+- Server error 500 creating new blog with white spaces inside title. Bug reported on https://git.joinplu.me/Plume/Plume/issues/1152
+- Show _Subscribe_ button in column format instead of row format in screen smaller than 600px. https://git.lainoa.eus/aitzol/Plume/commit/db8cc6e7e8351a5d74f7ce0399126e13493c62d9
+
+### To do
+
+- Choose rdn via environment variables for LDAP simple bind
+
 ## [[0.7.2]] - 2022-05-11
 
 ### Added

Cargo.toml

@@ -1,33 +1,34 @@
 [package]
 authors = ["Plume contributors"]
 name = "plume"
-version = "0.7.2"
+version = "0.7.3-dev-fork"
-repository = "https://github.com/Plume-org/Plume"
+repository = "https://git.lainoa.eus/aitzol/Plume"
-edition = "2018"
+edition = "2021"
 
 [dependencies]
-atom_syndication = "0.11.0"
+atom_syndication = "0.12.0"
 clap = "2.33"
 dotenv = "0.15.0"
 gettext = "0.4.0"
 gettext-macros = "0.6.1"
 gettext-utils = "0.1.0"
-guid-create = "0.2"
+guid-create = "0.4.1"
+conv = "0.3.3"
 lettre_email = "0.9.2"
-num_cpus = "1.10"
+num_cpus = "1.16.0"
-rocket = "0.4.6"
+rocket = "0.4.11"
-rocket_contrib = { version = "0.4.5", features = ["json"] }
+rocket_contrib = { version = "0.4.11", features = ["json"] }
 rocket_i18n = "0.4.1"
-scheduled-thread-pool = "0.2.2"
+scheduled-thread-pool = "0.2.7"
-serde = "1.0"
+serde = "1.0.137"
 serde_json = "1.0.81"
 shrinkwraprs = "0.3.0"
 validator = { version = "0.15", features = ["derive"] }
 webfinger = "0.4.1"
-tracing = "0.1.34"
+tracing = "0.1.35"
 tracing-subscriber = "0.3.10"
 riker = "0.4.2"
-activitystreams = "0.7.0-alpha.18"
+activitystreams = "=0.7.0-alpha.20"
 
 [[bin]]
 name = "plume"
@@ -35,7 +36,7 @@ path = "src/main.rs"
 
 [dependencies.chrono]
 features = ["serde"]
-version = "0.4"
+version = "0.4.31"
 
 [dependencies.ctrlc]
 features = ["termination"]
@@ -60,20 +61,22 @@ path = "plume-common"
 path = "plume-models"
 
 [dependencies.rocket_csrf]
-git = "https://github.com/fdb-hiroshima/rocket_csrf"
+git = "https://git.joinplu.me/plume/rocket_csrf"
-rev = "29910f2829e7e590a540da3804336577b48c7b31"
+rev = "0.1.2"
 
 [build-dependencies]
-ructe = "0.14.0"
+ructe = "0.15.0"
-rsass = "0.24"
+rsass = "0.26"
 
 [features]
-default = ["postgres"]
+default = ["postgres", "s3"]
 postgres = ["plume-models/postgres", "diesel/postgres"]
 sqlite = ["plume-models/sqlite", "diesel/sqlite"]
 debug-mailer = []
 test = []
 search-lindera = ["plume-models/search-lindera"]
+s3 = ["plume-models/s3"]
+cargo-clippy = []
 
 [workspace]
 members = ["plume-api", "plume-cli", "plume-models", "plume-common", "plume-front", "plume-macro"]

Containerfile

@@ -0,0 +1,62 @@
+FROM rust:1.82 AS builder
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    gettext \
+    postgresql-client \
+    libpq-dev \
+    git \
+    curl \
+    gcc \
+    make \
+    openssl \
+    libssl-dev \
+    clang
+
+RUN ln -s /usr/bin/python3 /usr/bin/python & \
+    ln -s /usr/bin/pip3 /usr/bin/pip
+
+WORKDIR /scratch
+COPY script/wasm-deps.sh .
+RUN chmod a+x ./wasm-deps.sh && sleep 1 && ./wasm-deps.sh
+
+WORKDIR /app
+
+COPY . .
+RUN echo "=== TOOLCHAIN ===" && \
+    rustc --version && \
+    cargo --version && \
+    rustup show && \
+    echo "=== TIME-CORE IN LOCK ===" && \
+    grep -A5 -B2 'name = "time-core"' Cargo.lock
+
+#RUN cargo install wasm-pack
+RUN curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+RUN chmod a+x ./script/plume-front.sh && sleep 1 && ./script/plume-front.sh
+
+RUN cargo install --locked --path ./ --force --no-default-features --features postgres
+RUN cargo install --locked --path plume-cli --force --no-default-features --features postgres
+#RUN cargo install --path ./ --force --no-default-features --features postgres
+#RUN cargo install --path plume-cli --force --no-default-features --features postgres
+RUN cargo clean
+
+FROM debian:stable-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    libpq5
+
+WORKDIR /app
+
+COPY --from=builder /app /app
+COPY --from=builder /usr/local/cargo/bin/plm /bin/
+COPY --from=builder /usr/local/cargo/bin/plume /bin/
+
+
+COPY entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod 755 /usr/local/bin/entrypoint.sh
+
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+CMD ["plume"]
+
+EXPOSE 7878

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1-buster as builder
+FROM rust:latest AS builder
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates \
@@ -13,27 +13,27 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libssl-dev \
     clang
 
+RUN ln -s /usr/bin/python3 /usr/bin/python & \
+    ln -s /usr/bin/pip3 /usr/bin/pip
+
 WORKDIR /scratch
 COPY script/wasm-deps.sh .
 RUN chmod a+x ./wasm-deps.sh && sleep 1 && ./wasm-deps.sh
 
 WORKDIR /app
-COPY Cargo.toml Cargo.lock rust-toolchain ./
-RUN cargo install wasm-pack
 
 COPY . .
-
+RUN cargo install wasm-pack
 RUN chmod a+x ./script/plume-front.sh && sleep 1 && ./script/plume-front.sh
 RUN cargo install --path ./ --force --no-default-features --features postgres
 RUN cargo install --path plume-cli --force --no-default-features --features postgres
 RUN cargo clean
 
-FROM debian:buster-slim
+FROM debian:stable-slim
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates \
-    libpq5 \
+    libpq5
-    libssl1.1
 
 WORKDIR /app
 

README.md

@@ -1,10 +1,10 @@
 <h1 align="center">
-  <img src="https://raw.githubusercontent.com/Plume-org/Plume/master/assets/icons/trwnh/feather/plumeFeather64.png" alt="Plume's logo">
+  <img src="https://raw.githubusercontent.com/Plume-org/Plume/main/assets/icons/trwnh/feather/plumeFeather64.png" alt="Plume's logo">
   Plume
 </h1>
 <p align="center">
   <a href="https://github.com/Plume-org/Plume/"><img alt="CircleCI" src="https://img.shields.io/circleci/build/gh/Plume-org/Plume.svg"></a>
-  <a href="https://codecov.io/gh/Plume-org/Plume"><img src="https://codecov.io/gh/Plume-org/Plume/branch/master/graph/badge.svg" alt="Code coverage"></a>
+  <a href="https://codecov.io/gh/Plume-org/Plume"><img src="https://codecov.io/gh/Plume-org/Plume/branch/main/graph/badge.svg" alt="Code coverage"></a>
   <a title="Crowdin" target="_blank" href="https://crowdin.com/project/plume"><img src="https://d322cqt584bo4o.cloudfront.net/plume/localized.svg"></a>
   <a href="https://hub.docker.com/r/plumeorg/plume"><img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/plumeorg/plume.svg"></a>
   <a href="https://liberapay.com/Plume"><img alt="Liberapay patrons" src="https://img.shields.io/liberapay/patrons/Plume.svg"></a>

assets/themes/default/_article.scss

@@ -98,7 +98,7 @@ main article {
   }
 
   blockquote {
-    border-inline-start: 5px solid $gray;
+    border-inline-start: 5px solid $lightpurple;
     margin: 1em auto;
     padding: 0em 2em;
   }
@@ -228,7 +228,7 @@ main .article-meta {
       fill: currentColor;
     }
     .action.liked:hover svg.feather {
-      background: transparentize($red, 0.75)
+      background: transparentize($red, 0.75);
       color: $red;
     }
   }
@@ -252,7 +252,7 @@ main .article-meta {
       background: $primary;
     }
     .action.reshared:hover svg.feather {
-      background: transparentize($primary, 0.75)
+      background: transparentize($primary, 0.75);
       color: $primary;
     }
   }

assets/themes/default/_forms.scss

@@ -135,6 +135,7 @@ form.new-post {
 
 .button + .button {
   margin-left: 1em;
+  margin-inline-start: 1em;
 }
 
 .split {

assets/themes/default/_header.scss

@@ -37,6 +37,10 @@ body > header {
     flex-direction: row;
     align-items: center;
 
+    &.right-nav {
+      overflow-x: hidden;
+    }
+
     hr {
       height: 100%;
       width: 0.2em;

assets/themes/default/_tables.scss

@@ -0,0 +1,10 @@
+/* tables */
+table, td, th, tr {
+  border: 1px dotted $lightpurple;
+}
+
+table {
+  border-collapse: collapse;
+}
+
+tr:nth-child(even){background-color: $gray;}

assets/themes/default/dark.scss

@@ -12,3 +12,4 @@
 @import "header";
 @import "article";
 @import "forms";
+@import "tables";

assets/themes/default/light.scss

@@ -12,3 +12,4 @@
 @import "header";
 @import "article";
 @import "forms";
+@import "tables";

entrypoint.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+set -eu
+
+ENV_FILE=/app/.env
+
+cat > "$ENV_FILE" <<EOF
+BASE_URL=blog.lainoa.eus
+ROCKET_SECRET_KEY=${ROCKET_SECRET_KEY}
+
+MAIL_SERVER=smtp.lainoa.eus
+MAIL_USER=aitzol
+MAIL_PASSWORD=${EMAIL_PASSWORD}
+
+POSTGRES_USER=plume
+POSTGRES_DB=plume
+POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+
+DATABASE_URL=postgres://plume:${POSTGRES_PASSWORD}@postgres:5432/plume
+MIGRATION_DIRECTORY=migrations/postgres
+USE_HTTPS=1
+ROCKET_ADDRESS=0.0.0.0
+ROCKET_PORT=7878
+
+LDAP_ADDR=ldaps://ldap.lainoa.eus:636
+LDAP_BASE_DN=cn=users,ou=groups,dc=ldap,dc=lainoa,dc=eus
+LDAP_USER_NAME_ATTR=uid
+LDAP_USER_MAIL_ATTR=mail
+LDAP_TLS=true
+LDAP_USER=cn=readonly,dc=ldap,dc=lainoa,dc=eus
+LDAP_PASSWORD=${LDAP_PASSWORD}
+
+RUST_BACTRACE=1
+
+EOF
+
+chmod 600 "$ENV_FILE"
+
+exec "$@"

flake.lock

@@ -0,0 +1,116 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1681202837,
+        "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "cfacdce06f30d2b68473a46042957675eebb3401",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "inputs": {
+        "systems": "systems_2"
+      },
+      "locked": {
+        "lastModified": 1681202837,
+        "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "cfacdce06f30d2b68473a46042957675eebb3401",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1683408522,
+        "narHash": "sha256-9kcPh6Uxo17a3kK3XCHhcWiV1Yu1kYj22RHiymUhMkU=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "897876e4c484f1e8f92009fd11b7d988a121a4e7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "flake-utils": "flake-utils_2",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1683857898,
+        "narHash": "sha256-pyVY4UxM6zUX97g6bk6UyCbZGCWZb2Zykrne8YxacRA=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "4e7fba3f37f5e184ada0ef3cf1e4d8ef450f240b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,60 @@
+{
+  description = "Developpment shell for Plume including nightly Rust compiler";
+
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  inputs.rust-overlay = {
+    url = "github:oxalica/rust-overlay";
+    inputs.nixpkgs.follows = "nixpkgs";
+  };
+  inputs.flake-utils.url = "github:numtide/flake-utils";
+
+  outputs = { self, nixpkgs, flake-utils, rust-overlay, ... }:
+    flake-utils.lib.eachDefaultSystem (system:
+    let
+      overlays = [ (import rust-overlay) ];
+      pkgs = import nixpkgs { inherit system overlays; };
+      inputs = with pkgs; [
+            (rust-bin.nightly.latest.default.override {
+              targets = [ "wasm32-unknown-unknown" ];
+            })
+            wasm-pack
+            openssl
+            pkg-config
+            gettext
+            postgresql
+            sqlite
+          ];
+      in {
+        packages.default = pkgs.rustPlatform.buildRustPackage {
+          pname = "plume";
+          version = "0.7.3-dev";
+
+          src = ./.;
+
+          cargoLock = {
+            lockFile = ./Cargo.lock;
+            outputHashes = {
+              "pulldown-cmark-0.8.0" = "sha256-lpfoRDuY3zJ3QmUqJ5k9OL0MEdGDpwmpJ+u5BCj2kIA=";
+              "rocket_csrf-0.1.2" = "sha256-WywZfMiwZqTPfSDcAE7ivTSYSaFX+N9fjnRsLSLb9wE=";
+            };
+          };
+          buildNoDefaultFeatures = true;
+          buildFeatures = ["postgresql" "s3"];
+
+          nativeBuildInputs = inputs;
+
+          buildPhase = ''
+			wasm-pack build --target web --release plume-front
+			cargo build --no-default-features --features postgresql,s3 --path .
+			cargo build --no-default-features --features postgresql,s3 --path plume-cli
+          '';
+          installPhase = ''
+			cargo install --no-default-features --features postgresql,s3 --path . --target-dir $out
+			cargo install --no-default-features --features postgresql,s3 --path plume-cli --target-dir $out
+		  '';
+        };
+        devShells.default = pkgs.mkShell {
+          packages = inputs;
+        };
+      });
+}

plume-api/Cargo.toml

@@ -5,5 +5,5 @@ authors = ["Plume contributors"]
 edition = "2018"
 
 [dependencies]
-serde = "1.0"
+serde = "1.0.137"
 serde_derive = "1.0"

plume-api/release.toml

@@ -1,2 +1,3 @@
 pre-release-hook = ["cargo", "fmt"]
 pre-release-replacements = []
+release = false

plume-cli/Cargo.toml

@@ -24,3 +24,4 @@ path = "../plume-models"
 postgres = ["plume-models/postgres", "diesel/postgres"]
 sqlite = ["plume-models/sqlite", "diesel/sqlite"]
 search-lindera = ["plume-models/search-lindera"]
+s3 = ["plume-models/s3"]

plume-cli/release.toml

@@ -1,2 +1,3 @@
 pre-release-hook = ["cargo", "fmt"]
 pre-release-replacements = []
+release = false

plume-cli/src/list.rs

@@ -0,0 +1,262 @@
+use clap::{App, Arg, ArgMatches, SubCommand};
+
+use plume_models::{blogs::Blog, instance::Instance, lists::*, users::User, Connection};
+
+pub fn command<'a, 'b>() -> App<'a, 'b> {
+    SubCommand::with_name("lists")
+        .about("Manage lists")
+        .subcommand(
+            SubCommand::with_name("new")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of this list"),
+                )
+                .arg(
+                    Arg::with_name("type")
+                        .short("t")
+                        .long("type")
+                        .takes_value(true)
+                        .help(
+                            r#"The type of this list (one of "user", "blog", "word" or "prefix")"#,
+                        ),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help("Username of whom this list is for. Empty for an instance list"),
+                )
+                .about("Create a new list"),
+        )
+        .subcommand(
+            SubCommand::with_name("delete")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of the list to delete"),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help("Username of whom this list was for. Empty for instance list"),
+                )
+                .arg(
+                    Arg::with_name("yes")
+                        .short("y")
+                        .long("yes")
+                        .help("Confirm the deletion"),
+                )
+                .about("Delete a list"),
+        )
+        .subcommand(
+            SubCommand::with_name("add")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of the list to add an element to"),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help("Username of whom this list is for. Empty for instance list"),
+                )
+                .arg(
+                    Arg::with_name("value")
+                        .short("v")
+                        .long("value")
+                        .takes_value(true)
+                        .help("The value to add"),
+                )
+                .about("Add element to a list"),
+        )
+        .subcommand(
+            SubCommand::with_name("rm")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of the list to remove an element from"),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help("Username of whom this list is for. Empty for instance list"),
+                )
+                .arg(
+                    Arg::with_name("value")
+                        .short("v")
+                        .long("value")
+                        .takes_value(true)
+                        .help("The value to remove"),
+                )
+                .about("Remove element from list"),
+        )
+}
+
+pub fn run<'a>(args: &ArgMatches<'a>, conn: &Connection) {
+    let conn = conn;
+    match args.subcommand() {
+        ("new", Some(x)) => new(x, conn),
+        ("delete", Some(x)) => delete(x, conn),
+        ("add", Some(x)) => add(x, conn),
+        ("rm", Some(x)) => rm(x, conn),
+        ("", None) => command().print_help().unwrap(),
+        _ => println!("Unknown subcommand"),
+    }
+}
+
+fn get_list_identifier(args: &ArgMatches<'_>) -> (String, Option<String>) {
+    let name = args
+        .value_of("name")
+        .map(String::from)
+        .expect("No name provided for the list");
+    let user = args.value_of("user").map(String::from);
+    (name, user)
+}
+
+fn get_list_type(args: &ArgMatches<'_>) -> ListType {
+    let typ = args
+        .value_of("type")
+        .map(String::from)
+        .expect("No name type for the list");
+    match typ.as_str() {
+        "user" => ListType::User,
+        "blog" => ListType::Blog,
+        "word" => ListType::Word,
+        "prefix" => ListType::Prefix,
+        _ => panic!("Invalid list type: {}", typ),
+    }
+}
+
+fn get_value(args: &ArgMatches<'_>) -> String {
+    args.value_of("value")
+        .map(String::from)
+        .expect("No query provided")
+}
+
+fn resolve_user(username: &str, conn: &Connection) -> User {
+    let instance = Instance::get_local_uncached(conn).expect("Failed to load local instance");
+
+    User::find_by_name(conn, username, instance.id).expect("User not found")
+}
+
+fn new(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_list_identifier(args);
+    let typ = get_list_type(args);
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    List::new(conn, &name, user.as_ref(), typ).expect("failed to create list");
+}
+
+fn delete(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_list_identifier(args);
+
+    if !args.is_present("yes") {
+        panic!("Warning, this operation is destructive. Add --yes to confirm you want to do it.")
+    }
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    let list =
+        List::find_for_user_by_name(conn, user.map(|u| u.id), &name).expect("list not found");
+
+    list.delete(conn).expect("Failed to update list");
+}
+
+fn add(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_list_identifier(args);
+    let value = get_value(args);
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    let list =
+        List::find_for_user_by_name(conn, user.map(|u| u.id), &name).expect("list not found");
+
+    match list.kind() {
+        ListType::Blog => {
+            let blog_id = Blog::find_by_fqn(conn, &value).expect("unknown blog").id;
+            if !list.contains_blog(conn, blog_id).unwrap() {
+                list.add_blogs(conn, &[blog_id]).unwrap();
+            }
+        }
+        ListType::User => {
+            let user_id = User::find_by_fqn(conn, &value).expect("unknown user").id;
+            if !list.contains_user(conn, user_id).unwrap() {
+                list.add_users(conn, &[user_id]).unwrap();
+            }
+        }
+        ListType::Word => {
+            if !list.contains_word(conn, &value).unwrap() {
+                list.add_words(conn, &[&value]).unwrap();
+            }
+        }
+        ListType::Prefix => {
+            if !list.contains_prefix(conn, &value).unwrap() {
+                list.add_prefixes(conn, &[&value]).unwrap();
+            }
+        }
+    }
+}
+
+fn rm(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_list_identifier(args);
+    let value = get_value(args);
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    let list =
+        List::find_for_user_by_name(conn, user.map(|u| u.id), &name).expect("list not found");
+
+    match list.kind() {
+        ListType::Blog => {
+            let blog_id = Blog::find_by_fqn(conn, &value).expect("unknown blog").id;
+            let mut blogs = list.list_blogs(conn).unwrap();
+            if let Some(index) = blogs.iter().position(|b| b.id == blog_id) {
+                blogs.swap_remove(index);
+                let blogs = blogs.iter().map(|b| b.id).collect::<Vec<_>>();
+                list.set_blogs(conn, &blogs).unwrap();
+            }
+        }
+        ListType::User => {
+            let user_id = User::find_by_fqn(conn, &value).expect("unknown user").id;
+            let mut users = list.list_users(conn).unwrap();
+            if let Some(index) = users.iter().position(|u| u.id == user_id) {
+                users.swap_remove(index);
+                let users = users.iter().map(|u| u.id).collect::<Vec<_>>();
+                list.set_users(conn, &users).unwrap();
+            }
+        }
+        ListType::Word => {
+            let mut words = list.list_words(conn).unwrap();
+            if let Some(index) = words.iter().position(|w| *w == value) {
+                words.swap_remove(index);
+                let words = words.iter().map(String::as_str).collect::<Vec<_>>();
+                list.set_words(conn, &words).unwrap();
+            }
+        }
+        ListType::Prefix => {
+            let mut prefixes = list.list_prefixes(conn).unwrap();
+            if let Some(index) = prefixes.iter().position(|p| *p == value) {
+                prefixes.swap_remove(index);
+                let prefixes = prefixes.iter().map(String::as_str).collect::<Vec<_>>();
+                list.set_prefixes(conn, &prefixes).unwrap();
+            }
+        }
+    }
+}

plume-cli/src/main.rs

@@ -4,8 +4,10 @@ use plume_models::{instance::Instance, Connection as Conn, CONFIG};
 use std::io::{self, prelude::*};
 
 mod instance;
+mod list;
 mod migration;
 mod search;
+mod timeline;
 mod users;
 
 fn main() {
@@ -16,6 +18,8 @@ fn main() {
         .subcommand(instance::command())
         .subcommand(migration::command())
         .subcommand(search::command())
+        .subcommand(timeline::command())
+        .subcommand(list::command())
         .subcommand(users::command());
     let matches = app.clone().get_matches();
 
@@ -37,6 +41,10 @@ fn main() {
         ("search", Some(args)) => {
             search::run(args, &conn.expect("Couldn't connect to the database."))
         }
+        ("timeline", Some(args)) => {
+            timeline::run(args, &conn.expect("Couldn't connect to the database."))
+        }
+        ("lists", Some(args)) => list::run(args, &conn.expect("Couldn't connect to the database.")),
         ("users", Some(args)) => {
             users::run(args, &conn.expect("Couldn't connect to the database."))
         }

plume-cli/src/timeline.rs

@@ -0,0 +1,257 @@
+use clap::{App, Arg, ArgMatches, SubCommand};
+
+use plume_models::{instance::Instance, posts::Post, timeline::*, users::*, Connection};
+
+pub fn command<'a, 'b>() -> App<'a, 'b> {
+    SubCommand::with_name("timeline")
+        .about("Manage public timeline")
+        .subcommand(
+            SubCommand::with_name("new")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of this timeline"),
+                )
+                .arg(
+                    Arg::with_name("query")
+                        .short("q")
+                        .long("query")
+                        .takes_value(true)
+                        .help("The query posts in this timelines have to match"),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help(
+                            "Username of whom this timeline is for. Empty for an instance timeline",
+                        ),
+                )
+                .arg(
+                    Arg::with_name("preload-count")
+                        .short("p")
+                        .long("preload-count")
+                        .takes_value(true)
+                        .help("Number of posts to try to preload in this timeline at its creation"),
+                )
+                .about("Create a new timeline"),
+        )
+        .subcommand(
+            SubCommand::with_name("delete")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of the timeline to delete"),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help(
+                            "Username of whom this timeline was for. Empty for instance timeline",
+                        ),
+                )
+                .arg(
+                    Arg::with_name("yes")
+                        .short("y")
+                        .long("yes")
+                        .help("Confirm the deletion"),
+                )
+                .about("Delete a timeline"),
+        )
+        .subcommand(
+            SubCommand::with_name("edit")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of the timeline to edit"),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help("Username of whom this timeline is for. Empty for instance timeline"),
+                )
+                .arg(
+                    Arg::with_name("query")
+                        .short("q")
+                        .long("query")
+                        .takes_value(true)
+                        .help("The query posts in this timelines have to match"),
+                )
+                .about("Edit the query of a timeline"),
+        )
+        .subcommand(
+            SubCommand::with_name("repopulate")
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .takes_value(true)
+                        .help("The name of the timeline to repopulate"),
+                )
+                .arg(
+                    Arg::with_name("user")
+                        .short("u")
+                        .long("user")
+                        .takes_value(true)
+                        .help(
+                            "Username of whom this timeline was for. Empty for instance timeline",
+                        ),
+                )
+                .arg(
+                    Arg::with_name("preload-count")
+                        .short("p")
+                        .long("preload-count")
+                        .takes_value(true)
+                        .help("Number of posts to try to preload in this timeline at its creation"),
+                )
+                .about("Repopulate a timeline. Run this after modifying a list the timeline depends on."),
+        )
+}
+
+pub fn run<'a>(args: &ArgMatches<'a>, conn: &Connection) {
+    let conn = conn;
+    match args.subcommand() {
+        ("new", Some(x)) => new(x, conn),
+        ("edit", Some(x)) => edit(x, conn),
+        ("delete", Some(x)) => delete(x, conn),
+        ("repopulate", Some(x)) => repopulate(x, conn),
+        ("", None) => command().print_help().unwrap(),
+        _ => println!("Unknown subcommand"),
+    }
+}
+
+fn get_timeline_identifier(args: &ArgMatches<'_>) -> (String, Option<String>) {
+    let name = args
+        .value_of("name")
+        .map(String::from)
+        .expect("No name provided for the timeline");
+    let user = args.value_of("user").map(String::from);
+    (name, user)
+}
+
+fn get_query(args: &ArgMatches<'_>) -> String {
+    let query = args
+        .value_of("query")
+        .map(String::from)
+        .expect("No query provided");
+
+    match TimelineQuery::parse(&query) {
+        Ok(_) => (),
+        Err(QueryError::SyntaxError(start, end, message)) => panic!(
+            "Query parsing error between {} and {}: {}",
+            start, end, message
+        ),
+        Err(QueryError::UnexpectedEndOfQuery) => {
+            panic!("Query parsing error: unexpected end of query")
+        }
+        Err(QueryError::RuntimeError(message)) => panic!("Query parsing error: {}", message),
+    }
+
+    query
+}
+
+fn get_preload_count(args: &ArgMatches<'_>) -> usize {
+    args.value_of("preload-count")
+        .map(|arg| arg.parse().expect("invalid preload-count"))
+        .unwrap_or(plume_models::ITEMS_PER_PAGE as usize)
+}
+
+fn resolve_user(username: &str, conn: &Connection) -> User {
+    let instance = Instance::get_local_uncached(conn).expect("Failed to load local instance");
+
+    User::find_by_name(conn, username, instance.id).expect("User not found")
+}
+
+fn preload(timeline: Timeline, count: usize, conn: &Connection) {
+    timeline.remove_all_posts(conn).unwrap();
+
+    if count == 0 {
+        return;
+    }
+
+    let mut posts = Vec::with_capacity(count as usize);
+    for post in Post::list_filtered(conn, None, None, None)
+        .unwrap()
+        .into_iter()
+        .rev()
+    {
+        if timeline.matches(conn, &post, Kind::Original).unwrap() {
+            posts.push(post);
+            if posts.len() >= count {
+                break;
+            }
+        }
+    }
+
+    for post in posts.iter().rev() {
+        timeline.add_post(conn, post).unwrap();
+    }
+}
+
+fn new(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_timeline_identifier(args);
+    let query = get_query(args);
+    let preload_count = get_preload_count(args);
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    let timeline = if let Some(user) = user {
+        Timeline::new_for_user(conn, user.id, name, query)
+    } else {
+        Timeline::new_for_instance(conn, name, query)
+    }
+    .expect("Failed to create new timeline");
+
+    preload(timeline, preload_count, conn);
+}
+
+fn edit(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_timeline_identifier(args);
+    let query = get_query(args);
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    let mut timeline = Timeline::find_for_user_by_name(conn, user.map(|u| u.id), &name)
+        .expect("timeline not found");
+
+    timeline.query = query;
+
+    timeline.update(conn).expect("Failed to update timeline");
+}
+
+fn delete(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_timeline_identifier(args);
+
+    if !args.is_present("yes") {
+        panic!("Warning, this operation is destructive. Add --yes to confirm you want to do it.")
+    }
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    let timeline = Timeline::find_for_user_by_name(conn, user.map(|u| u.id), &name)
+        .expect("timeline not found");
+
+    timeline.delete(conn).expect("Failed to update timeline");
+}
+
+fn repopulate(args: &ArgMatches<'_>, conn: &Connection) {
+    let (name, user) = get_timeline_identifier(args);
+    let preload_count = get_preload_count(args);
+
+    let user = user.map(|user| resolve_user(&user, conn));
+
+    let timeline = Timeline::find_for_user_by_name(conn, user.map(|u| u.id), &name)
+        .expect("timeline not found");
+    preload(timeline, preload_count, conn);
+}

plume-common/Cargo.toml

@@ -7,29 +7,28 @@ edition = "2018"
 [dependencies]
 array_tool = "1.0"
 base64 = "0.13"
-heck = "0.4.0"
 hex = "0.4"
 openssl = "0.10.40"
-rocket = "0.4.6"
+rocket = "0.4.11"
-reqwest = { version = "0.11.10", features = ["blocking", "json", "socks"] }
+reqwest = { version = "0.11.11", features = ["blocking", "json", "socks"] }
-serde = "1.0"
+serde = "1.0.137"
 serde_derive = "1.0"
 serde_json = "1.0.81"
 shrinkwraprs = "0.3.0"
 syntect = "4.5.0"
-regex-syntax = { version = "0.6.17", default-features = false, features = ["unicode-perl"] }
+regex-syntax = { version = "0.6.26", default-features = false, features = ["unicode-perl"] }
-tracing = "0.1.34"
+tracing = "0.1.35"
 askama_escape = "0.10.3"
-activitystreams = "0.7.0-alpha.18"
+activitystreams = "=0.7.0-alpha.20"
 activitystreams-ext = "0.1.0-alpha.2"
 url = "2.2.2"
-flume = "0.10.12"
+flume = "0.10.13"
-tokio = { version = "1.18.2", features = ["full"] }
+tokio = { version = "1.19.2", features = ["full"] }
-futures = "0.3.21"
+futures = "0.3.25"
 
 [dependencies.chrono]
 features = ["serde"]
-version = "0.4"
+version = "0.4.31"
 
 [dependencies.pulldown-cmark]
 default-features = false
@@ -38,6 +37,6 @@ branch = "bidi-plume"
 
 [dev-dependencies]
 assert-json-diff = "2.0.1"
-once_cell = "1.10.0"
+once_cell = "1.12.0"
 
 [features]

plume-common/release.toml

@@ -1,2 +1,3 @@
 pre-release-hook = ["cargo", "fmt"]
 pre-release-replacements = []
+release = false

plume-common/src/activity_pub/inbox.rs

@@ -561,7 +561,7 @@ mod tests {
     use once_cell::sync::Lazy;
     use openssl::{hash::MessageDigest, pkey::PKey, rsa::Rsa};
 
-    static MY_SIGNER: Lazy<MySigner> = Lazy::new(|| MySigner::new());
+    static MY_SIGNER: Lazy<MySigner> = Lazy::new(MySigner::new);
 
     struct MySigner {
         public_key: String,
@@ -596,7 +596,7 @@ mod tests {
                 .unwrap();
             let mut verifier = openssl::sign::Verifier::new(MessageDigest::sha256(), &key).unwrap();
             verifier.update(data.as_bytes()).unwrap();
-            verifier.verify(&signature).map_err(|_| SignError())
+            verifier.verify(signature).map_err(|_| SignError())
         }
     }
 
@@ -782,7 +782,7 @@ mod tests {
             .done();
         assert!(res.is_err());
 
-        let res: Result<(), ()> = Inbox::handle(&(), act.clone())
+        let res: Result<(), ()> = Inbox::handle(&(), act)
             .with::<FailingActor, Create, MyObject>(None)
             .with::<MyActor, Create, MyObject>(None)
             .done();

plume-common/src/activity_pub/mod.rs

@@ -518,7 +518,8 @@ mod tests {
     use super::*;
     use activitystreams::{
         activity::{ActorAndObjectRef, Create},
-        object::kind::ArticleType,
+        object::{kind::ArticleType, Image},
+        prelude::{ApActorExt, BaseExt, ExtendsExt, ObjectExt},
     };
     use assert_json_diff::assert_json_eq;
     use serde_json::{from_str, json, to_value};
@@ -592,7 +593,7 @@ mod tests {
     }
 
     #[test]
-    fn de_custom_group() {
+    fn se_custom_group() {
         let group = CustomGroup::new(
             ApActor::new("https://example.com/inbox".parse().unwrap(), Group::new()),
             ApSignature {
@@ -625,6 +626,71 @@ mod tests {
         assert_eq!(to_value(group).unwrap(), expected);
     }
 
+    #[test]
+    fn de_custom_group() {
+        let value: CustomGroup = from_str(
+            r#"
+              {
+                "icon": {
+                  "type": "Image"
+                },
+                "id": "https://plume01.localhost/~/Plume01%20Blog%202/",
+                "image": {
+                  "type": "Image"
+                },
+                "inbox": "https://plume01.localhost/~/Plume01%20Blog%202/inbox",
+                "name": "Plume01 Blog 2",
+                "outbox": "https://plume01.localhost/~/Plume01%20Blog%202/outbox",
+                "preferredUsername": "Plume01 Blog 2",
+                "publicKey": {
+                  "id": "https://plume01.localhost/~/Plume01%20Blog%202/#main-key",
+                  "owner": "https://plume01.localhost/~/Plume01%20Blog%202/",
+                  "publicKeyPem": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwPGtKkl/iMsNAyeVaJGz\noEz5PoNkjRnKK7G97MFvb4zw9zs5SpzWW7b/pKHa4dODcGDJXmkCJ1H5JWyguzN8\n2GNoFjtEOJHxEGwBHSYDsTmhuLNB0DKxMU2iu55g8iIiXhZiIW1FBNGs/Geaymvr\nh/TEtzdReN8wzloRR55kOVcU49xBkqx8cfDSk/lrrDLlpveHdqgaFnIvuw2vycK0\nxFzS3xlEUpzJk9kHxoR1uEAfZ+gCv26Sgo/HqOAhqSD5IU3QZC3kdkr/hwVqtr8U\nXGkGG6Mo1rgzhkYiCFkWrV2WoKkcEHD4nEzbgoZZ5MyuSoloxnyF3NiScqmqW+Yx\nkQIDAQAB\n-----END PUBLIC KEY-----\n"
+                },
+                "source": {
+                  "content": "",
+                  "mediaType": "text/markdown"
+                },
+                "summary": "",
+                "type": "Group"
+              }
+            "#
+        ).unwrap();
+        let mut expected = CustomGroup::new(
+            ApActor::new("https://plume01.localhost/~/Plume01%20Blog%202/inbox".parse().unwrap(), Group::new()),
+            ApSignature {
+                public_key: PublicKey {
+                    id: "https://plume01.localhost/~/Plume01%20Blog%202/#main-key".parse().unwrap(),
+                    owner: "https://plume01.localhost/~/Plume01%20Blog%202/".parse().unwrap(),
+                    public_key_pem: "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwPGtKkl/iMsNAyeVaJGz\noEz5PoNkjRnKK7G97MFvb4zw9zs5SpzWW7b/pKHa4dODcGDJXmkCJ1H5JWyguzN8\n2GNoFjtEOJHxEGwBHSYDsTmhuLNB0DKxMU2iu55g8iIiXhZiIW1FBNGs/Geaymvr\nh/TEtzdReN8wzloRR55kOVcU49xBkqx8cfDSk/lrrDLlpveHdqgaFnIvuw2vycK0\nxFzS3xlEUpzJk9kHxoR1uEAfZ+gCv26Sgo/HqOAhqSD5IU3QZC3kdkr/hwVqtr8U\nXGkGG6Mo1rgzhkYiCFkWrV2WoKkcEHD4nEzbgoZZ5MyuSoloxnyF3NiScqmqW+Yx\nkQIDAQAB\n-----END PUBLIC KEY-----\n".into(),
+                }
+            },
+            SourceProperty {
+                source: Source {
+                    content: String::from(""),
+                    media_type: String::from("text/markdown")
+                }
+            }
+        );
+        expected.set_icon(Image::new().into_any_base().unwrap());
+        expected.set_id(
+            "https://plume01.localhost/~/Plume01%20Blog%202/"
+                .parse()
+                .unwrap(),
+        );
+        expected.set_image(Image::new().into_any_base().unwrap());
+        expected.set_name("Plume01 Blog 2");
+        expected.set_outbox(
+            "https://plume01.localhost/~/Plume01%20Blog%202/outbox"
+                .parse()
+                .unwrap(),
+        );
+        expected.set_preferred_username("Plume01 Blog 2");
+        expected.set_summary("");
+
+        assert_json_eq!(value, expected);
+    }
+
     #[test]
     fn se_licensed_article() {
         let object = ApObject::new(Article::new());

plume-common/src/activity_pub/request.rs

@@ -253,7 +253,7 @@ mod tests {
                 .unwrap();
             let mut verifier = openssl::sign::Verifier::new(MessageDigest::sha256(), &key).unwrap();
             verifier.update(data.as_bytes()).unwrap();
-            verifier.verify(&signature).map_err(|_| Error())
+            verifier.verify(signature).map_err(|_| Error())
         }
     }
 
@@ -262,7 +262,7 @@ mod tests {
         let signer = MySigner::new();
         let headers = HeaderMap::new();
         let result = signature(&signer, &headers, ("post", "/inbox", None)).unwrap();
-        let fields: Vec<&str> = result.to_str().unwrap().split(",").collect();
+        let fields: Vec<&str> = result.to_str().unwrap().split(',').collect();
         assert_eq!(r#"headers="(request-target)""#, fields[2]);
         let sign = &fields[3][11..(fields[3].len() - 1)];
         assert!(signer.verify("post /inbox", sign.as_bytes()).is_ok());

plume-common/src/activity_pub/sign.rs

@@ -119,7 +119,7 @@ impl Signable for serde_json::Value {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum SignatureValidity {
     Invalid,
     ValidNoDigest,

plume-common/src/utils.rs

@@ -1,4 +1,3 @@
-use heck::ToUpperCamelCase;
 use openssl::rand::rand_bytes;
 use pulldown_cmark::{html, CodeBlockKind, CowStr, Event, LinkType, Options, Parser, Tag};
 use regex_syntax::is_word_character;
@@ -16,14 +15,6 @@ pub fn random_hex() -> String {
         .fold(String::new(), |res, byte| format!("{}{:x}", res, byte))
 }
 
-/// Remove non alphanumeric characters and CamelCase a string
-pub fn make_actor_id(name: &str) -> String {
-    name.to_upper_camel_case()
-        .chars()
-        .filter(|c| c.is_alphanumeric())
-        .collect()
-}
-
 /**
  * Percent-encode characters which are not allowed in IRI path segments.
  *

plume-front/Cargo.toml

@@ -2,7 +2,10 @@
 name = "plume-front"
 version = "0.7.2"
 authors = ["Plume contributors"]
-edition = "2018"
+edition = "2021"
+
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = false
 
 [lib]
 crate-type = ["cdylib"]
@@ -12,15 +15,15 @@ gettext = "0.4.0"
 gettext-macros = "0.6.1"
 gettext-utils = "0.1.0"
 lazy_static = "1.3"
-serde = "1.0"
+serde = "1.0.137"
 serde_json = "1.0"
-wasm-bindgen = "0.2.80"
+wasm-bindgen = "0.2.99"
-js-sys = "0.3.57"
+js-sys = "0.3.76"
 serde_derive = "1.0.123"
 console_error_panic_hook = "0.1.6"
 
 [dependencies.web-sys]
-version = "0.3.57"
+version = "0.3.76"
 features = [
   'console',
   'ClipboardEvent',

plume-front/release.toml

@@ -1,2 +1,3 @@
 pre-release-hook = ["cargo", "fmt"]
 pre-release-replacements = []
+release = false

plume-front/src/editor.rs

@@ -168,10 +168,14 @@ fn load_autosave() {
         .get(&get_autosave_id())
     {
         let autosave_info: AutosaveInformation = serde_json::from_str(&autosave_str).ok().unwrap();
+        let d = &JsValue::from_f64(autosave_info.last_saved);
+
         let message = i18n!(
             CATALOG,
             "Do you want to load the local autosave last edited at {}?";
-            Date::new(&JsValue::from_f64(autosave_info.last_saved)).to_date_string().as_string().unwrap()
+            // next line shows 'unexpected token' error on docker image building
+            //Date::new(&JsValue::from_f64(autosave_info.last_saved)).to_date_string().as_string().unwrap()
+            Date::new(d).to_date_string().as_string().unwrap()
         );
         if let Ok(true) = window().unwrap().confirm_with_message(&message) {
             set_value("editor-content", &autosave_info.contents);

plume-macro/release.toml

@@ -1,2 +1,3 @@
 pre-release-hook = ["cargo", "fmt"]
 pre-release-replacements = []
+release = false

plume-models/Cargo.toml

@@ -7,38 +7,41 @@ edition = "2018"
 [dependencies]
 ammonia = "3.2.0"
 bcrypt = "0.12.1"
-guid-create = "0.2"
+guid-create = "0.3.0"
 itertools = "0.10.3"
 lazy_static = "1.0"
-ldap3 = "0.10.4"
+ldap3 = "0.11.1"
 migrations_internals= "1.4.0"
 openssl = "0.10.40"
-rocket = "0.4.6"
+rocket = "0.4.11"
 rocket_i18n = "0.4.1"
-reqwest = "0.11.10"
+reqwest = "0.11.11"
-scheduled-thread-pool = "0.2.2"
+scheduled-thread-pool = "0.2.7"
-serde = "1.0"
+serde = "1.0.137"
+rust-s3 = { version = "0.33.0", optional = true, features = ["blocking"] }
 serde_derive = "1.0"
 serde_json = "1.0.81"
 tantivy = "0.13.3"
 url = "2.1"
 walkdir = "2.2"
 webfinger = "0.4.1"
-whatlang = "0.16.0"
+whatlang = "0.16.2"
 shrinkwraprs = "0.3.0"
-diesel-derive-newtype = "0.1.2"
+diesel-derive-newtype = "1.0.0"
-glob = "0.3.0"
+glob = "0.3.1"
 lindera-tantivy = { version = "0.7.1", optional = true }
-tracing = "0.1.34"
+tracing = "0.1.35"
 riker = "0.4.2"
-once_cell = "1.10.0"
+once_cell = "1.12.0"
 lettre = "0.9.6"
 native-tls = "0.2.10"
-activitystreams = "0.7.0-alpha.18"
+activitystreams = "=0.7.0-alpha.20"
+ahash = "=0.8.11"
+heck = "0.4.1"
 
 [dependencies.chrono]
 features = ["serde"]
-version = "0.4"
+version = "0.4.31"
 
 [dependencies.diesel]
 features = ["r2d2", "chrono"]
@@ -61,3 +64,4 @@ diesel_migrations = "1.3.0"
 postgres = ["diesel/postgres", "plume-macro/postgres" ]
 sqlite = ["diesel/sqlite", "plume-macro/sqlite" ]
 search-lindera = ["lindera-tantivy"]
+s3 = ["rust-s3"]

plume-models/release.toml

@@ -1,2 +1,3 @@
 pre-release-hook = ["cargo", "fmt"]
 pre-release-replacements = []
+release = false

plume-models/src/admin.rs

@@ -5,7 +5,7 @@ use rocket::{
     Outcome,
 };
 
-/// Wrapper around User to use as a request guard on pages reserved to admins.
+/// Wrapper around User to use as a request guard on pages exclusively reserved to admins.
 pub struct Admin(pub User);
 
 impl<'a, 'r> FromRequest<'a, 'r> for Admin {
@@ -21,6 +21,23 @@ impl<'a, 'r> FromRequest<'a, 'r> for Admin {
     }
 }
 
+/// Same as `Admin` but it forwards to next guard if the user is not an admin.
+/// It's useful when there are multiple implementations of routes for admin and moderator.
+pub struct InclusiveAdmin(pub User);
+
+impl<'a, 'r> FromRequest<'a, 'r> for InclusiveAdmin {
+    type Error = ();
+
+    fn from_request(request: &'a Request<'r>) -> request::Outcome<InclusiveAdmin, ()> {
+        let user = request.guard::<User>()?;
+        if user.is_admin() {
+            Outcome::Success(InclusiveAdmin(user))
+        } else {
+            Outcome::Forward(())
+        }
+    }
+}
+
 /// Same as `Admin` but for moderators.
 pub struct Moderator(pub User);
 

plume-models/src/api_tokens.rs

@@ -103,7 +103,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for ApiToken {
             let conn = request
                 .guard::<DbConn>()
                 .map_failure(|_| (Status::InternalServerError, TokenError::DbError))?;
-            if let Ok(token) = ApiToken::find_by_value(&*conn, val) {
+            if let Ok(token) = ApiToken::find_by_value(&conn, val) {
                 return Outcome::Success(token);
             }
         }

plume-models/src/apps.rs

@@ -1,6 +1,7 @@
 use crate::{schema::apps, Error, Result};
 use chrono::NaiveDateTime;
 use diesel::{self, ExpressionMethods, QueryDsl, RunQueryDsl};
+use serde_derive::Serialize;
 
 #[derive(Clone, Queryable, Serialize)]
 pub struct App {

plume-models/src/blocklisted_emails.rs

@@ -126,12 +126,9 @@ pub(crate) mod tests {
                     .id,
                 various[1].id
             );
-            assert_eq!(
+            assert!(BlocklistedEmail::matches_blocklist(&conn, no_match)
-                BlocklistedEmail::matches_blocklist(&conn, no_match)
+                .unwrap()
-                    .unwrap()
+                .is_none());
-                    .is_none(),
-                true
-            );
             Ok(())
         });
     }

plume-models/src/blogs.rs

@@ -1,6 +1,7 @@
+use heck::ToUpperCamelCase;
 use crate::{
-    db_conn::DbConn, instance::*, medias::Media, posts::Post, safe_string::SafeString,
+    instance::*, medias::Media, posts::Post, safe_string::SafeString, schema::blogs, users::User,
-    schema::blogs, users::User, Connection, Error, PlumeRocket, Result, CONFIG, ITEMS_PER_PAGE,
+    Connection, Error, PlumeRocket, Result, CONFIG, ITEMS_PER_PAGE,
 };
 use activitystreams::{
     actor::{ApActor, ApActorExt, AsApActor, Group},
@@ -18,10 +19,13 @@ use openssl::{
     rsa::Rsa,
     sign::{Signer, Verifier},
 };
-use plume_common::activity_pub::{
+use plume_common::{
-    inbox::{AsActor, FromId},
+    activity_pub::{
-    sign, ActivityStream, ApSignature, CustomGroup, Id, IntoId, PublicKey, Source, SourceProperty,
+        inbox::{AsActor, FromId},
-    ToAsString, ToAsUri,
+        sign, ActivityStream, ApSignature, CustomGroup, Id, IntoId, PublicKey, Source,
+        SourceProperty, ToAsString, ToAsUri,
+    },
+    utils::iri_percent_encode_seg,
 };
 use webfinger::*;
 
@@ -83,9 +87,13 @@ impl Blog {
 
         if inserted.fqn.is_empty() {
             if instance.local {
-                inserted.fqn = inserted.actor_id.clone();
+                inserted.fqn = iri_percent_encode_seg(&inserted.actor_id);
             } else {
-                inserted.fqn = format!("{}@{}", inserted.actor_id, instance.public_domain);
+                inserted.fqn = format!(
+                    "{}@{}",
+                    iri_percent_encode_seg(&inserted.actor_id),
+                    instance.public_domain
+                );
             }
         }
 
@@ -95,6 +103,19 @@ impl Blog {
     find_by!(blogs, find_by_ap_url, ap_url as &str);
     find_by!(blogs, find_by_name, actor_id as &str, instance_id as i32);
 
+/// Remove non alphanumeric characters and CamelCase a string
+	pub fn slug(title: &str) -> String {
+	    title.to_upper_camel_case()
+	        .chars()
+	        .filter(|c| c.is_alphanumeric())
+	        .collect()
+	}
+    /*
+    pub fn slug(title: &str) -> &str {
+        title
+    }
+    */
+
     pub fn get_instance(&self, conn: &Connection) -> Result<Instance> {
         Instance::get(conn, self.instance_id)
     }
@@ -131,10 +152,10 @@ impl Blog {
             .map_err(Error::from)
     }
 
-    pub fn find_by_fqn(conn: &DbConn, fqn: &str) -> Result<Blog> {
+    pub fn find_by_fqn(conn: &Connection, fqn: &str) -> Result<Blog> {
         let from_db = blogs::table
             .filter(blogs::fqn.eq(fqn))
-            .first(&**conn)
+            .first(conn)
             .optional()?;
         if let Some(from_db) = from_db {
             Ok(from_db)
@@ -143,7 +164,7 @@ impl Blog {
         }
     }
 
-    fn fetch_from_webfinger(conn: &DbConn, acct: &str) -> Result<Blog> {
+    fn fetch_from_webfinger(conn: &Connection, acct: &str) -> Result<Blog> {
         resolve_with_prefix(Prefix::Group, acct.to_owned(), true)?
             .links
             .into_iter()
@@ -162,7 +183,7 @@ impl Blog {
 
     pub fn to_activity(&self, conn: &Connection) -> Result<CustomGroup> {
         let mut blog = ApActor::new(self.inbox_url.parse()?, Group::new());
-        blog.set_preferred_username(self.actor_id.clone());
+        blog.set_preferred_username(iri_percent_encode_seg(&self.actor_id));
         blog.set_name(self.title.clone());
         blog.set_outbox(self.outbox_url.parse()?);
         blog.set_summary(self.summary_html.to_string());
@@ -361,15 +382,15 @@ impl IntoId for Blog {
     }
 }
 
-impl FromId<DbConn> for Blog {
+impl FromId<Connection> for Blog {
     type Error = Error;
     type Object = CustomGroup;
 
-    fn from_db(conn: &DbConn, id: &str) -> Result<Self> {
+    fn from_db(conn: &Connection, id: &str) -> Result<Self> {
         Self::find_by_ap_url(conn, id)
     }
 
-    fn from_activity(conn: &DbConn, acct: CustomGroup) -> Result<Self> {
+    fn from_activity(conn: &Connection, acct: CustomGroup) -> Result<Self> {
         let (name, outbox_url, inbox_url) = {
             let actor = acct.ap_actor_ref();
             let name = actor
@@ -377,6 +398,7 @@ impl FromId<DbConn> for Blog {
                 .ok_or(Error::MissingApProperty)?
                 .to_string();
             if name.contains(&['<', '>', '&', '@', '\'', '"', ' ', '\t'][..]) {
+                tracing::error!("preferredUsername includes invalid character(s): {}", &name);
                 return Err(Error::InvalidValue);
             }
             (
@@ -656,7 +678,7 @@ pub(crate) mod tests {
             .unwrap()
             .id,
         );
-        let _: Blog = blog1.save_changes(&*conn).unwrap();
+        let _: Blog = blog1.save_changes(conn).unwrap();
 
         (users, vec![blog1, blog2, blog3])
     }
@@ -665,10 +687,10 @@ pub(crate) mod tests {
     fn get_instance() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            fill_database(&conn);
+            fill_database(conn);
 
             let blog = Blog::insert(
-                &conn,
+                conn,
                 NewBlog::new_local(
                     "SomeName".to_owned(),
                     "Some name".to_owned(),
@@ -680,7 +702,7 @@ pub(crate) mod tests {
             .unwrap();
 
             assert_eq!(
-                blog.get_instance(&conn).unwrap().id,
+                blog.get_instance(conn).unwrap().id,
                 Instance::get_local().unwrap().id
             );
             // TODO add tests for remote instance
@@ -692,10 +714,10 @@ pub(crate) mod tests {
     fn authors() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (user, _) = fill_database(&conn);
+            let (user, _) = fill_database(conn);
 
             let b1 = Blog::insert(
-                &conn,
+                conn,
                 NewBlog::new_local(
                     "SomeName".to_owned(),
                     "Some name".to_owned(),
@@ -706,7 +728,7 @@ pub(crate) mod tests {
             )
             .unwrap();
             let b2 = Blog::insert(
-                &conn,
+                conn,
                 NewBlog::new_local(
                     "Blog".to_owned(),
                     "Blog".to_owned(),
@@ -719,7 +741,7 @@ pub(crate) mod tests {
             let blog = vec![b1, b2];
 
             BlogAuthor::insert(
-                &conn,
+                conn,
                 NewBlogAuthor {
                     blog_id: blog[0].id,
                     author_id: user[0].id,
@@ -729,7 +751,7 @@ pub(crate) mod tests {
             .unwrap();
 
             BlogAuthor::insert(
-                &conn,
+                conn,
                 NewBlogAuthor {
                     blog_id: blog[0].id,
                     author_id: user[1].id,
@@ -739,7 +761,7 @@ pub(crate) mod tests {
             .unwrap();
 
             BlogAuthor::insert(
-                &conn,
+                conn,
                 NewBlogAuthor {
                     blog_id: blog[1].id,
                     author_id: user[0].id,
@@ -749,39 +771,39 @@ pub(crate) mod tests {
             .unwrap();
 
             assert!(blog[0]
-                .list_authors(&conn)
+                .list_authors(conn)
                 .unwrap()
                 .iter()
                 .any(|a| a.id == user[0].id));
             assert!(blog[0]
-                .list_authors(&conn)
+                .list_authors(conn)
                 .unwrap()
                 .iter()
                 .any(|a| a.id == user[1].id));
             assert!(blog[1]
-                .list_authors(&conn)
+                .list_authors(conn)
                 .unwrap()
                 .iter()
                 .any(|a| a.id == user[0].id));
             assert!(!blog[1]
-                .list_authors(&conn)
+                .list_authors(conn)
                 .unwrap()
                 .iter()
                 .any(|a| a.id == user[1].id));
 
-            assert!(Blog::find_for_author(&conn, &user[0])
+            assert!(Blog::find_for_author(conn, &user[0])
                 .unwrap()
                 .iter()
                 .any(|b| b.id == blog[0].id));
-            assert!(Blog::find_for_author(&conn, &user[1])
+            assert!(Blog::find_for_author(conn, &user[1])
                 .unwrap()
                 .iter()
                 .any(|b| b.id == blog[0].id));
-            assert!(Blog::find_for_author(&conn, &user[0])
+            assert!(Blog::find_for_author(conn, &user[0])
                 .unwrap()
                 .iter()
                 .any(|b| b.id == blog[1].id));
-            assert!(!Blog::find_for_author(&conn, &user[1])
+            assert!(!Blog::find_for_author(conn, &user[1])
                 .unwrap()
                 .iter()
                 .any(|b| b.id == blog[1].id));
@@ -793,10 +815,10 @@ pub(crate) mod tests {
     fn find_local() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            fill_database(&conn);
+            fill_database(conn);
 
             let blog = Blog::insert(
-                &conn,
+                conn,
                 NewBlog::new_local(
                     "SomeName".to_owned(),
                     "Some name".to_owned(),
@@ -807,7 +829,7 @@ pub(crate) mod tests {
             )
             .unwrap();
 
-            assert_eq!(Blog::find_by_fqn(&conn, "SomeName").unwrap().id, blog.id);
+            assert_eq!(Blog::find_by_fqn(conn, "SomeName").unwrap().id, blog.id);
             Ok(())
         })
     }
@@ -816,10 +838,10 @@ pub(crate) mod tests {
     fn get_fqn() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            fill_database(&conn);
+            fill_database(conn);
 
             let blog = Blog::insert(
-                &conn,
+                conn,
                 NewBlog::new_local(
                     "SomeName".to_owned(),
                     "Some name".to_owned(),
@@ -839,10 +861,10 @@ pub(crate) mod tests {
     fn delete() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (_, blogs) = fill_database(&conn);
+            let (_, blogs) = fill_database(conn);
 
-            blogs[0].delete(&conn).unwrap();
+            blogs[0].delete(conn).unwrap();
-            assert!(Blog::get(&conn, blogs[0].id).is_err());
+            assert!(Blog::get(conn, blogs[0].id).is_err());
             Ok(())
         })
     }
@@ -851,10 +873,10 @@ pub(crate) mod tests {
     fn delete_via_user() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (user, _) = fill_database(&conn);
+            let (user, _) = fill_database(conn);
 
             let b1 = Blog::insert(
-                &conn,
+                conn,
                 NewBlog::new_local(
                     "SomeName".to_owned(),
                     "Some name".to_owned(),
@@ -865,7 +887,7 @@ pub(crate) mod tests {
             )
             .unwrap();
             let b2 = Blog::insert(
-                &conn,
+                conn,
                 NewBlog::new_local(
                     "Blog".to_owned(),
                     "Blog".to_owned(),
@@ -878,7 +900,7 @@ pub(crate) mod tests {
             let blog = vec![b1, b2];
 
             BlogAuthor::insert(
-                &conn,
+                conn,
                 NewBlogAuthor {
                     blog_id: blog[0].id,
                     author_id: user[0].id,
@@ -888,7 +910,7 @@ pub(crate) mod tests {
             .unwrap();
 
             BlogAuthor::insert(
-                &conn,
+                conn,
                 NewBlogAuthor {
                     blog_id: blog[0].id,
                     author_id: user[1].id,
@@ -898,7 +920,7 @@ pub(crate) mod tests {
             .unwrap();
 
             BlogAuthor::insert(
-                &conn,
+                conn,
                 NewBlogAuthor {
                     blog_id: blog[1].id,
                     author_id: user[0].id,
@@ -907,11 +929,11 @@ pub(crate) mod tests {
             )
             .unwrap();
 
-            user[0].delete(&conn).unwrap();
+            user[0].delete(conn).unwrap();
-            assert!(Blog::get(&conn, blog[0].id).is_ok());
+            assert!(Blog::get(conn, blog[0].id).is_ok());
-            assert!(Blog::get(&conn, blog[1].id).is_err());
+            assert!(Blog::get(conn, blog[1].id).is_err());
-            user[1].delete(&conn).unwrap();
+            user[1].delete(conn).unwrap();
-            assert!(Blog::get(&conn, blog[0].id).is_err());
+            assert!(Blog::get(conn, blog[0].id).is_err());
             Ok(())
         })
     }
@@ -920,10 +942,10 @@ pub(crate) mod tests {
     fn self_federation() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (users, mut blogs) = fill_database(&conn);
+            let (users, mut blogs) = fill_database(conn);
             blogs[0].icon_id = Some(
                 Media::insert(
-                    &conn,
+                    conn,
                     NewMedia {
                         file_path: "aaa.png".into(),
                         alt_text: String::new(),
@@ -939,7 +961,7 @@ pub(crate) mod tests {
             );
             blogs[0].banner_id = Some(
                 Media::insert(
-                    &conn,
+                    conn,
                     NewMedia {
                         file_path: "bbb.png".into(),
                         alt_text: String::new(),
@@ -954,9 +976,9 @@ pub(crate) mod tests {
                 .id,
             );
             let _: Blog = blogs[0].save_changes(&**conn).unwrap();
-            let ap_repr = blogs[0].to_activity(&conn).unwrap();
+            let ap_repr = blogs[0].to_activity(conn).unwrap();
-            blogs[0].delete(&conn).unwrap();
+            blogs[0].delete(conn).unwrap();
-            let blog = Blog::from_activity(&conn, ap_repr).unwrap();
+            let blog = Blog::from_activity(conn, ap_repr).unwrap();
 
             assert_eq!(blog.actor_id, blogs[0].actor_id);
             assert_eq!(blog.title, blogs[0].title);
@@ -968,8 +990,8 @@ pub(crate) mod tests {
             assert_eq!(blog.public_key, blogs[0].public_key);
             assert_eq!(blog.fqn, blogs[0].fqn);
             assert_eq!(blog.summary_html, blogs[0].summary_html);
-            assert_eq!(blog.icon_url(&conn), blogs[0].icon_url(&conn));
+            assert_eq!(blog.icon_url(conn), blogs[0].icon_url(conn));
-            assert_eq!(blog.banner_url(&conn), blogs[0].banner_url(&conn));
+            assert_eq!(blog.banner_url(conn), blogs[0].banner_url(conn));
 
             Ok(())
         })
@@ -979,7 +1001,7 @@ pub(crate) mod tests {
     fn to_activity() {
         let conn = &db();
         conn.test_transaction::<_, Error, _>(|| {
-            let (_users, blogs) = fill_database(&conn);
+            let (_users, blogs) = fill_database(conn);
             let blog = &blogs[0];
             let act = blog.to_activity(conn)?;
 

plume-models/src/comments.rs

@@ -1,6 +1,5 @@
 use crate::{
     comment_seers::{CommentSeers, NewCommentSeers},
-    db_conn::DbConn,
     instance::Instance,
     medias::Media,
     mentions::Mention,
@@ -74,6 +73,7 @@ impl Comment {
     });
     get!(comments);
     list_by!(comments, list_by_post, post_id as i32);
+    list_by!(comments, list_by_author, author_id as i32);
     find_by!(comments, find_by_ap_url, ap_url as &str);
 
     pub fn get_author(&self, conn: &Connection) -> Result<User> {
@@ -111,7 +111,7 @@ impl Comment {
                 .unwrap_or(false)
     }
 
-    pub fn to_activity(&self, conn: &DbConn) -> Result<Note> {
+    pub fn to_activity(&self, conn: &Connection) -> Result<Note> {
         let author = User::get(conn, self.author_id)?;
         let (html, mentions, _hashtags) = utils::md_to_html(
             self.content.get().as_ref(),
@@ -136,7 +136,8 @@ impl Comment {
             |id| Comment::get(conn, id).map(|comment| comment.ap_url.unwrap_or_default()),
         )?);
         note.set_published(
-            OffsetDateTime::from_unix_timestamp_nanos(self.creation_date.timestamp_nanos().into())
+            //EZABATU OffsetDateTime::from_unix_timestamp_nanos(self.creation_date.timestamp_nanos_opt().unwrap().into())
+            OffsetDateTime::from_unix_timestamp_nanos(self.creation_date.and_utc().timestamp_nanos_opt().unwrap().into())
                 .expect("OffsetDateTime"),
         );
         note.set_attributed_to(author.into_id().parse::<IriString>()?);
@@ -149,7 +150,7 @@ impl Comment {
         Ok(note)
     }
 
-    pub fn create_activity(&self, conn: &DbConn) -> Result<Create> {
+    pub fn create_activity(&self, conn: &Connection) -> Result<Create> {
         let author = User::get(conn, self.author_id)?;
 
         let note = self.to_activity(conn)?;
@@ -217,15 +218,15 @@ impl Comment {
     }
 }
 
-impl FromId<DbConn> for Comment {
+impl FromId<Connection> for Comment {
     type Error = Error;
     type Object = Note;
 
-    fn from_db(conn: &DbConn, id: &str) -> Result<Self> {
+    fn from_db(conn: &Connection, id: &str) -> Result<Self> {
         Self::find_by_ap_url(conn, id)
     }
 
-    fn from_activity(conn: &DbConn, note: Note) -> Result<Self> {
+    fn from_activity(conn: &Connection, note: Note) -> Result<Self> {
         let comm = {
             let previous_url = note
                 .in_reply_to()
@@ -354,21 +355,21 @@ impl FromId<DbConn> for Comment {
     }
 }
 
-impl AsObject<User, Create, &DbConn> for Comment {
+impl AsObject<User, Create, &Connection> for Comment {
     type Error = Error;
     type Output = Self;
 
-    fn activity(self, _conn: &DbConn, _actor: User, _id: &str) -> Result<Self> {
+    fn activity(self, _conn: &Connection, _actor: User, _id: &str) -> Result<Self> {
         // The actual creation takes place in the FromId impl
         Ok(self)
     }
 }
 
-impl AsObject<User, Delete, &DbConn> for Comment {
+impl AsObject<User, Delete, &Connection> for Comment {
     type Error = Error;
     type Output = ();
 
-    fn activity(self, conn: &DbConn, actor: User, _id: &str) -> Result<()> {
+    fn activity(self, conn: &Connection, actor: User, _id: &str) -> Result<()> {
         if self.author_id != actor.id {
             return Err(Error::Unauthorized);
         }
@@ -381,14 +382,14 @@ impl AsObject<User, Delete, &DbConn> for Comment {
         }
 
         for n in Notification::find_for_comment(conn, &self)? {
-            n.delete(&**conn)?;
+            n.delete(conn)?;
         }
 
         diesel::update(comments::table)
             .filter(comments::in_response_to_id.eq(self.id))
             .set(comments::in_response_to_id.eq(self.in_response_to_id))
-            .execute(&**conn)?;
+            .execute(conn)?;
-        diesel::delete(&self).execute(&**conn)?;
+        diesel::delete(&self).execute(conn)?;
         Ok(())
     }
 }
@@ -423,6 +424,7 @@ impl CommentTree {
 mod tests {
     use super::*;
     use crate::blogs::Blog;
+    use crate::db_conn::DbConn;
     use crate::inbox::{inbox, tests::fill_database, InboxResult};
     use crate::safe_string::SafeString;
     use crate::tests::{db, format_datetime};
@@ -431,7 +433,7 @@ mod tests {
     use serde_json::{json, to_value};
 
     fn prepare_activity(conn: &DbConn) -> (Comment, Vec<Post>, Vec<User>, Vec<Blog>) {
-        let (posts, users, blogs) = fill_database(&conn);
+        let (posts, users, blogs) = fill_database(conn);
 
         let comment = Comment::insert(
             conn,
@@ -457,8 +459,8 @@ mod tests {
     fn self_federation() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (original_comm, posts, users, _blogs) = prepare_activity(&conn);
+            let (original_comm, posts, users, _blogs) = prepare_activity(conn);
-            let act = original_comm.create_activity(&conn).unwrap();
+            let act = original_comm.create_activity(conn).unwrap();
 
             assert_json_eq!(to_value(&act).unwrap(), json!({
                 "actor": "https://plu.me/@/admin/",
@@ -500,7 +502,7 @@ mod tests {
                 },
             )
             .unwrap();
-            let reply_act = reply.create_activity(&conn).unwrap();
+            let reply_act = reply.create_activity(conn).unwrap();
 
             assert_json_eq!(to_value(&reply_act).unwrap(), json!({
                 "actor": "https://plu.me/@/user/",
@@ -522,12 +524,12 @@ mod tests {
             }));
 
             inbox(
-                &conn,
+                conn,
-                serde_json::to_value(original_comm.build_delete(&conn).unwrap()).unwrap(),
+                serde_json::to_value(original_comm.build_delete(conn).unwrap()).unwrap(),
             )
             .unwrap();
 
-            match inbox(&conn, to_value(act).unwrap()).unwrap() {
+            match inbox(conn, to_value(act).unwrap()).unwrap() {
                 InboxResult::Commented(c) => {
                     // TODO: one is HTML, the other markdown: assert_eq!(c.content, original_comm.content);
                     assert_eq!(c.in_response_to_id, original_comm.in_response_to_id);

plume-models/src/config.rs

@@ -5,6 +5,10 @@ use rocket::config::Limits;
 use rocket::Config as RocketConfig;
 use std::collections::HashSet;
 use std::env::{self, var};
+use serde_derive::Serialize;
+
+#[cfg(feature = "s3")]
+use s3::{Bucket, Region, creds::Credentials};
 
 #[cfg(not(test))]
 const DB_NAME: &str = "plume";
@@ -27,13 +31,23 @@ pub struct Config {
     pub mail: Option<MailConfig>,
     pub ldap: Option<LdapConfig>,
     pub proxy: Option<ProxyConfig>,
+    pub s3: Option<S3Config>,
 }
+
 impl Config {
     pub fn proxy(&self) -> Option<&reqwest::Proxy> {
         self.proxy.as_ref().map(|p| &p.proxy)
     }
 }
 
+fn string_to_bool(val: &str, name: &str) -> bool {
+    match val {
+        "1" | "true" | "TRUE" => true,
+        "0" | "false" | "FALSE" => false,
+        _ => panic!("Invalid configuration: {} is not boolean", name),
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum InvalidRocketConfig {
     Env,
@@ -280,6 +294,7 @@ pub struct LdapConfig {
     pub tls: bool,
     pub user_name_attr: String,
     pub mail_attr: String,
+    pub user: Option<(String, String)>,
 }
 
 fn get_ldap_config() -> Option<LdapConfig> {
@@ -288,23 +303,29 @@ fn get_ldap_config() -> Option<LdapConfig> {
     match (addr, base_dn) {
         (Some(addr), Some(base_dn)) => {
             let tls = var("LDAP_TLS").unwrap_or_else(|_| "false".to_owned());
-            let tls = match tls.as_ref() {
+            let tls = string_to_bool(&tls, "LDAP_TLS");
-                "1" | "true" | "TRUE" => true,
-                "0" | "false" | "FALSE" => false,
-                _ => panic!("Invalid LDAP configuration : tls"),
-            };
             let user_name_attr = var("LDAP_USER_NAME_ATTR").unwrap_or_else(|_| "cn".to_owned());
             let mail_attr = var("LDAP_USER_MAIL_ATTR").unwrap_or_else(|_| "mail".to_owned());
+            //2023-12-30
+            let user = var("LDAP_USER").ok();
+            let password = var("LDAP_PASSWORD").ok();
+            let user = match (user, password) {
+                (Some(user), Some(password)) => Some((user, password)),
+                (None, None) => None,
+                _ => panic!("Invalid LDAP configuration both or neither of LDAP_USER and LDAP_PASSWORD must be set")           
+            };
+            //
             Some(LdapConfig {
                 addr,
                 base_dn,
                 tls,
                 user_name_attr,
                 mail_attr,
+                user,
             })
         }
         (None, None) => None,
-        (_, _) => {
+        _ => {
             panic!("Invalid LDAP configuration : both LDAP_ADDR and LDAP_BASE_DN must be set")
         }
     }
@@ -349,6 +370,104 @@ fn get_proxy_config() -> Option<ProxyConfig> {
     })
 }
 
+pub struct S3Config {
+    pub bucket: String,
+    pub access_key_id: String,
+    pub access_key_secret: String,
+
+    // region? If not set, default to us-east-1
+    pub region: String,
+    // hostname for s3. If not set, default to $region.amazonaws.com
+    pub hostname: String,
+    // may be useful when using self hosted s3. Won't work with recent AWS buckets
+    pub path_style: bool,
+    // http or https
+    pub protocol: String,
+
+    // download directly from s3 to user, wihout going through Plume. Require public read on bucket
+    pub direct_download: bool,
+    // use this hostname for downloads, can be used with caching proxy in front of s3 (expected to
+    // be reachable through https)
+    pub alias: Option<String>,
+}
+
+impl S3Config {
+    #[cfg(feature = "s3")]
+    pub fn get_bucket(&self) -> Bucket {
+        let region = Region::Custom {
+            region: self.region.clone(),
+            endpoint: format!("{}://{}", self.protocol, self.hostname),
+        };
+        let credentials = Credentials {
+            access_key: Some(self.access_key_id.clone()),
+            secret_key: Some(self.access_key_secret.clone()),
+            security_token: None,
+            session_token: None,
+            expiration: None,
+        };
+
+        let bucket = Bucket::new(&self.bucket, region, credentials).unwrap();
+        if self.path_style {
+            bucket.with_path_style()
+        } else {
+            bucket
+        }
+    }
+}
+
+fn get_s3_config() -> Option<S3Config> {
+    let bucket = var("S3_BUCKET").ok();
+    let access_key_id = var("AWS_ACCESS_KEY_ID").ok();
+    let access_key_secret = var("AWS_SECRET_ACCESS_KEY").ok();
+    if bucket.is_none() && access_key_id.is_none() && access_key_secret.is_none() {
+        return None;
+    }
+
+    #[cfg(not(feature = "s3"))]
+    panic!("S3 support is not enabled in this build");
+
+    #[cfg(feature = "s3")]
+    {
+        if bucket.is_none() || access_key_id.is_none() || access_key_secret.is_none() {
+            panic!("Invalid S3 configuration: some required values are set, but not others");
+        }
+        let bucket = bucket.unwrap();
+        let access_key_id = access_key_id.unwrap();
+        let access_key_secret = access_key_secret.unwrap();
+
+        let region = var("S3_REGION").unwrap_or_else(|_| "us-east-1".to_owned());
+        let hostname = var("S3_HOSTNAME").unwrap_or_else(|_| format!("{}.amazonaws.com", region));
+
+        let protocol = var("S3_PROTOCOL").unwrap_or_else(|_| "https".to_owned());
+        if protocol != "http" && protocol != "https" {
+            panic!("Invalid S3 configuration: invalid protocol {}", protocol);
+        }
+
+        let path_style = var("S3_PATH_STYLE").unwrap_or_else(|_| "false".to_owned());
+        let path_style = string_to_bool(&path_style, "S3_PATH_STYLE");
+        let direct_download = var("S3_DIRECT_DOWNLOAD").unwrap_or_else(|_| "false".to_owned());
+        let direct_download = string_to_bool(&direct_download, "S3_DIRECT_DOWNLOAD");
+
+        let alias = var("S3_ALIAS_HOST").ok();
+
+        if direct_download && protocol == "http" && alias.is_none() {
+            panic!("S3 direct download is disabled because bucket is accessed through plain HTTP. Use HTTPS or set an alias hostname (S3_ALIAS_HOST).");
+        }
+
+        Some(S3Config {
+            bucket,
+            access_key_id,
+            access_key_secret,
+            region,
+            hostname,
+            protocol,
+            path_style,
+            direct_download,
+            alias,
+        })
+    }
+}
+
 lazy_static! {
     pub static ref CONFIG: Config = Config {
         base_url: var("BASE_URL").unwrap_or_else(|_| format!(
@@ -380,5 +499,6 @@ lazy_static! {
         mail: get_mail_config(),
         ldap: get_ldap_config(),
         proxy: get_proxy_config(),
+        s3: get_s3_config(),
     };
 }

plume-models/src/db_conn.rs

@@ -69,7 +69,8 @@ pub(crate) mod tests {
     impl CustomizeConnection<Connection, ConnError> for TestConnectionCustomizer {
         fn on_acquire(&self, conn: &mut Connection) -> Result<(), ConnError> {
             PragmaForeignKey.on_acquire(conn)?;
-            Ok(conn.begin_test_transaction().unwrap())
+            conn.begin_test_transaction().unwrap();
+            Ok(())
         }
     }
 }

plume-models/src/email_signups.rs

@@ -1,4 +1,5 @@
 use crate::{
+    blocklisted_emails::BlocklistedEmail,
     db_conn::DbConn,
     schema::email_signups,
     users::{NewUser, Role, User},
@@ -60,6 +61,8 @@ pub struct NewEmailSignup<'a> {
 
 impl EmailSignup {
     pub fn start(conn: &DbConn, email: &str) -> Result<Token> {
+        Self::ensure_email_not_blocked(conn, email)?;
+
         conn.transaction(|| {
             Self::ensure_user_not_exist_by_email(conn, email)?;
             let _rows = Self::delete_existings_by_email(conn, email)?;
@@ -90,6 +93,8 @@ impl EmailSignup {
     }
 
     pub fn confirm(&self, conn: &DbConn) -> Result<()> {
+        Self::ensure_email_not_blocked(conn, &self.email)?;
+
         conn.transaction(|| {
             Self::ensure_user_not_exist_by_email(conn, &self.email)?;
             if self.expired() {
@@ -101,6 +106,8 @@ impl EmailSignup {
     }
 
     pub fn complete(&self, conn: &DbConn, username: String, password: String) -> Result<User> {
+        Self::ensure_email_not_blocked(conn, &self.email)?;
+
         conn.transaction(|| {
             Self::ensure_user_not_exist_by_email(conn, &self.email)?;
             let user = NewUser::new_local(
@@ -122,6 +129,14 @@ impl EmailSignup {
         Ok(())
     }
 
+    fn ensure_email_not_blocked(conn: &DbConn, email: &str) -> Result<()> {
+        if let Some(x) = BlocklistedEmail::matches_blocklist(conn, email)? {
+            Err(Error::Blocklisted(x.notify_user, x.notification_text))
+        } else {
+            Ok(())
+        }
+    }
+
     fn ensure_user_not_exist_by_email(conn: &DbConn, email: &str) -> Result<()> {
         if User::email_used(conn, email)? {
             let _rows = Self::delete_existings_by_email(conn, email)?;

plume-models/src/follows.rs

@@ -1,6 +1,6 @@
 use crate::{
-    ap_url, db_conn::DbConn, instance::Instance, notifications::*, schema::follows, users::User,
+    ap_url, instance::Instance, notifications::*, schema::follows, users::User, Connection, Error,
-    Connection, Error, Result, CONFIG,
+    Result, CONFIG,
 };
 use activitystreams::{
     activity::{Accept, ActorAndObjectRef, Follow as FollowAct, Undo},
@@ -107,12 +107,7 @@ impl Follow {
         res.notify(conn)?;
 
         let accept = res.build_accept(from, target, follow)?;
-        broadcast(
+        broadcast(target, accept, vec![from.clone()], CONFIG.proxy().cloned());
-            &*target,
-            accept,
-            vec![from.clone()],
-            CONFIG.proxy().cloned(),
-        );
         Ok(res)
     }
 
@@ -155,11 +150,11 @@ impl Follow {
     }
 }
 
-impl AsObject<User, FollowAct, &DbConn> for User {
+impl AsObject<User, FollowAct, &Connection> for User {
     type Error = Error;
     type Output = Follow;
 
-    fn activity(self, conn: &DbConn, actor: User, id: &str) -> Result<Follow> {
+    fn activity(self, conn: &Connection, actor: User, id: &str) -> Result<Follow> {
         // Mastodon (at least) requires the full Follow object when accepting it,
         // so we rebuilt it here
         let follow = FollowAct::new(actor.ap_url.parse::<IriString>()?, id.parse::<IriString>()?);
@@ -167,15 +162,15 @@ impl AsObject<User, FollowAct, &DbConn> for User {
     }
 }
 
-impl FromId<DbConn> for Follow {
+impl FromId<Connection> for Follow {
     type Error = Error;
     type Object = FollowAct;
 
-    fn from_db(conn: &DbConn, id: &str) -> Result<Self> {
+    fn from_db(conn: &Connection, id: &str) -> Result<Self> {
         Follow::find_by_ap_url(conn, id)
     }
 
-    fn from_activity(conn: &DbConn, follow: FollowAct) -> Result<Self> {
+    fn from_activity(conn: &Connection, follow: FollowAct) -> Result<Self> {
         let actor = User::from_id(
             conn,
             follow
@@ -207,18 +202,18 @@ impl FromId<DbConn> for Follow {
     }
 }
 
-impl AsObject<User, Undo, &DbConn> for Follow {
+impl AsObject<User, Undo, &Connection> for Follow {
     type Error = Error;
     type Output = ();
 
-    fn activity(self, conn: &DbConn, actor: User, _id: &str) -> Result<()> {
+    fn activity(self, conn: &Connection, actor: User, _id: &str) -> Result<()> {
         let conn = conn;
         if self.follower_id == actor.id {
-            diesel::delete(&self).execute(&**conn)?;
+            diesel::delete(&self).execute(conn)?;
 
             // delete associated notification if any
             if let Ok(notif) = Notification::find(conn, notification_kind::FOLLOW, self.id) {
-                diesel::delete(&notif).execute(&**conn)?;
+                diesel::delete(&notif).execute(conn)?;
             }
 
             Ok(())
@@ -237,7 +232,9 @@ impl IntoId for Follow {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{tests::db, users::tests as user_tests, users::tests::fill_database};
+    use crate::{
+        db_conn::DbConn, tests::db, users::tests as user_tests, users::tests::fill_database,
+    };
     use assert_json_diff::assert_json_eq;
     use diesel::Connection;
     use serde_json::{json, to_value};

plume-models/src/inbox.rs

@@ -2,12 +2,11 @@ use activitystreams::activity::{Announce, Create, Delete, Follow, Like, Undo, Up
 
 use crate::{
     comments::Comment,
-    db_conn::DbConn,
     follows, likes,
     posts::{Post, PostUpdate},
     reshares::Reshare,
     users::User,
-    Error, CONFIG,
+    Connection, Error, CONFIG,
 };
 use plume_common::activity_pub::inbox::Inbox;
 
@@ -46,7 +45,7 @@ impl_into_inbox_result! {
     Reshare => Reshared
 }
 
-pub fn inbox(conn: &DbConn, act: serde_json::Value) -> Result<InboxResult, Error> {
+pub fn inbox(conn: &Connection, act: serde_json::Value) -> Result<InboxResult, Error> {
     Inbox::handle(conn, act)
         .with::<User, Announce, Post>(CONFIG.proxy())
         .with::<User, Create, Comment>(CONFIG.proxy())
@@ -82,9 +81,9 @@ pub(crate) mod tests {
         use crate::post_authors::*;
         use crate::posts::*;
 
-        let (users, blogs) = blog_fill_db(&conn);
+        let (users, blogs) = blog_fill_db(conn);
         let post = Post::insert(
-            &conn,
+            conn,
             NewPost {
                 blog_id: blogs[0].id,
                 slug: "testing".to_owned(),
@@ -102,7 +101,7 @@ pub(crate) mod tests {
         .unwrap();
 
         PostAuthor::insert(
-            &conn,
+            conn,
             NewPostAuthor {
                 post_id: post.id,
                 author_id: users[0].id,
@@ -190,7 +189,7 @@ pub(crate) mod tests {
             });
 
             assert!(matches!(
-                super::inbox(&conn, act.clone()),
+                super::inbox(&conn, act),
                 Err(super::Error::Inbox(
                     box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
                 ))
@@ -221,7 +220,7 @@ pub(crate) mod tests {
             });
 
             assert!(matches!(
-                super::inbox(&conn, act.clone()),
+                super::inbox(&conn, act),
                 Err(super::Error::Inbox(
                     box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
                 ))
@@ -249,7 +248,7 @@ pub(crate) mod tests {
             });
 
             assert!(matches!(
-                super::inbox(&conn, act.clone()),
+                super::inbox(&conn, act),
                 Err(super::Error::Inbox(
                     box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
                 ))
@@ -324,7 +323,7 @@ pub(crate) mod tests {
             });
 
             assert!(matches!(
-                super::inbox(&conn, act.clone()),
+                super::inbox(&conn, act),
                 Err(super::Error::Inbox(
                     box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
                 ))
@@ -362,7 +361,7 @@ pub(crate) mod tests {
             });
 
             assert!(matches!(
-                super::inbox(&conn, act.clone()),
+                super::inbox(&conn, act),
                 Err(super::Error::Inbox(
                     box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
                 ))
@@ -397,7 +396,7 @@ pub(crate) mod tests {
             });
 
             assert!(matches!(
-                super::inbox(&conn, act.clone()),
+                super::inbox(&conn, act),
                 Err(super::Error::Inbox(
                     box plume_common::activity_pub::inbox::InboxError::InvalidObject(_),
                 ))

plume-models/src/instance.rs

@@ -9,7 +9,7 @@ use crate::{
 use chrono::NaiveDateTime;
 use diesel::{self, result::Error::NotFound, ExpressionMethods, QueryDsl, RunQueryDsl};
 use once_cell::sync::OnceCell;
-use plume_common::utils::md_to_html;
+use plume_common::utils::{iri_percent_encode_seg, md_to_html};
 use std::sync::RwLock;
 
 #[derive(Clone, Identifiable, Queryable)]
@@ -173,8 +173,8 @@ impl Instance {
             "{instance}/{prefix}/{name}/{box_name}",
             instance = self.public_domain,
             prefix = prefix,
-            name = name,
+            name = iri_percent_encode_seg(name),
-            box_name = box_name
+            box_name = iri_percent_encode_seg(box_name)
         ))
     }
 
@@ -523,7 +523,7 @@ pub(crate) mod tests {
             .unwrap();
             let inst = Instance::get(conn, inst.id).unwrap();
             assert_eq!(inst.name, "NewName".to_owned());
-            assert_eq!(inst.open_registrations, false);
+            assert!(!inst.open_registrations);
             assert_eq!(
                 inst.long_description.get(),
                 "[long_description](/with_link)"

plume-models/src/lib.rs

@@ -69,6 +69,8 @@ pub enum Error {
     Webfinger,
     Expired,
     UserAlreadyExists,
+    #[cfg(feature = "s3")]
+    S3(s3::error::S3Error),
 }
 
 impl From<bcrypt::BcryptError> for Error {
@@ -170,6 +172,13 @@ impl From<request::Error> for Error {
     }
 }
 
+#[cfg(feature = "s3")]
+impl From<s3::error::S3Error> for Error {
+    fn from(err: s3::error::S3Error) -> Error {
+        Error::S3(err)
+    }
+}
+
 pub type Result<T> = std::result::Result<T, Error>;
 
 /// Adds a function to a model, that returns the first
@@ -177,7 +186,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 ///
 /// Usage:
 ///
-/// ```rust
+/// ```ignore
 /// impl Model {
 ///     find_by!(model_table, name_of_the_function, field1 as String, field2 as i32);
 /// }
@@ -201,7 +210,7 @@ macro_rules! find_by {
 ///
 /// Usage:
 ///
-/// ```rust
+/// ```ignore
 /// impl Model {
 ///     list_by!(model_table, name_of_the_function, field1 as String);
 /// }
@@ -225,7 +234,7 @@ macro_rules! list_by {
 ///
 /// # Usage
 ///
-/// ```rust
+/// ```ignore
 /// impl Model {
 ///     get!(model_table);
 /// }
@@ -248,7 +257,7 @@ macro_rules! get {
 ///
 /// # Usage
 ///
-/// ```rust
+/// ```ignore
 /// impl Model {
 ///     insert!(model_table, NewModelType);
 /// }
@@ -280,7 +289,7 @@ macro_rules! insert {
 ///
 /// # Usage
 ///
-/// ```rust
+/// ```ignore
 /// impl Model {
 ///     last!(model_table);
 /// }
@@ -354,7 +363,7 @@ mod tests {
         };
     }
 
-    pub fn db<'a>() -> db_conn::DbConn {
+    pub fn db() -> db_conn::DbConn {
         db_conn::DbConn((*DB_POOL).get().unwrap())
     }
 

plume-models/src/likes.rs

@@ -1,6 +1,6 @@
 use crate::{
-    db_conn::DbConn, instance::Instance, notifications::*, posts::Post, schema::likes, timeline::*,
+    instance::Instance, notifications::*, posts::Post, schema::likes, timeline::*, users::User,
-    users::User, Connection, Error, Result, CONFIG,
+    Connection, Error, Result, CONFIG,
 };
 use activitystreams::{
     activity::{ActorAndObjectRef, Like as LikeAct, Undo},
@@ -85,11 +85,11 @@ impl Like {
     }
 }
 
-impl AsObject<User, LikeAct, &DbConn> for Post {
+impl AsObject<User, LikeAct, &Connection> for Post {
     type Error = Error;
     type Output = Like;
 
-    fn activity(self, conn: &DbConn, actor: User, id: &str) -> Result<Like> {
+    fn activity(self, conn: &Connection, actor: User, id: &str) -> Result<Like> {
         let res = Like::insert(
             conn,
             NewLike {
@@ -105,15 +105,15 @@ impl AsObject<User, LikeAct, &DbConn> for Post {
     }
 }
 
-impl FromId<DbConn> for Like {
+impl FromId<Connection> for Like {
     type Error = Error;
     type Object = LikeAct;
 
-    fn from_db(conn: &DbConn, id: &str) -> Result<Self> {
+    fn from_db(conn: &Connection, id: &str) -> Result<Self> {
         Like::find_by_ap_url(conn, id)
     }
 
-    fn from_activity(conn: &DbConn, act: LikeAct) -> Result<Self> {
+    fn from_activity(conn: &Connection, act: LikeAct) -> Result<Self> {
         let res = Like::insert(
             conn,
             NewLike {
@@ -154,17 +154,17 @@ impl FromId<DbConn> for Like {
     }
 }
 
-impl AsObject<User, Undo, &DbConn> for Like {
+impl AsObject<User, Undo, &Connection> for Like {
     type Error = Error;
     type Output = ();
 
-    fn activity(self, conn: &DbConn, actor: User, _id: &str) -> Result<()> {
+    fn activity(self, conn: &Connection, actor: User, _id: &str) -> Result<()> {
         if actor.id == self.user_id {
-            diesel::delete(&self).execute(&**conn)?;
+            diesel::delete(&self).execute(conn)?;
 
             // delete associated notification if any
             if let Ok(notif) = Notification::find(conn, notification_kind::LIKE, self.id) {
-                diesel::delete(&notif).execute(&**conn)?;
+                diesel::delete(&notif).execute(conn)?;
             }
             Ok(())
         } else {
@@ -199,7 +199,7 @@ mod tests {
             let (posts, _users, _blogs) = fill_database(&conn);
             let post = &posts[0];
             let user = &post.get_authors(&conn)?[0];
-            let like = Like::insert(&*conn, NewLike::new(post, user))?;
+            let like = Like::insert(&conn, NewLike::new(post, user))?;
             let act = like.to_activity(&conn).unwrap();
 
             let expected = json!({
@@ -223,8 +223,8 @@ mod tests {
             let (posts, _users, _blogs) = fill_database(&conn);
             let post = &posts[0];
             let user = &post.get_authors(&conn)?[0];
-            let like = Like::insert(&*conn, NewLike::new(post, user))?;
+            let like = Like::insert(&conn, NewLike::new(post, user))?;
-            let act = like.build_undo(&*conn)?;
+            let act = like.build_undo(&conn)?;
 
             let expected = json!({
                 "actor": "https://plu.me/@/admin/",

plume-models/src/lists.rs

@@ -297,6 +297,28 @@ impl List {
             .map_err(Error::from)
     }
 
+    pub fn delete(&self, conn: &Connection) -> Result<()> {
+        if let Some(user_id) = self.user_id {
+            diesel::delete(
+                lists::table
+                    .filter(lists::user_id.eq(user_id))
+                    .filter(lists::name.eq(&self.name)),
+            )
+            .execute(conn)
+            .map(|_| ())
+            .map_err(Error::from)
+        } else {
+            diesel::delete(
+                lists::table
+                    .filter(lists::user_id.is_null())
+                    .filter(lists::name.eq(&self.name)),
+            )
+            .execute(conn)
+            .map(|_| ())
+            .map_err(Error::from)
+        }
+    }
+
     func! {set: set_users, User, add_users}
     func! {set: set_blogs, Blog, add_blogs}
     func! {set: set_words, Word, add_words}
@@ -413,7 +435,7 @@ mod tests {
                 &List::find_for_user_by_name(conn, l1.user_id, &l1.name).unwrap(),
             );
             l_eq(
-                &&l1u,
+                &l1u,
                 &List::find_for_user_by_name(conn, l1u.user_id, &l1u.name).unwrap(),
             );
             Ok(())

plume-models/src/medias.rs

@@ -1,6 +1,6 @@
 use crate::{
-    ap_url, db_conn::DbConn, instance::Instance, safe_string::SafeString, schema::medias,
+    ap_url, instance::Instance, safe_string::SafeString, schema::medias, users::User, Connection,
-    users::User, Connection, Error, Result, CONFIG,
+    Error, Result, CONFIG,
 };
 use activitystreams::{object::Image, prelude::*};
 use diesel::{self, ExpressionMethods, QueryDsl, RunQueryDsl};
@@ -16,6 +16,9 @@ use std::{
 use tracing::warn;
 use url::Url;
 
+#[cfg(feature = "s3")]
+use crate::config::S3Config;
+
 const REMOTE_MEDIA_DIRECTORY: &str = "remote";
 
 #[derive(Clone, Identifiable, Queryable, AsChangeset)]
@@ -42,7 +45,7 @@ pub struct NewMedia {
     pub owner_id: i32,
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 pub enum MediaCategory {
     Image,
     Audio,
@@ -105,7 +108,7 @@ impl Media {
             .file_path
             .rsplit_once('.')
             .map(|x| x.1)
-            .expect("Media::category: extension error")
+            .unwrap_or("")
             .to_lowercase()
         {
             "png" | "jpg" | "jpeg" | "gif" | "svg" => MediaCategory::Image,
@@ -151,26 +154,99 @@ impl Media {
         })
     }
 
+    /// Returns full file path for medias stored in the local media directory.
+    pub fn local_path(&self) -> Option<PathBuf> {
+        if self.file_path.is_empty() {
+            return None;
+        }
+
+        if CONFIG.s3.is_some() {
+            #[cfg(feature="s3")]
+            unreachable!("Called Media::local_path() but media are stored on S3");
+            #[cfg(not(feature="s3"))]
+            unreachable!();
+        }
+
+        let relative_path = self
+            .file_path
+            .trim_start_matches(&CONFIG.media_directory)
+            .trim_start_matches(path::MAIN_SEPARATOR)
+            .trim_start_matches("static/media/");
+
+        Some(Path::new(&CONFIG.media_directory).join(relative_path))
+    }
+
+    /// Returns the relative URL to access this file, which is also the key at which
+    /// it is stored in the S3 bucket if we are using S3 storage.
+    /// Does not start with a '/', it is of the form "static/media/<...>"
+    pub fn relative_url(&self) -> Option<String> {
+        if self.file_path.is_empty() {
+            return None;
+        }
+
+        let relative_path = self
+            .file_path
+            .trim_start_matches(&CONFIG.media_directory)
+            .replace(path::MAIN_SEPARATOR, "/");
+
+        let relative_path = relative_path
+            .trim_start_matches('/')
+            .trim_start_matches("static/media/");
+
+        Some(format!("static/media/{}", relative_path))
+    }
+
+    /// Returns a public URL through which this media file can be accessed
     pub fn url(&self) -> Result<String> {
         if self.is_remote {
             Ok(self.remote_url.clone().unwrap_or_default())
         } else {
-            let file_path = self.file_path.replace(path::MAIN_SEPARATOR, "/").replacen(
+            let relative_url = self.relative_url().unwrap_or_default();
-                &CONFIG.media_directory,
+
-                "static/media",
+            #[cfg(feature="s3")]
-                1,
+            if CONFIG.s3.as_ref().map(|x| x.direct_download).unwrap_or(false) {
-            ); // "static/media" from plume::routs::plume_media_files()
+                let s3_url = match CONFIG.s3.as_ref().unwrap() {
+                    S3Config { alias: Some(alias), .. } => {
+                        format!("https://{}/{}", alias, relative_url)
+                    }
+                    S3Config { path_style: true, hostname, bucket, .. } => {
+                        format!("https://{}/{}/{}",
+                            hostname,
+                            bucket,
+                            relative_url
+                        )
+                    }
+                    S3Config { path_style: false, hostname, bucket, .. } => {
+                        format!("https://{}.{}/{}",
+                            bucket,
+                            hostname,
+                            relative_url
+                        )
+                    }
+                };
+                return Ok(s3_url);
+            }
+
             Ok(ap_url(&format!(
                 "{}/{}",
                 Instance::get_local()?.public_domain,
-                &file_path
+                relative_url
             )))
         }
     }
 
     pub fn delete(&self, conn: &Connection) -> Result<()> {
         if !self.is_remote {
-            fs::remove_file(self.file_path.as_str())?;
+            if CONFIG.s3.is_some() {
+                #[cfg(not(feature="s3"))]
+                unreachable!();
+
+                #[cfg(feature = "s3")]
+                CONFIG.s3.as_ref().unwrap().get_bucket()
+                    .delete_object_blocking(&self.relative_url().ok_or(Error::NotFound)?)?;
+            } else {
+                fs::remove_file(self.local_path().ok_or(Error::NotFound)?)?;
+            }
         }
         diesel::delete(self)
             .execute(conn)
@@ -206,27 +282,65 @@ impl Media {
     }
 
     // TODO: merge with save_remote?
-    pub fn from_activity(conn: &DbConn, image: &Image) -> Result<Media> {
+    pub fn from_activity(conn: &Connection, image: &Image) -> Result<Media> {
         let remote_url = image
             .url()
             .and_then(|url| url.to_as_uri())
             .ok_or(Error::MissingApProperty)?;
-        let path = determine_mirror_file_path(&remote_url);
-        let parent = path.parent().ok_or(Error::InvalidValue)?;
-        if !parent.is_dir() {
-            DirBuilder::new().recursive(true).create(parent)?;
-        }
 
-        let mut dest = fs::File::create(path.clone())?;
+        let file_path = if CONFIG.s3.is_some() {
-        // TODO: conditional GET
+            #[cfg(not(feature="s3"))]
-        request::get(
+            unreachable!();
-            remote_url.as_str(),
-            User::get_sender(),
-            CONFIG.proxy().cloned(),
-        )?
-        .copy_to(&mut dest)?;
 
-        Media::find_by_file_path(conn, path.to_str().ok_or(Error::InvalidValue)?)
+            #[cfg(feature = "s3")]
+            {
+                use rocket::http::ContentType;
+
+                let dest = determine_mirror_s3_path(&remote_url);
+
+                let media = request::get(
+                    remote_url.as_str(),
+                    User::get_sender(),
+                    CONFIG.proxy().cloned(),
+                )?;
+
+                let content_type = media
+                    .headers()
+                    .get(reqwest::header::CONTENT_TYPE)
+                    .and_then(|x| x.to_str().ok())
+                    .and_then(ContentType::parse_flexible)
+                    .unwrap_or(ContentType::Binary);
+
+                let bytes = media.bytes()?;
+
+                let bucket = CONFIG.s3.as_ref().unwrap().get_bucket();
+                bucket.put_object_with_content_type_blocking(
+                    &dest,
+                    &bytes,
+                    &content_type.to_string()
+                )?;
+
+                dest
+            }
+        } else {
+            let path = determine_mirror_file_path(&remote_url);
+            let parent = path.parent().ok_or(Error::InvalidValue)?;
+            if !parent.is_dir() {
+                DirBuilder::new().recursive(true).create(parent)?;
+            }
+
+            let mut dest = fs::File::create(path.clone())?;
+            // TODO: conditional GET
+            request::get(
+                remote_url.as_str(),
+                User::get_sender(),
+                CONFIG.proxy().cloned(),
+            )?
+            .copy_to(&mut dest)?;
+            path.to_str().ok_or(Error::InvalidValue)?.to_string()
+        };
+
+        Media::find_by_file_path(conn, &file_path)
             .and_then(|mut media| {
                 let mut updated = false;
 
@@ -258,7 +372,7 @@ impl Media {
                     updated = true;
                 }
                 if updated {
-                    diesel::update(&media).set(&media).execute(&**conn)?;
+                    diesel::update(&media).set(&media).execute(conn)?;
                 }
                 Ok(media)
             })
@@ -267,7 +381,7 @@ impl Media {
                 Media::insert(
                     conn,
                     NewMedia {
-                        file_path: path.to_str().ok_or(Error::InvalidValue)?.to_string(),
+                        file_path,
                         alt_text: image
                             .content()
                             .and_then(|content| content.to_as_string())
@@ -307,12 +421,10 @@ impl Media {
 }
 
 fn determine_mirror_file_path(url: &str) -> PathBuf {
-    let mut file_path = Path::new(&super::CONFIG.media_directory).join(REMOTE_MEDIA_DIRECTORY);
+    let mut file_path = Path::new(&CONFIG.media_directory).join(REMOTE_MEDIA_DIRECTORY);
-    Url::parse(url)
+
-        .map(|url| {
+    match Url::parse(url) {
-            if !url.has_host() {
+        Ok(url) if url.has_host() => {
-                return;
-            }
             file_path.push(url.host_str().unwrap());
             for segment in url.path_segments().expect("FIXME") {
                 file_path.push(segment);
@@ -320,19 +432,54 @@ fn determine_mirror_file_path(url: &str) -> PathBuf {
             // TODO: handle query
             // HINT: Use characters which must be percent-encoded in path as separator between path and query
             // HINT: handle extension
-        })
+        }
-        .unwrap_or_else(|err| {
+        other => {
-            warn!("Failed to parse url: {} {}", &url, err);
+            if let Err(err) = other {
+                warn!("Failed to parse url: {} {}", &url, err);
+            } else {
+                warn!("Error without a host: {}", &url);
+            }
             let ext = url
                 .rsplit('.')
                 .next()
                 .map(ToOwned::to_owned)
                 .unwrap_or_else(|| String::from("png"));
             file_path.push(format!("{}.{}", GUID::rand(), ext));
-        });
+        }
+    }
     file_path
 }
 
+#[cfg(feature="s3")]
+fn determine_mirror_s3_path(url: &str) -> String {
+    match Url::parse(url) {
+        Ok(url) if url.has_host() => {
+            format!("static/media/{}/{}/{}",
+                REMOTE_MEDIA_DIRECTORY,
+                url.host_str().unwrap(),
+                url.path().trim_start_matches('/'),
+            )
+        }
+        other => {
+            if let Err(err) = other {
+                warn!("Failed to parse url: {} {}", &url, err);
+            } else {
+                warn!("Error without a host: {}", &url);
+            }
+            let ext = url
+                .rsplit('.')
+                .next()
+                .map(ToOwned::to_owned)
+                .unwrap_or_else(|| String::from("png"));
+            format!("static/media/{}/{}.{}",
+                REMOTE_MEDIA_DIRECTORY,
+                GUID::rand(),
+                ext,
+            )
+        }
+    }
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
@@ -343,7 +490,7 @@ pub(crate) mod tests {
     use std::path::Path;
 
     pub(crate) fn fill_database(conn: &Conn) -> (Vec<User>, Vec<Media>) {
-        let mut wd = current_dir().unwrap().to_path_buf();
+        let mut wd = current_dir().unwrap();
         while wd.pop() {
             if wd.join(".git").exists() {
                 set_current_dir(wd).unwrap();
@@ -456,7 +603,7 @@ pub(crate) mod tests {
             let media = Media::insert(
                 conn,
                 NewMedia {
-                    file_path: path.clone(),
+                    file_path: path,
                     alt_text: "alt message".to_owned(),
                     is_remote: false,
                     remote_url: None,

plume-models/src/mentions.rs

@@ -1,6 +1,6 @@
 use crate::{
-    comments::Comment, db_conn::DbConn, notifications::*, posts::Post, schema::mentions,
+    comments::Comment, notifications::*, posts::Post, schema::mentions, users::User, Connection,
-    users::User, Connection, Error, Result,
+    Error, Result,
 };
 use activitystreams::{
     base::BaseExt,
@@ -60,7 +60,7 @@ impl Mention {
         }
     }
 
-    pub fn build_activity(conn: &DbConn, ment: &str) -> Result<link::Mention> {
+    pub fn build_activity(conn: &Connection, ment: &str) -> Result<link::Mention> {
         let user = User::find_by_fqn(conn, ment)?;
         let mut mention = link::Mention::new();
         mention.set_href(user.ap_url.parse::<IriString>()?);

plume-models/src/password_reset_requests.rs

@@ -89,7 +89,7 @@ mod tests {
             let request = PasswordResetRequest::find_by_token(&conn, &token)
                 .expect("couldn't retrieve request");
 
-            assert!(&token.len() > &32);
+            assert!(token.len() > 32);
             assert_eq!(&request.email, &admin_email);
 
             Ok(())
@@ -103,8 +103,8 @@ mod tests {
             user_tests::fill_database(&conn);
             let admin_email = "admin@example.com";
 
-            PasswordResetRequest::insert(&conn, &admin_email).expect("couldn't insert new request");
+            PasswordResetRequest::insert(&conn, admin_email).expect("couldn't insert new request");
-            PasswordResetRequest::insert(&conn, &admin_email)
+            PasswordResetRequest::insert(&conn, admin_email)
                 .expect("couldn't insert second request");
 
             let count = password_reset_requests::table.count().get_result(&*conn);
@@ -132,7 +132,7 @@ mod tests {
                 .execute(&*conn)
                 .expect("could not insert request");
 
-            match PasswordResetRequest::find_by_token(&conn, &token) {
+            match PasswordResetRequest::find_by_token(&conn, token) {
                 Err(Error::Expired) => (),
                 _ => panic!("Received unexpected result finding expired token"),
             }
@@ -148,7 +148,7 @@ mod tests {
             user_tests::fill_database(&conn);
             let admin_email = "admin@example.com";
 
-            let token = PasswordResetRequest::insert(&conn, &admin_email)
+            let token = PasswordResetRequest::insert(&conn, admin_email)
                 .expect("couldn't insert new request");
             PasswordResetRequest::find_and_delete_by_token(&conn, &token)
                 .expect("couldn't find and delete request");

plume-models/src/posts.rs

@@ -1,7 +1,7 @@
 use crate::{
-    ap_url, blogs::Blog, db_conn::DbConn, instance::Instance, medias::Media, mentions::Mention,
+    ap_url, blogs::Blog, instance::Instance, medias::Media, mentions::Mention, post_authors::*,
-    post_authors::*, safe_string::SafeString, schema::posts, tags::*, timeline::*, users::User,
+    safe_string::SafeString, schema::posts, tags::*, timeline::*, users::User, Connection, Error,
-    Connection, Error, PostEvent::*, Result, CONFIG, POST_CHAN,
+    PostEvent::*, Result, CONFIG, POST_CHAN,
 };
 use activitystreams::{
     activity::{Create, Delete, Update},
@@ -12,7 +12,7 @@ use activitystreams::{
     prelude::*,
     time::OffsetDateTime,
 };
-use chrono::{NaiveDateTime, Utc};
+use chrono::{DateTime, NaiveDateTime, Utc};
 use diesel::{self, BelongingToDsl, ExpressionMethods, QueryDsl, RunQueryDsl};
 use once_cell::sync::Lazy;
 use plume_common::{
@@ -134,7 +134,7 @@ impl Post {
             .filter(posts::published.eq(true))
             .count()
             .load(conn)?
-            .get(0)
+            .first()
             .cloned()
             .ok_or(Error::NotFound)
     }
@@ -255,7 +255,7 @@ impl Post {
         ap_url(&format!(
             "{}/~/{}/{}/",
             CONFIG.base_url,
-            blog.fqn,
+            iri_percent_encode_seg(&blog.fqn),
             iri_percent_encode_seg(slug)
         ))
     }
@@ -373,7 +373,8 @@ impl Post {
         }))?;
         article.set_source(source);
         article.set_published(
-            OffsetDateTime::from_unix_timestamp_nanos(self.creation_date.timestamp_nanos().into())
+            //EZABATU OffsetDateTime::from_unix_timestamp_nanos(self.creation_date.timestamp_nanos_opt().unwrap().into())
+            OffsetDateTime::from_unix_timestamp_nanos(self.creation_date.and_utc().timestamp_nanos_opt().unwrap().into())
                 .expect("OffsetDateTime"),
         );
         article.set_summary(&*self.subtitle);
@@ -465,7 +466,7 @@ impl Post {
             .collect::<HashSet<_>>();
         for (m, id) in &mentions {
             if !old_user_mentioned.contains(id) {
-                Mention::from_activity(&*conn, m, self.id, true, true)?;
+                Mention::from_activity(conn, m, self.id, true, true)?;
             }
         }
 
@@ -488,7 +489,7 @@ impl Post {
             .filter_map(|t| t.name.as_ref().map(|name| name.as_str().to_string()))
             .collect::<HashSet<_>>();
 
-        let old_tags = Tag::for_post(&*conn, self.id)?;
+        let old_tags = Tag::for_post(conn, self.id)?;
         let old_tags_name = old_tags
             .iter()
             .filter_map(|tag| {
@@ -525,7 +526,7 @@ impl Post {
             .filter_map(|t| t.name.as_ref().map(|name| name.as_str().to_string()))
             .collect::<HashSet<_>>();
 
-        let old_tags = Tag::for_post(&*conn, self.id)?;
+        let old_tags = Tag::for_post(conn, self.id)?;
         let old_tags_name = old_tags
             .iter()
             .filter_map(|tag| {
@@ -615,15 +616,15 @@ impl Post {
     }
 }
 
-impl FromId<DbConn> for Post {
+impl FromId<Connection> for Post {
     type Error = Error;
     type Object = LicensedArticle;
 
-    fn from_db(conn: &DbConn, id: &str) -> Result<Self> {
+    fn from_db(conn: &Connection, id: &str) -> Result<Self> {
         Self::find_by_ap_url(conn, id)
     }
 
-    fn from_activity(conn: &DbConn, article: LicensedArticle) -> Result<Self> {
+    fn from_activity(conn: &Connection, article: LicensedArticle) -> Result<Self> {
         let license = article.ext_one.license.unwrap_or_default();
         let article = article.inner;
 
@@ -752,12 +753,31 @@ impl FromId<DbConn> for Post {
                         license,
                         // FIXME: This is wrong: with this logic, we may use the display URL as the AP ID. We need two different fields
                         ap_url,
+			creation_date: article.published().map(|published| {
+    			    let timestamp_secs = published.unix_timestamp();
+    			    let timestamp_nanos = published.unix_timestamp_nanos()
+        			- (timestamp_secs as i128) * 1000i128 * 1000i128 * 1000i128;
+
+    			    DateTime::from_timestamp(
+        			timestamp_secs,
+        			timestamp_nanos as u32,
+    			    )
+    			    .unwrap()
+    			    .naive_utc()
+			}),	
+			/*
+			EZABATU
                         creation_date: article.published().map(|published| {
                             let timestamp_secs = published.unix_timestamp();
                             let timestamp_nanos = published.unix_timestamp_nanos()
                                 - (timestamp_secs as i128) * 1000i128 * 1000i128 * 1000i128;
-                            NaiveDateTime::from_timestamp(timestamp_secs, timestamp_nanos as u32)
+                            NaiveDateTime::from_timestamp_opt(
+                                timestamp_secs,
+                                timestamp_nanos as u32,
+                            )
+                            .unwrap()
                         }),
+			*/
                         subtitle: article
                             .summary()
                             .and_then(|summary| summary.to_as_string())
@@ -817,21 +837,21 @@ impl FromId<DbConn> for Post {
     }
 }
 
-impl AsObject<User, Create, &DbConn> for Post {
+impl AsObject<User, Create, &Connection> for Post {
     type Error = Error;
     type Output = Self;
 
-    fn activity(self, _conn: &DbConn, _actor: User, _id: &str) -> Result<Self::Output> {
+    fn activity(self, _conn: &Connection, _actor: User, _id: &str) -> Result<Self::Output> {
         // TODO: check that _actor is actually one of the author?
         Ok(self)
     }
 }
 
-impl AsObject<User, Delete, &DbConn> for Post {
+impl AsObject<User, Delete, &Connection> for Post {
     type Error = Error;
     type Output = ();
 
-    fn activity(self, conn: &DbConn, actor: User, _id: &str) -> Result<Self::Output> {
+    fn activity(self, conn: &Connection, actor: User, _id: &str) -> Result<Self::Output> {
         let can_delete = self
             .get_authors(conn)?
             .into_iter()
@@ -855,16 +875,16 @@ pub struct PostUpdate {
     pub tags: Option<serde_json::Value>,
 }
 
-impl FromId<DbConn> for PostUpdate {
+impl FromId<Connection> for PostUpdate {
     type Error = Error;
     type Object = LicensedArticle;
 
-    fn from_db(_: &DbConn, _: &str) -> Result<Self> {
+    fn from_db(_: &Connection, _: &str) -> Result<Self> {
         // Always fail because we always want to deserialize the AP object
         Err(Error::NotFound)
     }
 
-    fn from_activity(conn: &DbConn, updated: Self::Object) -> Result<Self> {
+    fn from_activity(conn: &Connection, updated: Self::Object) -> Result<Self> {
         let mut post_update = PostUpdate {
             ap_url: updated
                 .ap_object_ref()
@@ -919,11 +939,11 @@ impl FromId<DbConn> for PostUpdate {
     }
 }
 
-impl AsObject<User, Update, &DbConn> for PostUpdate {
+impl AsObject<User, Update, &Connection> for PostUpdate {
     type Error = Error;
     type Output = ();
 
-    fn activity(self, conn: &DbConn, actor: User, _id: &str) -> Result<()> {
+    fn activity(self, conn: &Connection, actor: User, _id: &str) -> Result<()> {
         let mut post =
             Post::from_id(conn, &self.ap_url, None, CONFIG.proxy()).map_err(|(_, e)| e)?;
 
@@ -1023,6 +1043,7 @@ impl From<PostEvent> for Arc<Post> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::db_conn::DbConn;
     use crate::inbox::{inbox, tests::fill_database, InboxResult};
     use crate::mentions::{Mention, NewMention};
     use crate::safe_string::SafeString;
@@ -1036,7 +1057,7 @@ mod tests {
         let post = &posts[0];
         let mentioned = &users[1];
         let mention = Mention::insert(
-            &conn,
+            conn,
             NewMention {
                 mentioned_id: mentioned.id,
                 post_id: Some(post.id),
@@ -1044,7 +1065,7 @@ mod tests {
             },
         )
         .unwrap();
-        (post.to_owned(), mention.to_owned(), posts, users, blogs)
+        (post.to_owned(), mention, posts, users, blogs)
     }
 
     // creates a post, get it's Create activity, delete the post,
@@ -1053,9 +1074,9 @@ mod tests {
     fn self_federation() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (_, users, blogs) = fill_database(&conn);
+            let (_, users, blogs) = fill_database(conn);
             let post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "yo".into(),
@@ -1072,19 +1093,19 @@ mod tests {
             )
             .unwrap();
             PostAuthor::insert(
-                &conn,
+                conn,
                 NewPostAuthor {
                     post_id: post.id,
                     author_id: users[0].id,
                 },
             )
             .unwrap();
-            let create = post.create_activity(&conn).unwrap();
+            let create = post.create_activity(conn).unwrap();
-            post.delete(&conn).unwrap();
+            post.delete(conn).unwrap();
 
-            match inbox(&conn, serde_json::to_value(create).unwrap()).unwrap() {
+            match inbox(conn, serde_json::to_value(create).unwrap()).unwrap() {
                 InboxResult::Post(p) => {
-                    assert!(p.is_author(&conn, users[0].id).unwrap());
+                    assert!(p.is_author(conn, users[0].id).unwrap());
                     assert_eq!(p.source, "Hello".to_owned());
                     assert_eq!(p.blog_id, blogs[0].id);
                     assert_eq!(p.content, SafeString::new("Hello"));
@@ -1221,7 +1242,7 @@ mod tests {
             let actual = to_value(act)?;
 
             let id = actual["id"].to_string();
-            let (id_pre, id_post) = id.rsplit_once("-").unwrap();
+            let (id_pre, id_post) = id.rsplit_once('-').unwrap();
             assert_eq!(post.ap_url, "https://plu.me/~/BlogName/testing");
             assert_eq!(
                 id_pre,

plume-models/src/remote_fetch_actor.rs

@@ -45,6 +45,12 @@ impl Actor for RemoteFetchActor {
             RemoteUserFound(user) => match self.conn.get() {
                 Ok(conn) => {
                     let conn = DbConn(conn);
+                    if user
+                        .get_instance(&conn)
+                        .map_or(false, |instance| instance.blocked)
+                    {
+                        return;
+                    }
                     // Don't call these functions in parallel
                     // for the case database connections limit is too small
                     fetch_and_cache_articles(&user, &conn);

plume-models/src/reshares.rs

@@ -1,6 +1,6 @@
 use crate::{
-    db_conn::DbConn, instance::Instance, notifications::*, posts::Post, schema::reshares,
+    instance::Instance, notifications::*, posts::Post, schema::reshares, timeline::*, users::User,
-    timeline::*, users::User, Connection, Error, Result, CONFIG,
+    Connection, Error, Result, CONFIG,
 };
 use activitystreams::{
     activity::{ActorAndObjectRef, Announce, Undo},
@@ -113,11 +113,11 @@ impl Reshare {
     }
 }
 
-impl AsObject<User, Announce, &DbConn> for Post {
+impl AsObject<User, Announce, &Connection> for Post {
     type Error = Error;
     type Output = Reshare;
 
-    fn activity(self, conn: &DbConn, actor: User, id: &str) -> Result<Reshare> {
+    fn activity(self, conn: &Connection, actor: User, id: &str) -> Result<Reshare> {
         let conn = conn;
         let reshare = Reshare::insert(
             conn,
@@ -134,15 +134,15 @@ impl AsObject<User, Announce, &DbConn> for Post {
     }
 }
 
-impl FromId<DbConn> for Reshare {
+impl FromId<Connection> for Reshare {
     type Error = Error;
     type Object = Announce;
 
-    fn from_db(conn: &DbConn, id: &str) -> Result<Self> {
+    fn from_db(conn: &Connection, id: &str) -> Result<Self> {
         Reshare::find_by_ap_url(conn, id)
     }
 
-    fn from_activity(conn: &DbConn, act: Announce) -> Result<Self> {
+    fn from_activity(conn: &Connection, act: Announce) -> Result<Self> {
         let res = Reshare::insert(
             conn,
             NewReshare {
@@ -183,17 +183,17 @@ impl FromId<DbConn> for Reshare {
     }
 }
 
-impl AsObject<User, Undo, &DbConn> for Reshare {
+impl AsObject<User, Undo, &Connection> for Reshare {
     type Error = Error;
     type Output = ();
 
-    fn activity(self, conn: &DbConn, actor: User, _id: &str) -> Result<()> {
+    fn activity(self, conn: &Connection, actor: User, _id: &str) -> Result<()> {
         if actor.id == self.user_id {
-            diesel::delete(&self).execute(&**conn)?;
+            diesel::delete(&self).execute(conn)?;
 
             // delete associated notification if any
             if let Ok(notif) = Notification::find(conn, notification_kind::RESHARE, self.id) {
-                diesel::delete(&notif).execute(&**conn)?;
+                diesel::delete(&notif).execute(conn)?;
             }
 
             Ok(())
@@ -229,7 +229,7 @@ mod test {
             let (posts, _users, _blogs) = fill_database(&conn);
             let post = &posts[0];
             let user = &post.get_authors(&conn)?[0];
-            let reshare = Reshare::insert(&*conn, NewReshare::new(post, user))?;
+            let reshare = Reshare::insert(&conn, NewReshare::new(post, user))?;
             let act = reshare.to_activity(&conn).unwrap();
 
             let expected = json!({
@@ -253,8 +253,8 @@ mod test {
             let (posts, _users, _blogs) = fill_database(&conn);
             let post = &posts[0];
             let user = &post.get_authors(&conn)?[0];
-            let reshare = Reshare::insert(&*conn, NewReshare::new(post, user))?;
+            let reshare = Reshare::insert(&conn, NewReshare::new(post, user))?;
-            let act = reshare.build_undo(&*conn)?;
+            let act = reshare.build_undo(&conn)?;
 
             let expected = json!({
                 "actor": "https://plu.me/@/admin/",

plume-models/src/safe_string.rs

@@ -93,7 +93,7 @@ fn url_add_prefix(url: &str) -> Option<Cow<'_, str>> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, AsExpression, FromSqlRow, Default)]
+#[derive(Debug, Clone, PartialEq, Eq, AsExpression, FromSqlRow, Default)]
 #[sql_type = "Text"]
 pub struct SafeString {
     value: String,

plume-models/src/search/actor.rs

@@ -108,7 +108,7 @@ mod tests {
 
         let searcher = Arc::new(get_searcher(&CONFIG.search_tokenizers));
         SearchActor::init(searcher.clone(), db_pool.clone());
-        let conn = db_pool.clone().get().unwrap();
+        let conn = db_pool.get().unwrap();
 
         let title = random_hex()[..8].to_owned();
         let (_instance, _user, blog) = fill_database(&conn);
@@ -161,41 +161,43 @@ mod tests {
                     long_description_html: "<p>Good morning</p>".to_string(),
                     short_description: SafeString::new("Hello"),
                     short_description_html: "<p>Hello</p>".to_string(),
-                    name: random_hex().to_string(),
+                    name: random_hex(),
                     open_registrations: true,
-                    public_domain: random_hex().to_string(),
+                    public_domain: random_hex(),
                 },
             )
             .unwrap();
             let user = User::insert(
                 conn,
                 NewUser {
-                    username: random_hex().to_string(),
+                    username: random_hex(),
-                    display_name: random_hex().to_string(),
+                    display_name: random_hex(),
-                    outbox_url: random_hex().to_string(),
+                    outbox_url: random_hex(),
-                    inbox_url: random_hex().to_string(),
+                    inbox_url: random_hex(),
                     summary: "".to_string(),
                     email: None,
                     hashed_password: None,
                     instance_id: instance.id,
-                    ap_url: random_hex().to_string(),
+                    ap_url: random_hex(),
                     private_key: None,
                     public_key: "".to_string(),
                     shared_inbox_url: None,
-                    followers_endpoint: random_hex().to_string(),
+                    followers_endpoint: random_hex(),
                     avatar_id: None,
                     summary_html: SafeString::new(""),
                     role: 0,
-                    fqn: random_hex().to_string(),
+                    fqn: random_hex(),
                 },
             )
             .unwrap();
-            let mut blog = NewBlog::default();
+            let blog = NewBlog {
-            blog.instance_id = instance.id;
+                instance_id: instance.id,
-            blog.actor_id = random_hex().to_string();
+                actor_id: random_hex(),
-            blog.ap_url = random_hex().to_string();
+                ap_url: random_hex(),
-            blog.inbox_url = random_hex().to_string();
+                inbox_url: random_hex(),
-            blog.outbox_url = random_hex().to_string();
+                outbox_url: random_hex(),
+                ..Default::default()
+            };
             let blog = Blog::insert(conn, blog).unwrap();
             BlogAuthor::insert(
                 conn,

plume-models/src/search/mod.rs

@@ -154,7 +154,7 @@ pub(crate) mod tests {
                 },
             )
             .unwrap();
-            searcher.add_document(&conn, &post).unwrap();
+            searcher.add_document(conn, &post).unwrap();
             searcher.commit();
             assert_eq!(
                 searcher.search_document(conn, Query::from_str(&title).unwrap(), (0, 1))[0].id,

plume-models/src/search/query.rs

@@ -93,8 +93,9 @@ macro_rules! gen_to_string {
         }
         )*
         $(
-        for val in &$self.$date {
+        //for val in &$self.$date {
-            $result.push_str(&format!("{}:{} ", stringify!($date), NaiveDate::from_num_days_from_ce(*val as i32).format("%Y-%m-%d")));
+	if let Some(val) = &$self.$date {
+            $result.push_str(&format!("{}:{} ", stringify!($date), NaiveDate::from_num_days_from_ce_opt(*val as i32).unwrap().format("%Y-%m-%d")));
         }
         )*
     }
@@ -180,12 +181,16 @@ impl PlumeQuery {
 
         if self.before.is_some() || self.after.is_some() {
             // if at least one range bound is provided
-            let after = self
+            let after = self.after.unwrap_or_else(|| {
-                .after
+                i64::from(
-                .unwrap_or_else(|| i64::from(NaiveDate::from_ymd(2000, 1, 1).num_days_from_ce()));
+                    NaiveDate::from_ymd_opt(2000, 1, 1)
+                        .unwrap()
+                        .num_days_from_ce(),
+                )
+            });
             let before = self
                 .before
-                .unwrap_or_else(|| i64::from(Utc::today().num_days_from_ce()));
+                .unwrap_or_else(|| i64::from(Utc::now().date_naive().num_days_from_ce()));
             let field = Searcher::schema().get_field("creation_date").unwrap();
             let range =
                 RangeQuery::new_i64_bounds(field, Bound::Included(after), Bound::Included(before));
@@ -202,16 +207,20 @@ impl PlumeQuery {
     pub fn before<D: Datelike>(&mut self, date: &D) -> &mut Self {
         let before = self
             .before
-            .unwrap_or_else(|| i64::from(Utc::today().num_days_from_ce()));
+            .unwrap_or_else(|| i64::from(Utc::now().date_naive().num_days_from_ce()));
         self.before = Some(cmp::min(before, i64::from(date.num_days_from_ce())));
         self
     }
 
     // documents older than the provided date will be ignored
     pub fn after<D: Datelike>(&mut self, date: &D) -> &mut Self {
-        let after = self
+        let after = self.after.unwrap_or_else(|| {
-            .after
+            i64::from(
-            .unwrap_or_else(|| i64::from(NaiveDate::from_ymd(2000, 1, 1).num_days_from_ce()));
+                NaiveDate::from_ymd_opt(2000, 1, 1)
+                    .unwrap()
+                    .num_days_from_ce(),
+            )
+        });
         self.after = Some(cmp::max(after, i64::from(date.num_days_from_ce())));
         self
     }

plume-models/src/tags.rs

@@ -92,7 +92,7 @@ mod tests {
             let (posts, _users, _blogs) = fill_database(conn);
             let post_id = posts[0].id;
             let mut ht = Hashtag::new();
-            ht.set_href(ap_url(&format!("https://plu.me/tag/a_tag")).parse::<IriString>()?);
+            ht.set_href(ap_url("https://plu.me/tag/a_tag").parse::<IriString>()?);
             ht.set_name("a_tag".to_string());
             let tag = Tag::from_activity(conn, &ht, post_id, true)?;
 

plume-models/src/timeline/mod.rs

@@ -1,5 +1,4 @@
 use crate::{
-    db_conn::DbConn,
     lists::List,
     posts::Post,
     schema::{posts, timeline, timeline_definition},
@@ -7,14 +6,13 @@ use crate::{
 };
 use diesel::{self, BoolExpressionMethods, ExpressionMethods, QueryDsl, RunQueryDsl};
 use std::cmp::Ordering;
-use std::ops::Deref;
 
 pub(crate) mod query;
 
 pub use self::query::Kind;
-use self::query::{QueryError, TimelineQuery};
+pub use self::query::{QueryError, TimelineQuery};
 
-#[derive(Clone, Debug, PartialEq, Queryable, Identifiable, AsChangeset)]
+#[derive(Clone, Debug, PartialEq, Eq, Queryable, Identifiable, AsChangeset)]
 #[table_name = "timeline_definition"]
 pub struct Timeline {
     pub id: i32,
@@ -220,9 +218,10 @@ impl Timeline {
             .map_err(Error::from)
     }
 
-    pub fn add_to_all_timelines(conn: &DbConn, post: &Post, kind: Kind<'_>) -> Result<()> {
+    pub fn add_to_all_timelines(conn: &Connection, post: &Post, kind: Kind<'_>) -> Result<()> {
         let timelines = timeline_definition::table
-            .load::<Self>(conn.deref())
+            //.load::<Self>(conn.deref())
+            .load::<Self>(conn)
             .map_err(Error::from)?;
 
         for t in timelines {
@@ -246,7 +245,26 @@ impl Timeline {
         Ok(())
     }
 
-    pub fn matches(&self, conn: &DbConn, post: &Post, kind: Kind<'_>) -> Result<bool> {
+    pub fn remove_post(&self, conn: &Connection, post: &Post) -> Result<bool> {
+        if self.includes_post(conn, post)? {
+            return Ok(false);
+        }
+        diesel::delete(
+            timeline::table
+                .filter(timeline::timeline_id.eq(self.id))
+                .filter(timeline::post_id.eq(post.id)),
+        )
+        .execute(conn)?;
+        Ok(true)
+    }
+
+    pub fn remove_all_posts(&self, conn: &Connection) -> Result<u64> {
+        let count = diesel::delete(timeline::table.filter(timeline::timeline_id.eq(self.id)))
+            .execute(conn)?;
+        Ok(count as u64)
+    }
+
+    pub fn matches(&self, conn: &Connection, post: &Post, kind: Kind<'_>) -> Result<bool> {
         let query = TimelineQuery::parse(&self.query)?;
         query.matches(conn, self, post, kind)
     }
@@ -282,73 +300,63 @@ mod tests {
     fn test_timeline() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let users = userTests::fill_database(&conn);
+            let users = userTests::fill_database(conn);
 
             let mut tl1_u1 = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "my timeline".to_owned(),
                 "all".to_owned(),
             )
             .unwrap();
-            List::new(
+            List::new(conn, "languages I speak", Some(&users[1]), ListType::Prefix).unwrap();
-                &conn,
-                "languages I speak",
-                Some(&users[1]),
-                ListType::Prefix,
-            )
-            .unwrap();
             let tl2_u1 = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "another timeline".to_owned(),
                 "followed".to_owned(),
             )
             .unwrap();
             let tl1_u2 = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[1].id,
                 "english posts".to_owned(),
                 "lang in \"languages I speak\"".to_owned(),
             )
             .unwrap();
             let tl1_instance = Timeline::new_for_instance(
-                &conn,
+                conn,
                 "english posts".to_owned(),
                 "license in [cc]".to_owned(),
             )
             .unwrap();
 
-            assert_eq!(tl1_u1, Timeline::get(&conn, tl1_u1.id).unwrap());
+            assert_eq!(tl1_u1, Timeline::get(conn, tl1_u1.id).unwrap());
             assert_eq!(
                 tl2_u1,
-                Timeline::find_for_user_by_name(&conn, Some(users[0].id), "another timeline")
+                Timeline::find_for_user_by_name(conn, Some(users[0].id), "another timeline")
                     .unwrap()
             );
             assert_eq!(
                 tl1_instance,
-                Timeline::find_for_user_by_name(&conn, None, "english posts").unwrap()
+                Timeline::find_for_user_by_name(conn, None, "english posts").unwrap()
             );
 
-            let tl_u1 = Timeline::list_for_user(&conn, Some(users[0].id)).unwrap();
+            let tl_u1 = Timeline::list_for_user(conn, Some(users[0].id)).unwrap();
             assert_eq!(3, tl_u1.len()); // it is not 2 because there is a "Your feed" tl created for each user automatically
-            assert!(tl_u1.iter().fold(false, |res, tl| { res || *tl == tl1_u1 }));
+            assert!(tl_u1.iter().any(|tl| *tl == tl1_u1));
-            assert!(tl_u1.iter().fold(false, |res, tl| { res || *tl == tl2_u1 }));
+            assert!(tl_u1.iter().any(|tl| *tl == tl2_u1));
 
-            let tl_instance = Timeline::list_for_user(&conn, None).unwrap();
+            let tl_instance = Timeline::list_for_user(conn, None).unwrap();
             assert_eq!(3, tl_instance.len()); // there are also the local and federated feed by default
-            assert!(tl_instance
+            assert!(tl_instance.iter().any(|tl| *tl == tl1_instance));
-                .iter()
-                .fold(false, |res, tl| { res || *tl == tl1_instance }));
 
             tl1_u1.name = "My Super TL".to_owned();
-            let new_tl1_u2 = tl1_u2.update(&conn).unwrap();
+            let new_tl1_u2 = tl1_u2.update(conn).unwrap();
 
-            let tl_u2 = Timeline::list_for_user(&conn, Some(users[1].id)).unwrap();
+            let tl_u2 = Timeline::list_for_user(conn, Some(users[1].id)).unwrap();
             assert_eq!(2, tl_u2.len()); // same here
-            assert!(tl_u2
+            assert!(tl_u2.iter().any(|tl| *tl == new_tl1_u2));
-                .iter()
-                .fold(false, |res, tl| { res || *tl == new_tl1_u2 }));
 
             Ok(())
         });
@@ -358,48 +366,48 @@ mod tests {
     fn test_timeline_creation_error() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let users = userTests::fill_database(&conn);
+            let users = userTests::fill_database(conn);
 
             assert!(Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "my timeline".to_owned(),
                 "invalid keyword".to_owned(),
             )
             .is_err());
             assert!(Timeline::new_for_instance(
-                &conn,
+                conn,
                 "my timeline".to_owned(),
                 "invalid keyword".to_owned(),
             )
             .is_err());
 
             assert!(Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "my timeline".to_owned(),
                 "author in non_existant_list".to_owned(),
             )
             .is_err());
             assert!(Timeline::new_for_instance(
-                &conn,
+                conn,
                 "my timeline".to_owned(),
                 "lang in dont-exist".to_owned(),
             )
             .is_err());
 
-            List::new(&conn, "friends", Some(&users[0]), ListType::User).unwrap();
+            List::new(conn, "friends", Some(&users[0]), ListType::User).unwrap();
-            List::new(&conn, "idk", None, ListType::Blog).unwrap();
+            List::new(conn, "idk", None, ListType::Blog).unwrap();
 
             assert!(Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "my timeline".to_owned(),
                 "blog in friends".to_owned(),
             )
             .is_err());
             assert!(Timeline::new_for_instance(
-                &conn,
+                conn,
                 "my timeline".to_owned(),
                 "not author in idk".to_owned(),
             )
@@ -413,10 +421,10 @@ mod tests {
     fn test_simple_match() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (users, blogs) = blogTests::fill_database(&conn);
+            let (users, blogs) = blogTests::fill_database(conn);
 
             let gnu_tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "GNU timeline".to_owned(),
                 "license in [AGPL, LGPL, GPL]".to_owned(),
@@ -424,7 +432,7 @@ mod tests {
             .unwrap();
 
             let gnu_post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "slug".to_string(),
@@ -440,10 +448,10 @@ mod tests {
                 },
             )
             .unwrap();
-            assert!(gnu_tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(gnu_tl.matches(conn, &gnu_post, Kind::Original).unwrap());
 
             let non_free_post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "slug2".to_string(),
@@ -460,7 +468,7 @@ mod tests {
             )
             .unwrap();
             assert!(!gnu_tl
-                .matches(&conn, &non_free_post, Kind::Original)
+                .matches(conn, &non_free_post, Kind::Original)
                 .unwrap());
 
             Ok(())
@@ -471,9 +479,9 @@ mod tests {
     fn test_complex_match() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (users, blogs) = blogTests::fill_database(&conn);
+            let (users, blogs) = blogTests::fill_database(conn);
             Follow::insert(
-                &conn,
+                conn,
                 NewFollow {
                     follower_id: users[0].id,
                     following_id: users[1].id,
@@ -483,11 +491,11 @@ mod tests {
             .unwrap();
 
             let fav_blogs_list =
-                List::new(&conn, "fav_blogs", Some(&users[0]), ListType::Blog).unwrap();
+                List::new(conn, "fav_blogs", Some(&users[0]), ListType::Blog).unwrap();
-            fav_blogs_list.add_blogs(&conn, &[blogs[0].id]).unwrap();
+            fav_blogs_list.add_blogs(conn, &[blogs[0].id]).unwrap();
 
             let my_tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "My timeline".to_owned(),
                 "blog in fav_blogs and not has_cover or local and followed exclude likes"
@@ -496,7 +504,7 @@ mod tests {
             .unwrap();
 
             let post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "about-linux".to_string(),
@@ -512,10 +520,10 @@ mod tests {
                 },
             )
             .unwrap();
-            assert!(my_tl.matches(&conn, &post, Kind::Original).unwrap()); // matches because of "blog in fav_blogs" (and there is no cover)
+            assert!(my_tl.matches(conn, &post, Kind::Original).unwrap()); // matches because of "blog in fav_blogs" (and there is no cover)
 
             let post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[1].id,
                     slug: "about-linux-2".to_string(),
@@ -533,7 +541,7 @@ mod tests {
                 },
             )
             .unwrap();
-            assert!(!my_tl.matches(&conn, &post, Kind::Like(&users[1])).unwrap());
+            assert!(!my_tl.matches(conn, &post, Kind::Like(&users[1])).unwrap());
 
             Ok(())
         });
@@ -543,17 +551,17 @@ mod tests {
     fn test_add_to_all_timelines() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (users, blogs) = blogTests::fill_database(&conn);
+            let (users, blogs) = blogTests::fill_database(conn);
 
             let gnu_tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "GNU timeline".to_owned(),
                 "license in [AGPL, LGPL, GPL]".to_owned(),
             )
             .unwrap();
             let non_gnu_tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "Stallman disapproved timeline".to_owned(),
                 "not license in [AGPL, LGPL, GPL]".to_owned(),
@@ -561,7 +569,7 @@ mod tests {
             .unwrap();
 
             let gnu_post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "slug".to_string(),
@@ -579,7 +587,7 @@ mod tests {
             .unwrap();
 
             let non_free_post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "slug2".to_string(),
@@ -596,13 +604,13 @@ mod tests {
             )
             .unwrap();
 
-            Timeline::add_to_all_timelines(&conn, &gnu_post, Kind::Original).unwrap();
+            Timeline::add_to_all_timelines(conn, &gnu_post, Kind::Original).unwrap();
-            Timeline::add_to_all_timelines(&conn, &non_free_post, Kind::Original).unwrap();
+            Timeline::add_to_all_timelines(conn, &non_free_post, Kind::Original).unwrap();
 
-            let res = gnu_tl.get_latest(&conn, 2).unwrap();
+            let res = gnu_tl.get_latest(conn, 2).unwrap();
             assert_eq!(res.len(), 1);
             assert_eq!(res[0].id, gnu_post.id);
-            let res = non_gnu_tl.get_latest(&conn, 2).unwrap();
+            let res = non_gnu_tl.get_latest(conn, 2).unwrap();
             assert_eq!(res.len(), 1);
             assert_eq!(res[0].id, non_free_post.id);
 
@@ -614,10 +622,10 @@ mod tests {
     fn test_matches_lists_direct() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (users, blogs) = blogTests::fill_database(&conn);
+            let (users, blogs) = blogTests::fill_database(conn);
 
             let gnu_post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "slug".to_string(),
@@ -634,63 +642,63 @@ mod tests {
             )
             .unwrap();
             gnu_post
-                .update_tags(&conn, vec![Tag::build_activity("free".to_owned()).unwrap()])
+                .update_tags(conn, vec![Tag::build_activity("free".to_owned()).unwrap()])
                 .unwrap();
             PostAuthor::insert(
-                &conn,
+                conn,
                 NewPostAuthor {
                     post_id: gnu_post.id,
-                    author_id: blogs[0].list_authors(&conn).unwrap()[0].id,
+                    author_id: blogs[0].list_authors(conn).unwrap()[0].id,
                 },
             )
             .unwrap();
 
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "blog timeline".to_owned(),
                 format!("blog in [{}]", blogs[0].fqn),
             )
             .unwrap();
-            assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "blog timeline".to_owned(),
                 "blog in [no_one@nowhere]".to_owned(),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
 
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "author timeline".to_owned(),
                 format!(
                     "author in [{}]",
-                    blogs[0].list_authors(&conn).unwrap()[0].fqn
+                    blogs[0].list_authors(conn).unwrap()[0].fqn
                 ),
             )
             .unwrap();
-            assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "author timeline".to_owned(),
                 format!("author in [{}]", users[2].fqn),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
             assert!(tl
-                .matches(&conn, &gnu_post, Kind::Reshare(&users[2]))
+                .matches(conn, &gnu_post, Kind::Reshare(&users[2]))
                 .unwrap());
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Like(&users[2])).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Like(&users[2])).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "author timeline".to_owned(),
                 format!(
@@ -699,50 +707,50 @@ mod tests {
                 ),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
             assert!(!tl
-                .matches(&conn, &gnu_post, Kind::Reshare(&users[2]))
+                .matches(conn, &gnu_post, Kind::Reshare(&users[2]))
                 .unwrap());
-            assert!(tl.matches(&conn, &gnu_post, Kind::Like(&users[2])).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Like(&users[2])).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
 
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "tag timeline".to_owned(),
                 "tags in [free]".to_owned(),
             )
             .unwrap();
-            assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "tag timeline".to_owned(),
                 "tags in [private]".to_owned(),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
 
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "english timeline".to_owned(),
                 "lang in [en]".to_owned(),
             )
             .unwrap();
-            assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "franco-italian timeline".to_owned(),
                 "lang in [fr, it]".to_owned(),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
 
             Ok(())
         });
@@ -786,10 +794,10 @@ mod tests {
     fn test_matches_keyword() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let (users, blogs) = blogTests::fill_database(&conn);
+            let (users, blogs) = blogTests::fill_database(conn);
 
             let gnu_post = Post::insert(
-                &conn,
+                conn,
                 NewPost {
                     blog_id: blogs[0].id,
                     slug: "slug".to_string(),
@@ -807,61 +815,61 @@ mod tests {
             .unwrap();
 
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "Linux title".to_owned(),
                 "title contains Linux".to_owned(),
             )
             .unwrap();
-            assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "Microsoft title".to_owned(),
                 "title contains Microsoft".to_owned(),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
 
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "Linux subtitle".to_owned(),
                 "subtitle contains Stallman".to_owned(),
             )
             .unwrap();
-            assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "Microsoft subtitle".to_owned(),
                 "subtitle contains Nadella".to_owned(),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
 
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "Linux content".to_owned(),
                 "content contains Linux".to_owned(),
             )
             .unwrap();
-            assert!(tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
             let tl = Timeline::new_for_user(
-                &conn,
+                conn,
                 users[0].id,
                 "Microsoft content".to_owned(),
                 "subtitle contains Windows".to_owned(),
             )
             .unwrap();
-            assert!(!tl.matches(&conn, &gnu_post, Kind::Original).unwrap());
+            assert!(!tl.matches(conn, &gnu_post, Kind::Original).unwrap());
-            tl.delete(&conn).unwrap();
+            tl.delete(conn).unwrap();
 
             Ok(())
         });

plume-models/src/timeline/query.rs

@@ -1,17 +1,16 @@
 use crate::{
     blogs::Blog,
-    db_conn::DbConn,
     lists::{self, ListType},
     posts::Post,
     tags::Tag,
     timeline::Timeline,
     users::User,
-    Result,
+    Connection, Result,
 };
 use plume_common::activity_pub::inbox::AsActor;
 use whatlang::{self, Lang};
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum QueryError {
     SyntaxError(usize, usize, String),
     UnexpectedEndOfQuery,
@@ -20,7 +19,7 @@ pub enum QueryError {
 
 pub type QueryResult<T> = std::result::Result<T, QueryError>;
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Kind<'a> {
     Original,
     Reshare(&'a User),
@@ -155,7 +154,7 @@ enum TQ<'a> {
 impl<'a> TQ<'a> {
     fn matches(
         &self,
-        conn: &DbConn,
+        conn: &Connection,
         timeline: &Timeline,
         post: &Post,
         kind: Kind<'_>,
@@ -200,7 +199,7 @@ enum Arg<'a> {
 impl<'a> Arg<'a> {
     pub fn matches(
         &self,
-        conn: &DbConn,
+        conn: &Connection,
         timeline: &Timeline,
         post: &Post,
         kind: Kind<'_>,
@@ -225,7 +224,7 @@ enum WithList {
 impl WithList {
     pub fn matches(
         &self,
-        conn: &DbConn,
+        conn: &Connection,
         timeline: &Timeline,
         post: &Post,
         list: &List<'_>,
@@ -292,7 +291,7 @@ impl WithList {
                 WithList::Author { boosts, likes } => match kind {
                     Kind::Original => Ok(list
                         .iter()
-                        .filter_map(|a| User::find_by_fqn(&*conn, a).ok())
+                        .filter_map(|a| User::find_by_fqn(conn, a).ok())
                         .any(|a| post.is_author(conn, a.id).unwrap_or(false))),
                     Kind::Reshare(u) => {
                         if *boosts {
@@ -361,7 +360,7 @@ enum Bool {
 impl Bool {
     pub fn matches(
         &self,
-        conn: &DbConn,
+        conn: &Connection,
         timeline: &Timeline,
         post: &Post,
         kind: Kind<'_>,
@@ -654,7 +653,7 @@ impl<'a> TimelineQuery<'a> {
 
     pub fn matches(
         &self,
-        conn: &DbConn,
+        conn: &Connection,
         timeline: &Timeline,
         post: &Post,
         kind: Kind<'_>,

plume-models/src/users.rs

@@ -1,8 +1,8 @@
 use crate::{
-    ap_url, blocklisted_emails::BlocklistedEmail, blogs::Blog, db_conn::DbConn, follows::Follow,
+    ap_url, blocklisted_emails::BlocklistedEmail, blogs::Blog, comments::Comment, db_conn::DbConn,
-    instance::*, medias::Media, notifications::Notification, post_authors::PostAuthor, posts::Post,
+    follows::Follow, instance::*, medias::Media, notifications::Notification,
-    safe_string::SafeString, schema::users, timeline::Timeline, Connection, Error, Result,
+    post_authors::PostAuthor, posts::Post, safe_string::SafeString, schema::users,
-    UserEvent::*, CONFIG, ITEMS_PER_PAGE, USER_CHAN,
+    timeline::Timeline, Connection, Error, Result, UserEvent::*, CONFIG, ITEMS_PER_PAGE, USER_CHAN,
 };
 use activitystreams::{
     activity::Delete,
@@ -15,7 +15,10 @@ use activitystreams::{
     prelude::*,
 };
 use chrono::{NaiveDateTime, Utc};
-use diesel::{self, BelongingToDsl, ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl};
+use diesel::{
+    self, BelongingToDsl, BoolExpressionMethods, ExpressionMethods, OptionalExtension, QueryDsl,
+    RunQueryDsl, TextExpressionMethods,
+};
 use ldap3::{LdapConn, Scope, SearchEntry};
 use openssl::{
     hash::MessageDigest,
@@ -165,6 +168,14 @@ impl User {
             notif.delete(conn)?
         }
 
+        for comment in Comment::list_by_author(conn, self.id)? {
+            let delete_activity = comment.build_delete(conn)?;
+            crate::inbox::inbox(
+                conn,
+                serde_json::to_value(&delete_activity).map_err(Error::from)?,
+            )?;
+        }
+
         diesel::delete(self)
             .execute(conn)
             .map(|_| ())
@@ -186,15 +197,16 @@ impl User {
     pub fn count_local(conn: &Connection) -> Result<i64> {
         users::table
             .filter(users::instance_id.eq(Instance::get_local()?.id))
+            .filter(users::role.ne(Role::Instance as i32))
             .count()
-            .get_result(&*conn)
+            .get_result(conn)
             .map_err(Error::from)
     }
 
-    pub fn find_by_fqn(conn: &DbConn, fqn: &str) -> Result<User> {
+    pub fn find_by_fqn(conn: &Connection, fqn: &str) -> Result<User> {
         let from_db = users::table
             .filter(users::fqn.eq(fqn))
-            .first(&**conn)
+            .first(conn)
             .optional()?;
         if let Some(from_db) = from_db {
             Ok(from_db)
@@ -203,6 +215,27 @@ impl User {
         }
     }
 
+    pub fn search_local_by_name(
+        conn: &Connection,
+        name: &str,
+        (min, max): (i32, i32),
+    ) -> Result<Vec<User>> {
+        users::table
+            .filter(users::instance_id.eq(Instance::get_local()?.id))
+            .filter(users::role.ne(Role::Instance as i32))
+            // TODO: use `ilike` instead of `like` for PostgreSQL
+            .filter(
+                users::username
+                    .like(format!("%{}%", name))
+                    .or(users::display_name.like(format!("%{}%", name))),
+            )
+            .order(users::username.asc())
+            .offset(min.into())
+            .limit((max - min).into())
+            .load::<User>(conn)
+            .map_err(Error::from)
+    }
+
     /**
      * TODO: Should create user record with normalized(lowercased) email
      */
@@ -219,7 +252,7 @@ impl User {
         .map_err(Error::from)
     }
 
-    fn fetch_from_webfinger(conn: &DbConn, acct: &str) -> Result<User> {
+    fn fetch_from_webfinger(conn: &Connection, acct: &str) -> Result<User> {
         let link = resolve(acct.to_owned(), true)?
             .links
             .into_iter()
@@ -246,20 +279,7 @@ impl User {
     fn fetch(url: &str) -> Result<CustomPerson> {
         let res = get(url, Self::get_sender(), CONFIG.proxy().cloned())?;
         let text = &res.text()?;
-        // without this workaround, publicKey is not correctly deserialized
+        let json = serde_json::from_str::<CustomPerson>(text)?;
-        let ap_sign = serde_json::from_str::<ApSignature>(text)?;
-        let person = serde_json::from_str::<Person>(text)?;
-        let json = CustomPerson::new(
-            ApActor::new(
-                person
-                    .clone()
-                    .id_unchecked()
-                    .ok_or(Error::MissingApProperty)?
-                    .to_owned(),
-                person,
-            ),
-            ap_sign,
-        ); // FIXME: Don't clone()
         Ok(json)
     }
 
@@ -269,23 +289,13 @@ impl User {
 
     pub fn refetch(&self, conn: &Connection) -> Result<()> {
         User::fetch(&self.ap_url.clone()).and_then(|json| {
-            let avatar = Media::save_remote(
+            let avatar = json
-                conn,
+                .icon()
-                json.ap_actor_ref()
+                .and_then(|icon| icon.iter().next())
-                    .icon()
+                .and_then(|i| i.clone().extend::<Image, ImageType>().ok())
-                    .ok_or(Error::MissingApProperty)? // FIXME: Fails when icon is not set
+                .and_then(|image| image)
-                    .iter()
+                .and_then(|image| image.id_unchecked().map(|url| url.to_string()))
-                    .next()
+                .and_then(|url| Media::save_remote(conn, url, self).ok());
-                    .and_then(|i| {
-                        i.clone()
-                            .extend::<Image, ImageType>() // FIXME: Don't clone()
-                            .ok()?
-                            .and_then(|url| Some(url.id_unchecked()?.to_string()))
-                    })
-                    .ok_or(Error::MissingApProperty)?,
-                self,
-            )
-            .ok();
 
             let pub_key = &json.ext_one.public_key.public_key_pem;
             diesel::update(self)
@@ -332,6 +342,42 @@ impl User {
         bcrypt::hash(pass, 10).map_err(Error::from)
     }
 
+    // [[ LDAP non anonymous bind copied from ....
+    fn ldap_preconn(ldap_conn: &mut LdapConn) -> Result<()> {
+        let ldap = CONFIG.ldap.as_ref().unwrap();
+
+        if let Some((user, password)) = ldap.user.as_ref() {
+            let bind = ldap_conn
+                .simple_bind(user, password)
+                .map_err(|_| Error::NotFound)?;
+
+            if bind.success().is_err() {
+                return Err(Error::NotFound);
+            }
+        }
+        Ok(())
+    }
+
+    fn search_dn(ldap_conn: &mut LdapConn, fil: &str) -> Result<String> {
+        let mut cn: String = String::new();
+        let ldap = CONFIG.ldap.as_ref().unwrap();
+            let (rs, _res) = ldap_conn.search(
+                &ldap.base_dn,
+                Scope::Subtree,
+                fil,
+                vec!["cn"]
+            )
+            .map_err(|_| Error::NotFound)?
+            .success()
+            .map_err(|_| Error::NotFound)?;
+            for entry in rs {
+                println!("{:?}", SearchEntry::construct(entry.clone()).dn);
+                cn = SearchEntry::construct(entry).dn;
+            }
+
+        Ok(cn.to_owned())
+    }
+
     fn ldap_register(conn: &Connection, name: &str, password: &str) -> Result<User> {
         if CONFIG.ldap.is_none() {
             return Err(Error::NotFound);
@@ -339,7 +385,12 @@ impl User {
         let ldap = CONFIG.ldap.as_ref().unwrap();
 
         let mut ldap_conn = LdapConn::new(&ldap.addr).map_err(|_| Error::NotFound)?;
-        let ldap_name = format!("{}={},{}", ldap.user_name_attr, name, ldap.base_dn);
+
+        User::ldap_preconn(&mut ldap_conn)?;
+
+        let _filter = format!("(&(objectClass=*)(uid={}))", name).to_owned(); 
+        let ldap_name = User::search_dn(&mut ldap_conn, &_filter).unwrap();
+        //let ldap_name = format!("{}={},{}", ldap.user_name_attr, name, ldap.base_dn);
         let bind = ldap_conn
             .simple_bind(&ldap_name, password)
             .map_err(|_| Error::NotFound)?;
@@ -385,10 +436,18 @@ impl User {
             } else {
                 return false;
             };
+            if User::ldap_preconn(&mut conn).is_err() {
+                return false;
+            }
+            //
+            let _filter = format!("(&(objectClass=*)(uid={}))", &self.username).to_owned(); 
+            let name = User::search_dn(&mut conn, &_filter).unwrap();
+            /*
             let name = format!(
                 "{}={},{}",
                 ldap.user_name_attr, &self.username, ldap.base_dn
             );
+            */
             if let Ok(bind) = conn.simple_bind(&name, password) {
                 bind.success().is_ok()
             } else {
@@ -443,7 +502,7 @@ impl User {
             }
         }
     }
-
+    // ... ldap-non-anon PR https://git.joinplu.me/Plume/Plume/src/branch/ldap-non-anon ]].
     pub fn reset_password(&self, conn: &Connection, pass: &str) -> Result<()> {
         diesel::update(self)
             .set(users::hashed_password.eq(User::hash_pass(pass)?))
@@ -454,6 +513,7 @@ impl User {
     pub fn get_local_page(conn: &Connection, (min, max): (i32, i32)) -> Result<Vec<User>> {
         users::table
             .filter(users::instance_id.eq(Instance::get_local()?.id))
+            .filter(users::role.ne(Role::Instance as i32))
             .order(users::username.asc())
             .offset(min.into())
             .limit((max - min).into())
@@ -931,7 +991,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for User {
             .cookies()
             .get_private(AUTH_COOKIE)
             .and_then(|cookie| cookie.value().parse().ok())
-            .and_then(|id| User::get(&*conn, id).ok())
+            .and_then(|id| User::get(&conn, id).ok())
             .or_forward(())
     }
 }
@@ -944,15 +1004,15 @@ impl IntoId for User {
 
 impl Eq for User {}
 
-impl FromId<DbConn> for User {
+impl FromId<Connection> for User {
     type Error = Error;
     type Object = CustomPerson;
 
-    fn from_db(conn: &DbConn, id: &str) -> Result<Self> {
+    fn from_db(conn: &Connection, id: &str) -> Result<Self> {
         Self::find_by_ap_url(conn, id)
     }
 
-    fn from_activity(conn: &DbConn, acct: CustomPerson) -> Result<Self> {
+    fn from_activity(conn: &Connection, acct: CustomPerson) -> Result<Self> {
         let actor = acct.ap_actor_ref();
         let username = actor
             .preferred_username()
@@ -960,6 +1020,10 @@ impl FromId<DbConn> for User {
             .to_string();
 
         if username.contains(&['<', '>', '&', '@', '\'', '"', ' ', '\t'][..]) {
+            tracing::error!(
+                "preferredUsername includes invalid character(s): {}",
+                &username
+            );
             return Err(Error::InvalidValue);
         }
 
@@ -1049,7 +1113,7 @@ impl FromId<DbConn> for User {
     }
 }
 
-impl AsActor<&DbConn> for User {
+impl AsActor<&Connection> for User {
     fn get_inbox_url(&self) -> String {
         self.inbox_url.clone()
     }
@@ -1065,11 +1129,11 @@ impl AsActor<&DbConn> for User {
     }
 }
 
-impl AsObject<User, Delete, &DbConn> for User {
+impl AsObject<User, Delete, &Connection> for User {
     type Error = Error;
     type Output = ();
 
-    fn activity(self, conn: &DbConn, actor: User, _id: &str) -> Result<()> {
+    fn activity(self, conn: &Connection, actor: User, _id: &str) -> Result<()> {
         if self.id == actor.id {
             self.delete(conn).map(|_| ())
         } else {
@@ -1232,7 +1296,7 @@ pub(crate) mod tests {
         )
         .unwrap();
         other.avatar_id = Some(avatar.id);
-        let other = other.save_changes::<User>(&*conn).unwrap();
+        let other = other.save_changes::<User>(conn).unwrap();
 
         vec![admin, user, other]
     }
@@ -1335,11 +1399,11 @@ pub(crate) mod tests {
     fn delete() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let inserted = fill_database(&conn);
+            let inserted = fill_database(conn);
 
-            assert!(User::get(&conn, inserted[0].id).is_ok());
+            assert!(User::get(conn, inserted[0].id).is_ok());
-            inserted[0].delete(&conn).unwrap();
+            inserted[0].delete(conn).unwrap();
-            assert!(User::get(&conn, inserted[0].id).is_err());
+            assert!(User::get(conn, inserted[0].id).is_err());
             Ok(())
         });
     }
@@ -1348,20 +1412,20 @@ pub(crate) mod tests {
     fn admin() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            let inserted = fill_database(&conn);
+            let inserted = fill_database(conn);
             let local_inst = Instance::get_local().unwrap();
             let mut i = 0;
-            while local_inst.has_admin(&conn).unwrap() {
+            while local_inst.has_admin(conn).unwrap() {
                 assert!(i < 100); //prevent from looping indefinitelly
                 local_inst
-                    .main_admin(&conn)
+                    .main_admin(conn)
                     .unwrap()
-                    .set_role(&conn, Role::Normal)
+                    .set_role(conn, Role::Normal)
                     .unwrap();
                 i += 1;
             }
-            inserted[0].set_role(&conn, Role::Admin).unwrap();
+            inserted[0].set_role(conn, Role::Admin).unwrap();
-            assert_eq!(inserted[0].id, local_inst.main_admin(&conn).unwrap().id);
+            assert_eq!(inserted[0].id, local_inst.main_admin(conn).unwrap().id);
             Ok(())
         });
     }
@@ -1370,9 +1434,9 @@ pub(crate) mod tests {
     fn auth() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            fill_database(&conn);
+            fill_database(conn);
             let test_user = NewUser::new_local(
-                &conn,
+                conn,
                 "test".to_owned(),
                 "test user".to_owned(),
                 Role::Normal,
@@ -1383,10 +1447,10 @@ pub(crate) mod tests {
             .unwrap();
 
             assert_eq!(
-                User::login(&conn, "test", "test_password").unwrap().id,
+                User::login(conn, "test", "test_password").unwrap().id,
                 test_user.id
             );
-            assert!(User::login(&conn, "test", "other_password").is_err());
+            assert!(User::login(conn, "test", "other_password").is_err());
             Ok(())
         });
     }
@@ -1395,26 +1459,26 @@ pub(crate) mod tests {
     fn get_local_page() {
         let conn = &db();
         conn.test_transaction::<_, (), _>(|| {
-            fill_database(&conn);
+            fill_database(conn);
 
-            let page = User::get_local_page(&conn, (0, 2)).unwrap();
+            let page = User::get_local_page(conn, (0, 2)).unwrap();
             assert_eq!(page.len(), 2);
             assert!(page[0].username <= page[1].username);
 
-            let mut last_username = User::get_local_page(&conn, (0, 1)).unwrap()[0]
+            let mut last_username = User::get_local_page(conn, (0, 1)).unwrap()[0]
                 .username
                 .clone();
-            for i in 1..User::count_local(&conn).unwrap() as i32 {
+            for i in 1..User::count_local(conn).unwrap() as i32 {
-                let page = User::get_local_page(&conn, (i, i + 1)).unwrap();
+                let page = User::get_local_page(conn, (i, i + 1)).unwrap();
                 assert_eq!(page.len(), 1);
                 assert!(last_username <= page[0].username);
                 last_username = page[0].username.clone();
             }
             assert_eq!(
-                User::get_local_page(&conn, (0, User::count_local(&conn).unwrap() as i32 + 10))
+                User::get_local_page(conn, (0, User::count_local(conn).unwrap() as i32 + 10))
                     .unwrap()
                     .len() as i64,
-                User::count_local(&conn).unwrap()
+                User::count_local(conn).unwrap()
             );
             Ok(())
         });

po/plume-front/plume-front.pot

@@ -1,7 +1,7 @@
-msgid ""
+
+msgid "Do you want to load the local autosave last edited at {}?"
 msgstr ""
-"Project-Id-Version: plume-front\n"
+ \n"
-"Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2018-06-15 16:33-0700\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
@@ -12,9 +12,6 @@ msgstr ""
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
 
-msgid "Do you want to load the local autosave last edited at {}?"
-msgstr ""
-
 msgid "Open the rich text editor"
 msgstr ""