Merge remote-tracking branch 'origin/develop' into shigusegubu

* origin/develop: (302 commits) MRF: ensure that subdomain_match calls are case-insensitive Strip internal fields including likes from incoming and outgoing activities tests for Pleroma.Uploaders Mastodon API: Fix thread mute detection Uploader.S3 added support stream uploads Mastodon API: Set follower/following counters to 0 when hiding followers/following is enabled Return profile URL in MastodonAPI's `url` field Simplify logic to mention.js `url` field Return profile URL when available instead of actor URI for MastodonAPI mention URL Do not rembed the object after updating it OStatus tests: stop relying on embedded objects ActivityPub tests: remove assertions of embedded object being updated, because the objects are no longer supposed to be embedded OStatus Announce Representer: Do not depend on the object being embedded in the Create activity Stop depending on the embedded object in restrict_favorited_by [#1150] fixed parser TwitterCard tests for CommonApi/Utils Remove Reply-To from report emails Do not add the "next" key to likes.json if there is no more items Replace "impode" with "implode" for Remove longfox emoji set ...
2019-08-11 16:58:09 +03:00 · 2019-08-11 16:58:09 +03:00 · c8b2534245
commit c8b2534245
parent ae4d15503b 779e32a879
434 changed files with 14970 additions and 3316 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -0,0 +1,12 @@
 .*
 *.md
 AGPL-3
 CC-BY-SA-4.0
 COPYING
 *file
 elixir_buildpack.config
 docs/
 test/
 # Required to get version
 !.git
--- a/.mailmap
+++ b/.mailmap
@ -0,0 +1,2 @@
 Ariadne Conill <ariadne@dereferenced.org> <nenolod@dereferenced.org>
 Ariadne Conill <ariadne@dereferenced.org> <nenolod@gmail.com>
--- a/CC-BY-NC-ND-4.0
+++ b/CC-BY-NC-ND-4.0
@ -1,403 +0,0 @@
 Attribution-NonCommercial-NoDerivatives 4.0 International
 =======================================================================
 Creative Commons Corporation ("Creative Commons") is not a law firm and
 does not provide legal services or legal advice. Distribution of
 Creative Commons public licenses does not create a lawyer-client or
 other relationship. Creative Commons makes its licenses and related
 information available on an "as-is" basis. Creative Commons gives no
 warranties regarding its licenses, any material licensed under their
 terms and conditions, or any related information. Creative Commons
 disclaims all liability for damages resulting from their use to the
 fullest extent possible.
 Using Creative Commons Public Licenses
 Creative Commons public licenses provide a standard set of terms and
 conditions that creators and other rights holders may use to share
 original works of authorship and other material subject to copyright
 and certain other rights specified in the public license below. The
 following considerations are for informational purposes only, are not
 exhaustive, and do not form part of our licenses.
     Considerations for licensors: Our public licenses are
     intended for use by those authorized to give the public
     permission to use material in ways otherwise restricted by
     copyright and certain other rights. Our licenses are
     irrevocable. Licensors should read and understand the terms
     and conditions of the license they choose before applying it.
     Licensors should also secure all rights necessary before
     applying our licenses so that the public can reuse the
     material as expected. Licensors should clearly mark any
     material not subject to the license. This includes other CC-
     licensed material, or material used under an exception or
     limitation to copyright. More considerations for licensors:
 	wiki.creativecommons.org/Considerations_for_licensors
     Considerations for the public: By using one of our public
     licenses, a licensor grants the public permission to use the
     licensed material under specified terms and conditions. If
     the licensor's permission is not necessary for any reason--for
     example, because of any applicable exception or limitation to
     copyright--then that use is not regulated by the license. Our
     licenses grant only permissions under copyright and certain
     other rights that a licensor has authority to grant. Use of
     the licensed material may still be restricted for other
     reasons, including because others have copyright or other
     rights in the material. A licensor may make special requests,
     such as asking that all changes be marked or described.
     Although not required by our licenses, you are encouraged to
     respect those requests where reasonable. More considerations
     for the public: 
 	wiki.creativecommons.org/Considerations_for_licensees
 =======================================================================
 Creative Commons Attribution-NonCommercial-NoDerivatives 4.0
 International Public License
 By exercising the Licensed Rights (defined below), You accept and agree
 to be bound by the terms and conditions of this Creative Commons
 Attribution-NonCommercial-NoDerivatives 4.0 International Public
 License ("Public License"). To the extent this Public License may be
 interpreted as a contract, You are granted the Licensed Rights in
 consideration of Your acceptance of these terms and conditions, and the
 Licensor grants You such rights in consideration of benefits the
 Licensor receives from making the Licensed Material available under
 these terms and conditions.
 Section 1 -- Definitions.
  a. Adapted Material means material subject to Copyright and Similar
     Rights that is derived from or based upon the Licensed Material
     and in which the Licensed Material is translated, altered,
     arranged, transformed, or otherwise modified in a manner requiring
     permission under the Copyright and Similar Rights held by the
     Licensor. For purposes of this Public License, where the Licensed
     Material is a musical work, performance, or sound recording,
     Adapted Material is always produced where the Licensed Material is
     synched in timed relation with a moving image.
  b. Copyright and Similar Rights means copyright and/or similar rights
     closely related to copyright including, without limitation,
     performance, broadcast, sound recording, and Sui Generis Database
     Rights, without regard to how the rights are labeled or
     categorized. For purposes of this Public License, the rights
     specified in Section 2(b)(1)-(2) are not Copyright and Similar
     Rights.
  c. Effective Technological Measures means those measures that, in the
     absence of proper authority, may not be circumvented under laws
     fulfilling obligations under Article 11 of the WIPO Copyright
     Treaty adopted on December 20, 1996, and/or similar international
     agreements.
  d. Exceptions and Limitations means fair use, fair dealing, and/or
     any other exception or limitation to Copyright and Similar Rights
     that applies to Your use of the Licensed Material.
  e. Licensed Material means the artistic or literary work, database,
     or other material to which the Licensor applied this Public
     License.
  f. Licensed Rights means the rights granted to You subject to the
     terms and conditions of this Public License, which are limited to
     all Copyright and Similar Rights that apply to Your use of the
     Licensed Material and that the Licensor has authority to license.
  g. Licensor means the individual(s) or entity(ies) granting rights
     under this Public License.
  h. NonCommercial means not primarily intended for or directed towards
     commercial advantage or monetary compensation. For purposes of
     this Public License, the exchange of the Licensed Material for
     other material subject to Copyright and Similar Rights by digital
     file-sharing or similar means is NonCommercial provided there is
     no payment of monetary compensation in connection with the
     exchange.
  i. Share means to provide material to the public by any means or
     process that requires permission under the Licensed Rights, such
     as reproduction, public display, public performance, distribution,
     dissemination, communication, or importation, and to make material
     available to the public including in ways that members of the
     public may access the material from a place and at a time
     individually chosen by them.
  j. Sui Generis Database Rights means rights other than copyright
     resulting from Directive 96/9/EC of the European Parliament and of
     the Council of 11 March 1996 on the legal protection of databases,
     as amended and/or succeeded, as well as other essentially
     equivalent rights anywhere in the world.
  k. You means the individual or entity exercising the Licensed Rights
     under this Public License. Your has a corresponding meaning.
 Section 2 -- Scope.
  a. License grant.
       1. Subject to the terms and conditions of this Public License,
          the Licensor hereby grants You a worldwide, royalty-free,
          non-sublicensable, non-exclusive, irrevocable license to
          exercise the Licensed Rights in the Licensed Material to:
            a. reproduce and Share the Licensed Material, in whole or
               in part, for NonCommercial purposes only; and
            b. produce and reproduce, but not Share, Adapted Material
               for NonCommercial purposes only.
       2. Exceptions and Limitations. For the avoidance of doubt, where
          Exceptions and Limitations apply to Your use, this Public
          License does not apply, and You do not need to comply with
          its terms and conditions.
       3. Term. The term of this Public License is specified in Section
          6(a).
       4. Media and formats; technical modifications allowed. The
          Licensor authorizes You to exercise the Licensed Rights in
          all media and formats whether now known or hereafter created,
          and to make technical modifications necessary to do so. The
          Licensor waives and/or agrees not to assert any right or
          authority to forbid You from making technical modifications
          necessary to exercise the Licensed Rights, including
          technical modifications necessary to circumvent Effective
          Technological Measures. For purposes of this Public License,
          simply making modifications authorized by this Section 2(a)
          (4) never produces Adapted Material.
       5. Downstream recipients.
            a. Offer from the Licensor -- Licensed Material. Every
               recipient of the Licensed Material automatically
               receives an offer from the Licensor to exercise the
               Licensed Rights under the terms and conditions of this
               Public License.
            b. No downstream restrictions. You may not offer or impose
               any additional or different terms or conditions on, or
               apply any Effective Technological Measures to, the
               Licensed Material if doing so restricts exercise of the
               Licensed Rights by any recipient of the Licensed
               Material.
       6. No endorsement. Nothing in this Public License constitutes or
          may be construed as permission to assert or imply that You
          are, or that Your use of the Licensed Material is, connected
          with, or sponsored, endorsed, or granted official status by,
          the Licensor or others designated to receive attribution as
          provided in Section 3(a)(1)(A)(i).
  b. Other rights.
       1. Moral rights, such as the right of integrity, are not
          licensed under this Public License, nor are publicity,
          privacy, and/or other similar personality rights; however, to
          the extent possible, the Licensor waives and/or agrees not to
          assert any such rights held by the Licensor to the limited
          extent necessary to allow You to exercise the Licensed
          Rights, but not otherwise.
       2. Patent and trademark rights are not licensed under this
          Public License.
       3. To the extent possible, the Licensor waives any right to
          collect royalties from You for the exercise of the Licensed
          Rights, whether directly or through a collecting society
          under any voluntary or waivable statutory or compulsory
          licensing scheme. In all other cases the Licensor expressly
          reserves any right to collect such royalties, including when
          the Licensed Material is used other than for NonCommercial
          purposes.
 Section 3 -- License Conditions.
 Your exercise of the Licensed Rights is expressly made subject to the
 following conditions.
  a. Attribution.
       1. If You Share the Licensed Material, You must:
            a. retain the following if it is supplied by the Licensor
               with the Licensed Material:
                 i. identification of the creator(s) of the Licensed
                    Material and any others designated to receive
                    attribution, in any reasonable manner requested by
                    the Licensor (including by pseudonym if
                    designated);
                ii. a copyright notice;
               iii. a notice that refers to this Public License;
                iv. a notice that refers to the disclaimer of
                    warranties;
                 v. a URI or hyperlink to the Licensed Material to the
                    extent reasonably practicable;
            b. indicate if You modified the Licensed Material and
               retain an indication of any previous modifications; and
            c. indicate the Licensed Material is licensed under this
               Public License, and include the text of, or the URI or
               hyperlink to, this Public License.
          For the avoidance of doubt, You do not have permission under
          this Public License to Share Adapted Material.
       2. You may satisfy the conditions in Section 3(a)(1) in any
          reasonable manner based on the medium, means, and context in
          which You Share the Licensed Material. For example, it may be
          reasonable to satisfy the conditions by providing a URI or
          hyperlink to a resource that includes the required
          information.
       3. If requested by the Licensor, You must remove any of the
          information required by Section 3(a)(1)(A) to the extent
          reasonably practicable.
 Section 4 -- Sui Generis Database Rights.
 Where the Licensed Rights include Sui Generis Database Rights that
 apply to Your use of the Licensed Material:
  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
     to extract, reuse, reproduce, and Share all or a substantial
     portion of the contents of the database for NonCommercial purposes
     only and provided You do not Share Adapted Material;
  b. if You include all or a substantial portion of the database
     contents in a database in which You have Sui Generis Database
     Rights, then the database in which You have Sui Generis Database
     Rights (but not its individual contents) is Adapted Material; and
  c. You must comply with the conditions in Section 3(a) if You Share
     all or a substantial portion of the contents of the database.
 For the avoidance of doubt, this Section 4 supplements and does not
 replace Your obligations under this Public License where the Licensed
 Rights include other Copyright and Similar Rights.
 Section 5 -- Disclaimer of Warranties and Limitation of Liability.
  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
  c. The disclaimer of warranties and limitation of liability provided
     above shall be interpreted in a manner that, to the extent
     possible, most closely approximates an absolute disclaimer and
     waiver of all liability.
 Section 6 -- Term and Termination.
  a. This Public License applies for the term of the Copyright and
     Similar Rights licensed here. However, if You fail to comply with
     this Public License, then Your rights under this Public License
     terminate automatically.
  b. Where Your right to use the Licensed Material has terminated under
     Section 6(a), it reinstates:
       1. automatically as of the date the violation is cured, provided
          it is cured within 30 days of Your discovery of the
          violation; or
       2. upon express reinstatement by the Licensor.
     For the avoidance of doubt, this Section 6(b) does not affect any
     right the Licensor may have to seek remedies for Your violations
     of this Public License.
  c. For the avoidance of doubt, the Licensor may also offer the
     Licensed Material under separate terms or conditions or stop
     distributing the Licensed Material at any time; however, doing so
     will not terminate this Public License.
  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
     License.
 Section 7 -- Other Terms and Conditions.
  a. The Licensor shall not be bound by any additional or different
     terms or conditions communicated by You unless expressly agreed.
  b. Any arrangements, understandings, or agreements regarding the
     Licensed Material not stated herein are separate from and
     independent of the terms and conditions of this Public License.
 Section 8 -- Interpretation.
  a. For the avoidance of doubt, this Public License does not, and
     shall not be interpreted to, reduce, limit, restrict, or impose
     conditions on any use of the Licensed Material that could lawfully
     be made without permission under this Public License.
  b. To the extent possible, if any provision of this Public License is
     deemed unenforceable, it shall be automatically reformed to the
     minimum extent necessary to make it enforceable. If the provision
     cannot be reformed, it shall be severed from this Public License
     without affecting the enforceability of the remaining terms and
     conditions.
  c. No term or condition of this Public License will be waived and no
     failure to comply consented to unless expressly agreed to by the
     Licensor.
  d. Nothing in this Public License constitutes or may be interpreted
     as a limitation upon, or waiver of, any privileges and immunities
     that apply to the Licensor or You, including from the legal
     processes of any jurisdiction or authority.
 =======================================================================
 Creative Commons is not a party to its public
 licenses. Notwithstanding, Creative Commons may elect to apply one of
 its public licenses to material it publishes and in those instances
 will be considered the “Licensor.” The text of the Creative Commons
 public licenses is dedicated to the public domain under the CC0 Public
 Domain Dedication. Except for the limited purpose of indicating that
 material is shared under a Creative Commons public license or as
 otherwise permitted by the Creative Commons policies published at
 creativecommons.org/policies, Creative Commons does not authorize the
 use of the trademark "Creative Commons" or any other trademark or logo
 of Creative Commons without its prior written consent including,
 without limitation, in connection with any unauthorized modifications
 to any of its public licenses or any other arrangements,
 understandings, or agreements concerning use of licensed material. For
 the avoidance of doubt, this paragraph does not form part of the
 public licenses.
 Creative Commons may be contacted at creativecommons.org.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -4,21 +4,93 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ## [Unreleased]
-### Added
+### Security
- MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
+- OStatus: eliminate the possibility of a protocol downgrade attack.
- Mastodon API: Support for the [`tagged` filter](https://github.com/tootsuite/mastodon/pull/9755) in [`GET /api/v1/accounts/:id/statuses`](https://docs.joinmastodon.org/api/rest/accounts/#get-api-v1-accounts-id-statuses)
+- OStatus: prevent following locked accounts, bypassing the approval process.
- Admin API: Return users' tags when querying reports
+
- Admin API: Return avatar and display name when querying users
+### Changed
 - **Breaking:** Configuration: A setting to explicitly disable the mailer was added, defaulting to true, if you are using a mailer add `config :pleroma, Pleroma.Emails.Mailer, enabled: true` to your config
 - **Breaking:** Configuration: `/media/` is now removed when `base_url` is configured, append `/media/` to your `base_url` config to keep the old behaviour if desired
 - Configuration: OpenGraph and TwitterCard providers enabled by default
 - Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
 - Federation: Return 403 errors when trying to request pages from a user's follower/following collections if they have `hide_followers`/`hide_follows` set
 - NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option
 - NodeInfo: Return `mailerEnabled` in `metadata`
 - Mastodon API: Unsubscribe followers when they unfollow a user
 - AdminAPI: Add "godmode" while fetching user statuses (i.e. admin can see private statuses)
 ### Fixed
 - Not being able to pin unlisted posts
 - Objects being re-embedded to activities after being updated (e.g faved/reposted). Running 'mix pleroma.database prune_objects' again is advised.
 - Metadata rendering errors resulting in the entire page being inaccessible
 - Federation/MediaProxy not working with instances that have wrong certificate order
 - Mastodon API: Handling of search timeouts (`/api/v1/search` and `/api/v2/search`)
 - Mastodon API: Embedded relationships not being properly rendered in the Account entity of Status entity
 - Mastodon API: follower/following counters not being nullified, when `hide_follows`/`hide_followers` is set
 - Mastodon API: `muted` in the Status entity, using author's account to determine if the tread was muted
 - Mastodon API: Add `account_id`, `type`, `offset`, and `limit` to search API (`/api/v1/search` and `/api/v2/search`)
 - Mastodon API, streaming: Fix filtering of notifications based on blocks/mutes/thread mutes
 - ActivityPub C2S: follower/following collection pages being inaccessible even when authentifucated if `hide_followers`/ `hide_follows` was set
 - Existing user id not being preserved on insert conflict
 - Rich Media: Parser failing when no TTL can be found by image TTL setters
 - Rich Media: The crawled URL is now spliced into the rich media data.
 - ActivityPub S2S: sharedInbox usage has been mostly aligned with the rules in the AP specification.
 - ActivityPub S2S: remote user deletions now work the same as local user deletions.
 - Not being able to access the Mastodon FE login page on private instances
 - Invalid SemVer version generation, when the current branch does not have commits ahead of tag/checked out on a tag
 - Pleroma.Upload base_url was not automatically whitelisted by MediaProxy. Now your custom CDN or file hosting will be accessed directly as expected.
 - Report email not being sent to admins when the reporter is a remote user
 - MRF: ensure that subdomain_match calls are case-insensitive
 ### Added
 - MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
 - MRF: Support for excluding specific domains from Transparency.
 - MRF: Support for filtering posts based on who they mention (`Pleroma.Web.ActivityPub.MRF.MentionPolicy`)
 - MRF (Simple Policy): Support for wildcard domains.
 - Support for wildcard domains in user domain blocks setting.
 - Configuration: `quarantined_instances` support wildcard domains.
 - Configuration: `federation_incoming_replies_max_depth` option
 - Mastodon API: Support for the [`tagged` filter](https://github.com/tootsuite/mastodon/pull/9755) in [`GET /api/v1/accounts/:id/statuses`](https://docs.joinmastodon.org/api/rest/accounts/#get-api-v1-accounts-id-statuses)
 - Mastodon API, streaming: Add support for passing the token in the `Sec-WebSocket-Protocol` header
 - Mastodon API, extension: Ability to reset avatar, profile banner, and background
 - Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>
 - Mastodon API: Add support for muting/unmuting notifications
 - Mastodon API: Add support for the `blocked_by` attribute in the relationship API (`GET /api/v1/accounts/relationships`). <https://github.com/tootsuite/mastodon/pull/10373>
 - Mastodon API: Add support for the `domain_blocking` attribute in the relationship API (`GET /api/v1/accounts/relationships`).
 - Mastodon API: Add `pleroma.deactivated` to the Account entity
 - Mastodon API: added `/auth/password` endpoint for password reset with rate limit.
 - Mastodon API: /api/v1/accounts/:id/statuses now supports nicknames or user id
 - Admin API: Return users' tags when querying reports
 - Admin API: Return avatar and display name when querying users
 - Admin API: Allow querying user by ID
 - Admin API: Added support for `tuples`.
 - Admin API: Added endpoints to run mix tasks pleroma.config migrate_to_db & pleroma.config migrate_from_db
 - Added synchronization of following/followers counters for external users
 - Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
 - Configuration: Pleroma.Plugs.RateLimiter `bucket_name`, `params` options.
 - Addressable lists
 - Twitter API: added rate limit for `/api/account/password_reset` endpoint.
 - ActivityPub: Add an internal service actor for fetching ActivityPub objects.
 - ActivityPub: Optional signing of ActivityPub object fetches.
 - Admin API: Endpoint for fetching latest user's statuses
 - Pleroma API: Add `/api/v1/pleroma/accounts/confirmation_resend?email=<email>` for resending account confirmation.
 - Relays: Added a task to list relay subscriptions.
 - Mix Tasks: `mix pleroma.database fix_likes_collections`
 - Federation: Remove `likes` from objects.
 ### Changed
 - Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
 - Admin API: changed json structure for saving config settings.
 - RichMedia: parsers and their order are configured in `rich_media` config.
 - RichMedia: add the rich media ttl based on image expiration time.
-### Changed
+### Removed
- NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option
+- Emoji: Remove longfox emojis.
 - Remove `Reply-To` header from report emails for admins.
 ## [1.0.1] - 2019-07-14
 ### Security
 - OStatus: fix an object spoofing vulnerability.
 ## [1.0.0] - 2019-06-29
 ### Security
@ -26,6 +98,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Rich media: Do not crawl private IP ranges
 ### Added
 - Digest email for inactive users
 - Add a generic settings store for frontends / clients to use.
 - Explicit addressing option for posting.
 - Optional SSH access mode. (Needs `erlang-ssh` package on some distributions).
@ -52,6 +125,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Configuration: `notify_email` option
 - Configuration: Media proxy `whitelist` option
 - Configuration: `report_uri` option
 - Configuration: `email_notifications` option
 - Configuration: `limit_to_local_content` option
 - Pleroma API: User subscriptions
 - Pleroma API: Healthcheck endpoint
--- a/39
+++ b/39
@ -0,0 +1,39 @@
 FROM rinpatch/elixir:1.9.0-rc.0-alpine as build
 COPY . .
 ENV MIX_ENV=prod
 RUN apk add git gcc g++ musl-dev make &&\
 	echo "import Mix.Config" > config/prod.secret.exs &&\
 	mix local.hex --force &&\
 	mix local.rebar --force &&\
 	mix deps.get --only prod &&\
 	mkdir release &&\
 	mix release --path release
 FROM alpine:latest
 ARG HOME=/opt/pleroma
 ARG DATA=/var/lib/pleroma
 RUN echo "http://nl.alpinelinux.org/alpine/latest-stable/community" >> /etc/apk/repositories &&\
 	apk update &&\
 	apk add ncurses postgresql-client &&\
 	adduser --system --shell /bin/false --home ${HOME} pleroma &&\
 	mkdir -p ${DATA}/uploads &&\
 	mkdir -p ${DATA}/static &&\
 	chown -R pleroma ${DATA} &&\
 	mkdir -p /etc/pleroma &&\
 	chown -R pleroma /etc/pleroma
 USER pleroma
 COPY --from=build --chown=pleroma:0 /release ${HOME}
 COPY ./config/docker.exs /etc/pleroma/config.exs
 COPY ./docker-entrypoint.sh ${HOME}
 EXPOSE 4000
 ENTRYPOINT ["/opt/pleroma/docker-entrypoint.sh"]
--- a/README.md
+++ b/README.md
@ -21,7 +21,7 @@ If you want to run your own server, feel free to contact us at @lain@pleroma.soy
 Currently Pleroma is not packaged by any OS/Distros, but feel free to reach out to us at [#pleroma-dev on freenode](https://webchat.freenode.net/?channels=%23pleroma-dev) or via matrix at <https://matrix.heldscal.la/#/room/#freenode_#pleroma-dev:matrix.org> for assistance. If you want to change default options in your Pleroma package, please **discuss it with us first**.
 ### Docker
-While we don’t provide docker files, other people have written very good ones. Take a look at <https://github.com/angristan/docker-pleroma> or <https://github.com/sn0w/pleroma-docker>.
+While we don’t provide docker files, other people have written very good ones. Take a look at <https://github.com/angristan/docker-pleroma> or <https://glitch.sh/sn0w/pleroma-docker>.
 ### Dependencies
--- a/config/config.exs
+++ b/config/config.exs
@ -194,6 +194,8 @@ config :pleroma, :http,
  send_user_agent: true,
  adapter: [
    ssl_options: [
      # Workaround for remote server certificate chain issues
      partial_chain: &:hackney_connect.partial_chain/1,
      # We don't support TLS v1.3 yet
      versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]
    ]
@ -218,6 +220,7 @@ config :pleroma, :instance,
  },
  registrations_open: true,
  federating: true,
  federation_incoming_replies_max_depth: 100,
  federation_reachability_timeout_days: 7,
  federation_publisher_modules: [
    Pleroma.Web.ActivityPub.Publisher,
@ -239,6 +242,7 @@ config :pleroma, :instance,
    "text/bbcode"
  ],
  mrf_transparency: true,
  mrf_transparency_exclusions: [],
  autofollowed_nicknames: [],
  max_pinned_statuses: 1,
  no_attachment_links: false,
@ -250,7 +254,8 @@ config :pleroma, :instance,
  remote_post_retention_days: 90,
  skip_thread_containment: true,
  limit_to_local_content: :unauthenticated,
-  dynamic_configuration: false
+  dynamic_configuration: false,
  external_user_synchronization: true
 config :pleroma, :markup,
  # XXX - unfortunately, inline images must be enabled by default right now, because
@ -304,7 +309,8 @@ config :pleroma, :activitypub,
  accept_blocks: true,
  unfollow_blocked: true,
  outgoing_blocks: true,
-  follow_handshake_timeout: 500
+  follow_handshake_timeout: 500,
  sign_object_fetches: true
 config :pleroma, :user, deny_follow_blocked: true
@ -347,7 +353,13 @@ config :pleroma, :mrf_subchain, match_actor: %{}
 config :pleroma, :rich_media,
  enabled: true,
  ignore_hosts: [],
-  ignore_tld: ["local", "localdomain", "lan"]
+  ignore_tld: ["local", "localdomain", "lan"],
  parsers: [
    Pleroma.Web.RichMedia.Parsers.TwitterCard,
    Pleroma.Web.RichMedia.Parsers.OGP,
    Pleroma.Web.RichMedia.Parsers.OEmbed
  ],
  ttl_setters: [Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl]
 config :pleroma, :media_proxy,
  enabled: false,
@ -371,7 +383,11 @@ config :pleroma, :gopher,
  port: 9999
 config :pleroma, Pleroma.Web.Metadata,
-  providers: [Pleroma.Web.Metadata.Providers.RelMe],
+  providers: [
    Pleroma.Web.Metadata.Providers.OpenGraph,
    Pleroma.Web.Metadata.Providers.TwitterCard,
    Pleroma.Web.Metadata.Providers.RelMe
  ],
  unfurl_nsfw: false
 config :pleroma, :suggestions,
@ -502,7 +518,7 @@ config :ueberauth,
 config :pleroma, :auth, oauth_consumer_strategies: oauth_consumer_strategies
-config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Sendmail
+config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Sendmail, enabled: false
 config :prometheus, Pleroma.Web.Endpoint.MetricsExporter, path: "/api/pleroma/app_metrics"
@ -511,6 +527,14 @@ config :pleroma, Pleroma.ScheduledActivity,
  total_user_limit: 300,
  enabled: true
 config :pleroma, :email_notifications,
  digest: %{
    active: false,
    schedule: "0 0 * * 0",
    interval: 7,
    inactivity_threshold: 7
  }
 config :pleroma, :oauth2,
  token_expires_in: 600,
  issue_new_refresh_token: true,
@ -526,7 +550,13 @@ config :http_signatures,
 config :pleroma, :rate_limit,
  search: [{1000, 10}, {1000, 30}],
-  app_account_creation: {1_800_000, 25}
+  app_account_creation: {1_800_000, 25},
  relations_actions: {10_000, 10},
  relation_id_action: {60_000, 2},
  statuses_actions: {10_000, 15},
  status_id_action: {60_000, 3},
  password_reset: {1_800_000, 5},
  account_confirmation_resend: {8_640_000, 5}
 # Import environment specific config. This must remain at the bottom
 # of this file so it overrides the configuration defined above.
--- a/config/docker.exs
+++ b/config/docker.exs
@ -0,0 +1,68 @@
 import Config
 config :pleroma, Pleroma.Web.Endpoint,
  url: [host: System.get_env("DOMAIN", "localhost"), scheme: "https", port: 443],
  http: [ip: {0, 0, 0, 0}, port: 4000]
 config :pleroma, :instance,
  name: System.get_env("INSTANCE_NAME", "Pleroma"),
  email: System.get_env("ADMIN_EMAIL"),
  notify_email: System.get_env("NOTIFY_EMAIL"),
  limit: 5000,
  registrations_open: false,
  dynamic_configuration: true
 config :pleroma, Pleroma.Repo,
  adapter: Ecto.Adapters.Postgres,
  username: System.get_env("DB_USER", "pleroma"),
  password: System.fetch_env!("DB_PASS"),
  database: System.get_env("DB_NAME", "pleroma"),
  hostname: System.get_env("DB_HOST", "db"),
  pool_size: 10
 # Configure web push notifications
 config :web_push_encryption, :vapid_details, subject: "mailto:#{System.get_env("NOTIFY_EMAIL")}"
 config :pleroma, :database, rum_enabled: false
 config :pleroma, :instance, static_dir: "/var/lib/pleroma/static"
 config :pleroma, Pleroma.Uploaders.Local, uploads: "/var/lib/pleroma/uploads"
 # We can't store the secrets in this file, since this is baked into the docker image
 if not File.exists?("/var/lib/pleroma/secret.exs") do
  secret = :crypto.strong_rand_bytes(64) |> Base.encode64() |> binary_part(0, 64)
  signing_salt = :crypto.strong_rand_bytes(8) |> Base.encode64() |> binary_part(0, 8)
  {web_push_public_key, web_push_private_key} = :crypto.generate_key(:ecdh, :prime256v1)
  secret_file =
    EEx.eval_string(
      """
      import Config
      config :pleroma, Pleroma.Web.Endpoint,
        secret_key_base: "<%= secret %>",
        signing_salt: "<%= signing_salt %>"
      config :web_push_encryption, :vapid_details,
        public_key: "<%= web_push_public_key %>",
        private_key: "<%= web_push_private_key %>"
      """,
      secret: secret,
      signing_salt: signing_salt,
      web_push_public_key: Base.url_encode64(web_push_public_key, padding: false),
      web_push_private_key: Base.url_encode64(web_push_private_key, padding: false)
    )
  File.write("/var/lib/pleroma/secret.exs", secret_file)
 end
 import_config("/var/lib/pleroma/secret.exs")
 # For additional user config
 if File.exists?("/var/lib/pleroma/config.exs"),
  do: import_config("/var/lib/pleroma/config.exs"),
  else:
    File.write("/var/lib/pleroma/config.exs", """
    import Config
    # For additional configuration outside of environmental variables
    """)
--- a/config/emoji.txt
+++ b/config/emoji.txt
@ -1,30 +1,2 @@
 firefox, /emoji/Firefox.gif, Gif,Fun
 blank, /emoji/blank.png, Fun
 f_00b, /emoji/f_00b.png
 f_00b11b, /emoji/f_00b11b.png
 f_00b33b, /emoji/f_00b33b.png
 f_00h, /emoji/f_00h.png
 f_00t, /emoji/f_00t.png
 f_01b, /emoji/f_01b.png
 f_03b, /emoji/f_03b.png
 f_10b, /emoji/f_10b.png
 f_11b, /emoji/f_11b.png
 f_11b00b, /emoji/f_11b00b.png
 f_11b22b, /emoji/f_11b22b.png
 f_11h, /emoji/f_11h.png
 f_11t, /emoji/f_11t.png
 f_12b, /emoji/f_12b.png
 f_21b, /emoji/f_21b.png
 f_22b, /emoji/f_22b.png
 f_22b11b, /emoji/f_22b11b.png
 f_22b33b, /emoji/f_22b33b.png
 f_22h, /emoji/f_22h.png
 f_22t, /emoji/f_22t.png
 f_23b, /emoji/f_23b.png
 f_30b, /emoji/f_30b.png
 f_32b, /emoji/f_32b.png
 f_33b, /emoji/f_33b.png
 f_33b00b, /emoji/f_33b00b.png
 f_33b22b, /emoji/f_33b22b.png
 f_33h, /emoji/f_33h.png
 f_33t, /emoji/f_33t.png
--- a/config/test.exs
+++ b/config/test.exs
@ -23,12 +23,16 @@ config :pleroma, Pleroma.Upload, filters: [], link_name: false
 config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"
-config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test
+config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true
 config :pleroma, :instance,
  email: "admin@example.com",
  notify_email: "noreply@example.com",
-  skip_thread_containment: false
+  skip_thread_containment: false,
  federating: false,
  external_user_synchronization: false
 config :pleroma, :activitypub, sign_object_fetches: false
 # Configure your database
 config :pleroma, Pleroma.Repo,
@ -64,7 +68,10 @@ config :pleroma, Pleroma.ScheduledActivity,
  total_user_limit: 3,
  enabled: false
-config :pleroma, :rate_limit, app_account_creation: {10_000, 5}
+config :pleroma, :rate_limit,
  search: [{1000, 30}, {1000, 30}],
  app_account_creation: {10_000, 5},
  password_reset: {1000, 30}
 config :pleroma, :http_security, report_uri: "https://endpoint.com"
@ -74,6 +81,10 @@ rum_enabled = System.get_env("RUM_ENABLED") == "true"
 config :pleroma, :database, rum_enabled: rum_enabled
 IO.puts("RUM enabled: #{rum_enabled}")
 config :joken, default_signer: "yU8uHKq+yyAkZ11Hx//jcdacWc8yQ1bxAAGrplzB0Zwwjkp35v0RK9SO8WTPr6QZ"
 config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.ClientMock
 try do
  import_config "test.secret.exs"
 rescue
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@ -0,0 +1,14 @@
 #!/bin/ash
 set -e
 echo "-- Waiting for database..."
 while ! pg_isready -U ${DB_USER:-pleroma} -d postgres://${DB_HOST:-db}:5432/${DB_NAME:-pleroma} -t 1; do
    sleep 1s
 done
 echo "-- Running migrations..."
 $HOME/bin/pleroma_ctl migrate
 echo "-- Starting!"
 exec $HOME/bin/pleroma start
--- a/docs/api/admin_api.md
+++ b/docs/api/admin_api.md
@ -176,17 +176,30 @@ Note: Available `:permission_group` is currently moderator and admin. 404 is ret
  - `nickname`
  - `status` BOOLEAN field, false value means deactivation.
-## `/api/pleroma/admin/users/:nickname`
+## `/api/pleroma/admin/users/:nickname_or_id`
 ### Retrive the details of a user
 - Method: `GET`
 - Params:
-  - `nickname`
+  - `nickname` or `id`
 - Response:
  - On failure: `Not found`
  - On success: JSON of the user
 ## `/api/pleroma/admin/users/:nickname_or_id/statuses`
 ### Retrive user's latest statuses
 - Method: `GET`
 - Params:
  - `nickname` or `id`
  - *optional* `page_size`: number of statuses to return (default is `20`)
  - *optional* `godmode`: `true`/`false` – allows to see private statuses
 - Response:
  - On failure: `Not found`
  - On success: JSON array of user's latest statuses
 ## `/api/pleroma/admin/relay`
 ### Follow a Relay
@ -562,8 +575,32 @@ Note: Available `:permission_group` is currently moderator and admin. 404 is ret
    - 404 Not Found `"Not found"`
  - On success: 200 OK `{}`
 ## `/api/pleroma/admin/config/migrate_to_db`
 ### Run mix task pleroma.config migrate_to_db
 Copy settings on key `:pleroma` to DB.
 - Method `GET`
 - Params: none
 - Response:
 ```json
 {}
 ```
 ## `/api/pleroma/admin/config/migrate_from_db`
 ### Run mix task pleroma.config migrate_from_db
 Copy all settings from DB to `config/prod.exported_from_db.secret.exs` with deletion from DB.
 - Method `GET`
 - Params: none
 - Response:
 ```json
 {}
 ```
 ## `/api/pleroma/admin/config`
 ### List config settings
 List config settings only works with `:pleroma => :instance => :dynamic_configuration` setting to `true`.
 - Method `GET`
 - Params: none
 - Response:
@ -573,7 +610,7 @@ Note: Available `:permission_group` is currently moderator and admin. 404 is ret
  configs: [
    {
      "group": string,
-      "key": string,
+      "key": string or string with leading `:` for atoms,
      "value": string or {} or [] or {"tuple": []}
     }
  ]
@ -582,11 +619,16 @@ Note: Available `:permission_group` is currently moderator and admin. 404 is ret
 ## `/api/pleroma/admin/config`
 ### Update config settings
 Updating config settings only works with `:pleroma => :instance => :dynamic_configuration` setting to `true`.
 Module name can be passed as string, which starts with `Pleroma`, e.g. `"Pleroma.Upload"`.
-Atom or boolean value can be passed with `:` in the beginning, e.g. `":true"`, `":upload"`. For keys it is not needed.
+Atom keys and values can be passed with `:` in the beginning, e.g. `":upload"`.
-Integer with `i:`, e.g. `"i:150"`.
+Tuples can be passed as `{"tuple": ["first_val", Pleroma.Module, []]}`.
 Tuple with more than 2 values with `{"tuple": ["first_val", Pleroma.Module, []]}`.
 `{"tuple": ["some_string", "Pleroma.Some.Module", []]}` will be converted to `{"some_string", Pleroma.Some.Module, []}`.
 Keywords can be passed as lists with 2 child tuples, e.g.
 `[{"tuple": ["first_val", Pleroma.Module]}, {"tuple": ["second_val", true]}]`.
 If value contains list of settings `[subkey: val1, subkey2: val2, subkey3: val3]`, it's possible to remove only subkeys instead of all settings passing `subkeys` parameter. E.g.:
 {"group": "pleroma", "key": "some_key", "delete": "true", "subkeys": [":subkey", ":subkey3"]}.
 Compile time settings (need instance reboot):
 - all settings by this keys:
@ -603,9 +645,10 @@ Compile time settings (need instance reboot):
 - Params:
  - `configs` => [
    - `group` (string)
-    - `key` (string)
+    - `key` (string or string with leading `:` for atoms)
    - `value` (string, [], {} or {"tuple": []})
    - `delete` = true (optional, if parameter must be deleted)
    - `subkeys` [(string with leading `:` for atoms)] (optional, works only if `delete=true` parameter is passed, otherwise will be ignored)
  ]
 - Request (example):
@ -616,23 +659,24 @@ Compile time settings (need instance reboot):
    {
      "group": "pleroma",
      "key": "Pleroma.Upload",
-      "value": {
+      "value": [
-        "uploader": "Pleroma.Uploaders.Local",
+        {"tuple": [":uploader", "Pleroma.Uploaders.Local"]},
-        "filters": ["Pleroma.Upload.Filter.Dedupe"],
+        {"tuple": [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
-        "link_name": ":true",
+        {"tuple": [":link_name", true]},
-        "proxy_remote": ":false",
+        {"tuple": [":proxy_remote", false]},
-        "proxy_opts": {
+        {"tuple": [":proxy_opts", [
-          "redirect_on_failure": ":false",
+          {"tuple": [":redirect_on_failure", false]},
-          "max_body_length": "i:1048576",
+          {"tuple": [":max_body_length", 1048576]},
-          "http": {
+          {"tuple": [":http": [
-            "follow_redirect": ":true",
+            {"tuple": [":follow_redirect", true]},
-            "pool": ":upload"
+            {"tuple": [":pool", ":upload"]},
-          }
+          ]]}
-        },
+        ]
-        "dispatch": {
+        ]},
        {"tuple": [":dispatch", {
          "tuple": ["/api/v1/streaming", "Pleroma.Web.MastodonAPI.WebsocketHandler", []]
-        }
+        }]}
-      }
+      ]
    }
  ]
 }
@ -644,7 +688,7 @@ Compile time settings (need instance reboot):
  configs: [
    {
      "group": string,
-      "key": string,
+      "key": string or string with leading `:` for atoms,
      "value": string or {} or [] or {"tuple": []}
     }
  ]
--- a/docs/api/differences_in_mastoapi_responses.md
+++ b/docs/api/differences_in_mastoapi_responses.md
@ -16,9 +16,11 @@ Adding the parameter `with_muted=true` to the timeline queries will also return
 ## Statuses
 - `visibility`: has an additional possible value `list`
 Has these additional fields under the `pleroma` object:
- `local`: true if the post was made on the local instance.
+- `local`: true if the post was made on the local instance
 - `conversation_id`: the ID of the conversation the status is associated with (if any)
 - `in_reply_to_account_acct`: the `acct` property of User entity for replied user (if any)
 - `content`: a map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
@ -32,7 +34,10 @@ Has these additional fields under the `pleroma` object:
 ## Accounts
- `/api/v1/accounts/:id`: The `id` parameter can also be the `nickname` of the user. This only works in this endpoint, not the deeper nested ones for following etc.
+The `id` parameter can also be the `nickname` of the user. This only works in these endpoints, not the deeper nested ones for following etc.
 - `/api/v1/accounts/:id`
 - `/api/v1/accounts/:id/statuses`
 Has these additional fields under the `pleroma` object:
@ -45,6 +50,7 @@ Has these additional fields under the `pleroma` object:
 - `hide_follows`: boolean, true when the user has follow hiding enabled
 - `settings_store`: A generic map of settings for frontends. Opaque to the backend. Only returned in `verify_credentials` and `update_credentials`
 - `chat_token`: The token needed for Pleroma chat. Only returned in `verify_credentials`
 - `deactivated`: boolean, true when the user is deactivated
 ### Source
@ -72,6 +78,7 @@ Additional parameters can be added to the JSON body/Form data:
 - `preview`: boolean, if set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example.
 - `content_type`: string, contain the MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint.
 - `to`: A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for for post visibility are not affected by this and will still apply.
 - `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`.
 ## PATCH `/api/v1/update_credentials`
--- a/docs/api/pleroma_api.md
+++ b/docs/api/pleroma_api.md
@ -238,6 +238,21 @@ See [Admin-API](Admin-API.md)
 ]
 ```
 ## `/api/v1/pleroma/accounts/update_*`
 ### Set and clear account avatar, banner, and background
 - PATCH `/api/v1/pleroma/accounts/update_avatar`: Set/clear user avatar image
 - PATCH `/api/v1/pleroma/accounts/update_banner`: Set/clear user banner image
 - PATCH `/api/v1/pleroma/accounts/update_background`: Set/clear user background image
 ## `/api/v1/pleroma/accounts/confirmation_resend`
 ### Resend confirmation email
 * Method `POST`
 * Params:
    * `email`: email of that needs to be verified
 * Authentication: not required
 * Response: 204 No Content 
 ## `/api/v1/pleroma/mascot`
 ### Gets user mascot image
 * Method `GET`
--- a/docs/clients.md
+++ b/docs/clients.md
@ -31,10 +31,11 @@ Feel free to contact us to be added to this list!
 - Features: No Streaming
 ### Fedilab
- Source Code: <https://gitlab.com/tom79/mastalab/>
+- Homepage: <https://fedilab.app/>
- Contact: [@tom79@mastodon.social](https://mastodon.social/users/tom79)
+- Source Code: <https://framagit.org/tom79/fedilab/>
 - Contact: [@fedilab@framapiaf.org](https://framapiaf.org/users/fedilab)
 - Platforms: Android
- Features: Streaming Ready
+- Features: Streaming Ready, Moderation, Text Formatting 
 ### Nekonium
 - Homepage: [F-Droid Repository](https://repo.gdgd.jp.net/), [Google Play](https://play.google.com/store/apps/details?id=com.apps.nekonium), [Amazon](https://www.amazon.co.jp/dp/B076FXPRBC/)
--- a/docs/config.md
+++ b/docs/config.md
@ -18,6 +18,7 @@ Note: `strip_exif` has been replaced by `Pleroma.Upload.Filter.Mogrify`.
 ## Pleroma.Uploaders.S3
 * `bucket`: S3 bucket name
 * `bucket_namespace`: S3 bucket namespace
 * `public_endpoint`: S3 endpoint that the user finally accesses(ex. "https://s3.dualstack.ap-northeast-1.amazonaws.com")
 * `truncated_namespace`: If you use S3 compatible service such as Digital Ocean Spaces or CDN, set folder name or "" etc.
 For example, when using CDN to S3 virtual host format, set "".
@ -25,7 +26,7 @@ At this time, write CNAME to CDN in public_endpoint.
 ## Pleroma.Upload.Filter.Mogrify
-* `args`: List of actions for the `mogrify` command like `"strip"` or `["strip", "auto-orient", {"impode", "1"}]`.
+* `args`: List of actions for the `mogrify` command like `"strip"` or `["strip", "auto-orient", {"implode", "1"}]`.
 ## Pleroma.Upload.Filter.Dedupe
@ -41,6 +42,7 @@ This filter replaces the filename (not the path) of an upload. For complete obfu
 ## Pleroma.Emails.Mailer
 * `adapter`: one of the mail adapters listed in [Swoosh readme](https://github.com/swoosh/swoosh#adapters), or `Swoosh.Adapters.Local` for in-memory mailbox.
 * `api_key` / `password` and / or other adapter-specific settings, per the above documentation.
 * `enabled`: Allows enable/disable send  emails. Default: `false`.
 An example for Sendgrid adapter:
@ -87,6 +89,7 @@ config :pleroma, Pleroma.Emails.Mailer,
 * `invites_enabled`: Enable user invitations for admins (depends on `registrations_open: false`).
 * `account_activation_required`: Require users to confirm their emails before signing in.
 * `federating`: Enable federation with other instances
 * `federation_incoming_replies_max_depth`: Max. depth of reply-to activities fetching on incoming federation, to prevent out-of-memory situations while fetching very long threads. If set to `nil`, threads of any depth will be fetched. Lower this value if you experience out-of-memory crashes.
 * `federation_reachability_timeout_days`: Timeout (in days) of each external federation target being unreachable prior to pausing federating to it.
 * `allow_relay`: Enable Pleroma’s Relay, which makes it possible to follow a whole instance
 * `rewrite_policy`: Message Rewrite Policy, either one or a list. Here are the ones available by default:
@ -99,11 +102,13 @@ config :pleroma, Pleroma.Emails.Mailer,
  * `Pleroma.Web.ActivityPub.MRF.EnsureRePrepended`: Rewrites posts to ensure that replies to posts with subjects do not have an identical subject and instead begin with re:.
  * `Pleroma.Web.ActivityPub.MRF.AntiLinkSpamPolicy`: Rejects posts from likely spambots by rejecting posts from new users that contain links.
  * `Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`: Crawls attachments using their MediaProxy URLs so that the MediaProxy cache is primed.
  * `Pleroma.Web.ActivityPub.MRF.MentionPolicy`: Drops posts mentioning configurable users. (see `:mrf_mention` section)
 * `public`: Makes the client API in authentificated mode-only except for user-profiles. Useful for disabling the Local Timeline and The Whole Known Network.
 * `quarantined_instances`: List of ActivityPub instances where private(DMs, followers-only) activities will not be send.
 * `managed_config`: Whenether the config for pleroma-fe is configured in this config or in ``static/config.json``
 * `allowed_post_formats`: MIME-type list of formats allowed to be posted (transformed into HTML)
 * `mrf_transparency`: Make the content of your Message Rewrite Facility settings public (via nodeinfo).
 * `mrf_transparency_exclusions`: Exclude specific instance names from MRF transparency.  The use of the exclusions feature will be disclosed in nodeinfo as a boolean value.
 * `scope_copy`: Copy the scope (private/unlisted/public) in replies to posts by default.
 * `subject_line_behavior`: Allows changing the default behaviour of subject lines in replies. Valid values:
  * "email": Copy and preprend re:, as in email.
@ -124,6 +129,8 @@ config :pleroma, Pleroma.Emails.Mailer,
 * `skip_thread_containment`: Skip filter out broken threads. The default is `false`.
 * `limit_to_local_content`: Limit unauthenticated users to search for local statutes and users only. Possible values: `:unauthenticated`, `:all` and `false`. The default is `:unauthenticated`.
 * `dynamic_configuration`: Allow transferring configuration to DB with the subsequent customization from Admin api.
 * `external_user_synchronization`: Enabling following/followers counters synchronization for external users.
 ## :logger
@ -266,6 +273,9 @@ config :pleroma, :mrf_subchain,
 * `federated_timeline_removal`: A list of patterns which result in message being removed from federated timelines (a.k.a unlisted), each pattern can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)
 * `replace`: A list of tuples containing `{pattern, replacement}`, `pattern` can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)
 ## :mrf_mention
 * `actors`: A list of actors, for which to drop any posts mentioning.
 ## :media_proxy
 * `enabled`: Enables proxying of remote media to the instance’s proxy
 * `base_url`: The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host/CDN fronts.
@ -323,6 +333,7 @@ This will make Pleroma listen on `127.0.0.1` port `8080` and generate urls start
 * ``unfollow_blocked``: Whether blocks result in people getting unfollowed
 * ``outgoing_blocks``: Whether to federate blocks to other instances
 * ``deny_follow_blocked``: Whether to disallow following an account that has blocked the user in question
 * ``sign_object_fetches``: Sign object fetches with HTTP signatures
 ## :http_security
 * ``enabled``: Whether the managed content security policy is enabled
@ -420,6 +431,7 @@ This config contains two queues: `federator_incoming` and `federator_outgoing`.
 * `enabled`: if enabled the instance will parse metadata from attached links to generate link previews
 * `ignore_hosts`: list of hosts which will be ignored by the metadata parser. For example `["accounts.google.com", "xss.website"]`, defaults to `[]`.
 * `ignore_tld`: list TLDs (top-level domains) which will ignore for parse metadata. default is ["local", "localdomain", "lan"]
 * `parsers`: list of Rich Media parsers
 ## :fetch_initial_posts
 * `enabled`: if enabled, when a new user is federated with, fetch some of their latest posts
@ -525,6 +537,18 @@ Authentication / authorization settings.
 * `oauth_consumer_template`: OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.
 * `oauth_consumer_strategies`: the list of enabled OAuth consumer strategies; by default it's set by `OAUTH_CONSUMER_STRATEGIES` environment variable. Each entry in this space-delimited string should be of format `<strategy>` or `<strategy>:<dependency>` (e.g. `twitter` or `keycloak:ueberauth_keycloak_strategy` in case dependency is named differently than `ueberauth_<strategy>`).
 ## :email_notifications
 Email notifications settings.
  - digest - emails of "what you've missed" for users who have been
    inactive for a while.
    - active: globally enable or disable digest emails
    - schedule: When to send digest email, in [crontab format](https://en.wikipedia.org/wiki/Cron).
      "0 0 * * 0" is the default, meaning "once a week at midnight on Sunday morning"
    - interval: Minimum interval between digest emails to one user
    - inactivity_threshold: Minimum user inactivity threshold
 ## OAuth consumer mode
 OAuth consumer mode allows sign in / sign up via external OAuth providers (e.g. Twitter, Facebook, Google, Microsoft, etc.).
@ -636,3 +660,12 @@ A keyword list of rate limiters where a key is a limiter name and value is the l
 It is also possible to have different limits for unauthenticated and authenticated users: the keyword value must be a list of two tuples where the first one is a config for unauthenticated users and the second one is for authenticated.
 See [`Pleroma.Plugs.RateLimiter`](Pleroma.Plugs.RateLimiter.html) documentation for examples.
 Supported rate limiters:
 * `:search` for the search requests (account & status search etc.)
 * `:app_account_creation` for registering user accounts from the same IP address
 * `:relations_actions` for actions on relations with all users (follow, unfollow)
 * `:relation_id_action` for actions on relation with a specific user (follow, unfollow)
 * `:statuses_actions` for create / delete / fav / unfav / reblog / unreblog actions on any statuses
 * `:status_id_action` for fav / unfav or reblog / unreblog actions on the same status by the same user
--- a/docs/config/howto_mediaproxy.md
+++ b/docs/config/howto_mediaproxy.md
@ -1,8 +1,8 @@
 # How to activate mediaproxy
 ## Explanation
-Without the `mediaproxy` function, Pleroma don't store any remote content like pictures, video etc. locally. So every time you open Pleroma, the content is loaded from the source server, from where the post is coming. This can result in slowly loading content or/and increased bandwidth usage on the source server.
+Without the `mediaproxy` function, Pleroma doesn't store any remote content like pictures, video etc. locally. So every time you open Pleroma, the content is loaded from the source server, from where the post is coming. This can result in slowly loading content or/and increased bandwidth usage on the source server.
-With the `mediaproxy` function you can use the cache ability of nginx, to cache these content, so user can access it faster, cause it's loaded from your server.
+With the `mediaproxy` function you can use nginx to cache this content, so users can access it faster, because it's loaded from your server.
 ## Activate it
@ -24,7 +24,9 @@ If you came here from one of the installation guides, take a look at the example
 ```
 config :pleroma, :media_proxy,
      enabled: true,
      proxy_opts: [
            redirect_on_failure: true
      ]
      #base_url: "https://cache.pleroma.social"
 ```
 If you want to use a subdomain to serve the files, uncomment `base_url`, change the url and add a comma after `true` in the previous line.
--- a/docs/config/howto_set_richmedia_cache_ttl_based_on_image.md
+++ b/docs/config/howto_set_richmedia_cache_ttl_based_on_image.md
@ -0,0 +1,33 @@
 # How to set rich media cache ttl based on image ttl
 ## Explanation
 Richmedia are cached without the ttl but the rich media may have image which can expire, like aws signed url.
 In such cases the old image url (expired) is returned from the media cache.
 So to avoid such situation we can define a module that will set ttl based on image.
 The module must adopt behaviour `Pleroma.Web.RichMedia.Parser.TTL`
 ### Example
 ```exs
 defmodule MyModule do
  @behaviour Pleroma.Web.RichMedia.Parser.TTL
  @impl Pleroma.Web.RichMedia.Parser.TTL
  def ttl(data, url) do
    image_url = Map.get(data, :image)
    # do some parsing in the url and get the ttl of the image
    # return ttl is unix time
    parse_ttl_from_url(image_url)
  end
 end
 ```
 And update the config
 ```exs
 config :pleroma, :rich_media,
  ttl_setters: [Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl, MyModule]
 ```
 > For reference there is a parser for AWS signed URL `Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl`, it's enabled by default.
--- a/docs/config/small_customizations.md
+++ b/docs/config/small_customizations.md
@ -1,35 +1,12 @@
 # Small customizations
 Replace `dev.secret.exs` with `prod.secret.exs` according to your setup.
-# Thumbnail
+See also static_dir.md for visual settings.
-Replace `priv/static/instance/thumbnail.jpeg` with your selfie or other neat picture. It will appear in [Pleroma Instances](http://distsn.org/pleroma-instances.html).
+## Theme
 # Instance-specific panel
 ![instance-specific panel demo](/uploads/296b19ec806b130e0b49b16bfe29ce8a/image.png)
 To show the instance specific panel, set `show_instance_panel` to `true` in `config/dev.secret.exs`. You can modify its content by editing `priv/static/instance/panel.html`.
 # Background
 You can change the background of your Pleroma instance by uploading it to `priv/static/static`, and then changing `"background"` in `config/dev.secret.exs` accordingly.
 # Logo
 ![logo modification demo](/uploads/c70b14de60fa74245e7f0dcfa695ebff/image.png)
 If you want to give a brand to your instance, look no further. You can change the logo of your instance by uploading it to `priv/static/static`, and then changing `logo` in `config/dev.secret.exs` accordingly.
 # Theme
 All users of your instance will be able to change the theme they use by going to the settings (the cog in the top-right hand corner). However, if you wish to change the default theme, you can do so by editing `theme` in `config/dev.secret.exs` accordingly.
-# Terms of Service
+## Message Visibility
 Terms of Service will be shown to all users on the registration page. It's the best place where to write down the rules for your instance. You can modify the rules by changing `priv/static/static/terms-of-service.html`.
 # Message Visibility
 To enable message visibility options when posting like in the Mastodon frontend, set
 `scope_options_enabled` to `true` in `config/dev.secret.exs`.
--- a/docs/config/static_dir.md
+++ b/docs/config/static_dir.md
@ -7,7 +7,13 @@ config :pleroma, :instance,
  static_dir: "instance/static/",
 ```
-You can overwrite this value in your configuration to use a different static instance directory.
+For example, edit `instance/static/instance/panel.html` .
 Alternatively, you can overwrite this value in your configuration to use a different static instance directory.
 This document is written assuming `instance/static/`.
 Or, if you want to manage your custom file in git repository, basically remove the `instance/` entry from `.gitignore`.
 ## robots.txt
@ -18,3 +24,46 @@ If you want to generate a restrictive `robots.txt`, you can run the following mi
 ```
 mix pleroma.robots_txt disallow_all
 ```
 ## Thumbnail
 Put on `instance/static/instance/thumbnail.jpeg` with your selfie or other neat picture. It will appear in [Pleroma Instances](http://distsn.org/pleroma-instances.html).
 ## Instance-specific panel
 ![instance-specific panel demo](/uploads/296b19ec806b130e0b49b16bfe29ce8a/image.png)
 Create and Edit your file on `instance/static/instance/panel.html`.
 ## Background
 You can change the background of your Pleroma instance by uploading it to `instance/static/`, and then changing `background` in `config/prod.secret.exs` accordingly.
 If you put `instance/static/images/background.jpg`
 ```
 config :pleroma, :frontend_configurations,
  pleroma_fe: %{
    background: "/images/background.jpg"
  }
 ```
 ## Logo
 ![logo modification demo](/uploads/c70b14de60fa74245e7f0dcfa695ebff/image.png)
 If you want to give a brand to your instance, You can change the logo of your instance by uploading it to `instance/static/`.
 Alternatively, you can specify the path with config.
 If you put `instance/static/static/mylogo-file.png`
 ```
 config :pleroma, :frontend_configurations,
  pleroma_fe: %{
   logo: "/static/mylogo-file.png"
  }
 ```
 ## Terms of Service
 Terms of Service will be shown to all users on the registration page. It's the best place where to write down the rules for your instance. You can modify the rules by changing `instance/static/static/terms-of-service.html`.
--- a/docs/installation/alpine_linux_en.md
+++ b/docs/installation/alpine_linux_en.md
@ -202,7 +202,6 @@ sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress
 #### Further reading
 * [Admin tasks](Admin tasks)
 * [Backup your instance](backup.html)
 * [Configuration tips](general-tips-for-customizing-pleroma-fe.html)
 * [Hardening your instance](hardening.html)
--- a/docs/installation/arch_linux_en.md
+++ b/docs/installation/arch_linux_en.md
@ -200,7 +200,6 @@ sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress
 #### Further reading
 * [Admin tasks](Admin tasks)
 * [Backup your instance](backup.html)
 * [Configuration tips](general-tips-for-customizing-pleroma-fe.html)
 * [Hardening your instance](hardening.html)
--- a/docs/installation/centos7_en.md
+++ b/docs/installation/centos7_en.md
@ -264,7 +264,6 @@ sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress
 #### Further reading
 * [Admin tasks](Admin tasks)
 * [Backup your instance](backup.html)
 * [Configuration tips](general-tips-for-customizing-pleroma-fe.html)
 * [Hardening your instance](hardening.html)
--- a/docs/installation/debian_based_en.md
+++ b/docs/installation/debian_based_en.md
@ -190,7 +190,6 @@ sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress
 #### Further reading
 * [Admin tasks](Admin tasks)
 * [Backup your instance](backup.html)
 * [Configuration tips](general-tips-for-customizing-pleroma-fe.html)
 * [Hardening your instance](hardening.html)
--- a/docs/installation/debian_based_jp.md
+++ b/docs/installation/debian_based_jp.md
@ -180,7 +180,6 @@ mix set_moderator username [true|false]
 #### コンフィギュレーションとカスタマイズ
 * [Admin tasks](Admin tasks)
 * [Backup your instance](backup.html)
 * [Configuration tips](general-tips-for-customizing-pleroma-fe.html)
 * [Hardening your instance](hardening.html)
--- a/docs/installation/gentoo_en.md
+++ b/docs/installation/gentoo_en.md
@ -283,7 +283,6 @@ If you opted to allow sudo for the `pleroma` user but would like to remove the a
 #### Further reading
 * [Admin tasks](Admin tasks)
 * [Backup your instance](backup.html)
 * [Configuration tips](general-tips-for-customizing-pleroma-fe.html)
 * [Hardening your instance](hardening.html)
--- a/docs/installation/otp_en.md
+++ b/docs/installation/otp_en.md
@ -242,6 +242,14 @@ So for example, if the task is `mix pleroma.user set admin --admin`, you should
 ```sh
 su pleroma -s $SHELL -lc "./bin/pleroma_ctl user set admin --admin"
 ```
 ## Create your first user and set as admin
 ```sh
 cd /opt/pleroma/bin
 su pleroma -s $SHELL -lc "./bin/pleroma_ctl user new joeuser joeuser@sld.tld --admin"
 ```
 This will create an account withe the username of 'joeuser' with the email address of joeuser@sld.tld, and set that user's account as an admin. This will result in a link that you can paste into the browser, which logs you in and enables you to set the password.
 ### Updating
 Generally, doing the following is enough:
 ```sh
--- a/lib/healthcheck.ex
+++ b/lib/healthcheck.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Healthcheck do
  @moduledoc """
  Module collects metrics about app and assign healthy status.
--- a/lib/jason_types.ex
+++ b/lib/jason_types.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 Postgrex.Types.define(
  Pleroma.PostgresTypes,
  [] ++ Ecto.Adapters.Postgres.extensions(),
--- a/lib/mix/tasks/pleroma/benchmark.ex
+++ b/lib/mix/tasks/pleroma/benchmark.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Mix.Tasks.Pleroma.Benchmark do
  import Mix.Pleroma
  use Mix.Task
--- a/lib/mix/tasks/pleroma/config.ex
+++ b/lib/mix/tasks/pleroma/config.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Mix.Tasks.Pleroma.Config do
  use Mix.Task
  import Mix.Pleroma
@ -11,7 +15,7 @@ defmodule Mix.Tasks.Pleroma.Config do
      mix pleroma.config migrate_to_db
-  ## Transfers config from DB to file.
+  ## Transfers config from DB to file `config/env.exported_from_db.secret.exs`
      mix pleroma.config migrate_from_db ENV
  """
@ -24,6 +28,14 @@ defmodule Mix.Tasks.Pleroma.Config do
      |> Enum.reject(fn {k, _v} -> k in [Pleroma.Repo, :env] end)
      |> Enum.each(fn {k, v} ->
        key = to_string(k) |> String.replace("Elixir.", "")
        key =
          if String.starts_with?(key, "Pleroma.") do
            key
          else
            ":" <> key
          end
        {:ok, _} = Config.update_or_create(%{group: "pleroma", key: key, value: v})
        Mix.shell().info("#{key} is migrated.")
      end)
@ -49,17 +61,9 @@ defmodule Mix.Tasks.Pleroma.Config do
      Repo.all(Config)
      |> Enum.each(fn config ->
        mark =
          if String.starts_with?(config.key, "Pleroma.") or
               String.starts_with?(config.key, "Ueberauth"),
             do: ",",
             else: ":"
        IO.write(
          file,
-          "config :#{config.group}, #{config.key}#{mark} #{
+          "config :#{config.group}, #{config.key}, #{inspect(Config.from_binary(config.value))}\r\n\r\n"
            inspect(Config.from_binary(config.value))
          }\r\n"
        )
        if delete? do
--- a/lib/mix/tasks/pleroma/database.ex
+++ b/lib/mix/tasks/pleroma/database.ex
@ -8,6 +8,7 @@ defmodule Mix.Tasks.Pleroma.Database do
  alias Pleroma.Repo
  alias Pleroma.User
  require Logger
  require Pleroma.Constants
  import Mix.Pleroma
  use Mix.Task
@ -35,6 +36,10 @@ defmodule Mix.Tasks.Pleroma.Database do
  ## Remove duplicated items from following and update followers count for all users
      mix pleroma.database update_users_following_followers_counts
  ## Fix the pre-existing "likes" collections for all objects
      mix pleroma.database fix_likes_collections
  """
  def run(["remove_embedded_objects" | args]) do
    {options, [], []} =
@ -99,10 +104,15 @@ defmodule Mix.Tasks.Pleroma.Database do
      NaiveDateTime.utc_now()
      |> NaiveDateTime.add(-(deadline * 86_400))
    public = "https://www.w3.org/ns/activitystreams#Public"
    from(o in Object,
-      where: fragment("?->'to' \\? ? OR ?->'cc' \\? ?", o.data, ^public, o.data, ^public),
+      where:
        fragment(
          "?->'to' \\? ? OR ?->'cc' \\? ?",
          o.data,
          ^Pleroma.Constants.as_public(),
          o.data,
          ^Pleroma.Constants.as_public()
        ),
      where: o.inserted_at < ^time_deadline,
      where:
        fragment("split_part(?->>'actor', '/', 3) != ?", o.data, ^Pleroma.Web.Endpoint.host())
@ -119,4 +129,36 @@ defmodule Mix.Tasks.Pleroma.Database do
      )
    end
  end
  def run(["fix_likes_collections"]) do
    import Ecto.Query
    start_pleroma()
    from(object in Object,
      where: fragment("(?)->>'likes' is not null", object.data),
      select: %{id: object.id, likes: fragment("(?)->>'likes'", object.data)}
    )
    |> Pleroma.RepoStreamer.chunk_stream(100)
    |> Stream.each(fn objects ->
      ids =
        objects
        |> Enum.filter(fn object -> object.likes |> Jason.decode!() |> is_map() end)
        |> Enum.map(& &1.id)
      Object
      |> where([object], object.id in ^ids)
      |> update([object],
        set: [
          data:
            fragment(
              "jsonb_set(?, '{likes}', '[]'::jsonb, true)",
              object.data
            )
        ]
      )
      |> Repo.update_all([], timeout: :infinity)
    end)
    |> Stream.run()
  end
 end
--- a/lib/mix/tasks/pleroma/digest.ex
+++ b/lib/mix/tasks/pleroma/digest.ex
@ -0,0 +1,33 @@
 defmodule Mix.Tasks.Pleroma.Digest do
  use Mix.Task
  @shortdoc "Manages digest emails"
  @moduledoc """
  Manages digest emails
  ## Send digest email since given date (user registration date by default)
  ignoring user activity status.
  ``mix pleroma.digest test <nickname> <since_date>``
  Example: ``mix pleroma.digest test donaldtheduck 2019-05-20``
  """
  def run(["test", nickname | opts]) do
    Mix.Pleroma.start_pleroma()
    user = Pleroma.User.get_by_nickname(nickname)
    last_digest_emailed_at =
      with [date] <- opts,
           {:ok, datetime} <- Timex.parse(date, "{YYYY}-{0M}-{0D}") do
        datetime
      else
        _ -> user.inserted_at
      end
    patched_user = %{user | last_digest_emailed_at: last_digest_emailed_at}
    _user = Pleroma.DigestEmailWorker.perform(patched_user)
    Mix.shell().info("Digest email have been sent to #{nickname} (#{user.email})")
  end
 end
--- a/lib/mix/tasks/pleroma/ecto/ecto.ex
+++ b/lib/mix/tasks/pleroma/ecto/ecto.ex
@ -1,6 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-onl
 defmodule Mix.Tasks.Pleroma.Ecto do
  @doc """
  Ensures the given repository's migrations path exists on the file system.
--- a/lib/mix/tasks/pleroma/instance.ex
+++ b/lib/mix/tasks/pleroma/instance.ex
@ -34,6 +34,8 @@ defmodule Mix.Tasks.Pleroma.Instance do
  - `--db-configurable Y/N` - Allow/disallow configuring instance from admin part
  - `--uploads-dir` - the directory uploads go in when using a local uploader
  - `--static-dir` - the directory custom public files should be read from (custom emojis, frontend bundle overrides, robots.txt, etc.)
  - `--listen-ip` - the ip the app should listen to, defaults to 127.0.0.1
  - `--listen-port` - the port the app should listen to, defaults to 4000
  """
  def run(["gen" | rest]) do
@ -56,7 +58,9 @@ defmodule Mix.Tasks.Pleroma.Instance do
          indexable: :string,
          db_configurable: :string,
          uploads_dir: :string,
-          static_dir: :string
+          static_dir: :string,
          listen_ip: :string,
          listen_port: :string
        ],
        aliases: [
          o: :output,
@ -146,6 +150,22 @@ defmodule Mix.Tasks.Pleroma.Instance do
          "n"
        ) === "y"
      listen_port =
        get_option(
          options,
          :listen_port,
          "What port will the app listen to (leave it if you are using the default setup with nginx)?",
          4000
        )
      listen_ip =
        get_option(
          options,
          :listen_ip,
          "What ip will the app listen to (leave it if you are using the default setup with nginx)?",
          "127.0.0.1"
        )
      uploads_dir =
        get_option(
          options,
@ -163,6 +183,7 @@ defmodule Mix.Tasks.Pleroma.Instance do
        )
      secret = :crypto.strong_rand_bytes(64) |> Base.encode64() |> binary_part(0, 64)
      jwt_secret = :crypto.strong_rand_bytes(64) |> Base.encode64() |> binary_part(0, 64)
      signing_salt = :crypto.strong_rand_bytes(8) |> Base.encode64() |> binary_part(0, 8)
      {web_push_public_key, web_push_private_key} = :crypto.generate_key(:ecdh, :prime256v1)
      template_dir = Application.app_dir(:pleroma, "priv") <> "/templates"
@ -180,13 +201,16 @@ defmodule Mix.Tasks.Pleroma.Instance do
          dbuser: dbuser,
          dbpass: dbpass,
          secret: secret,
          jwt_secret: jwt_secret,
          signing_salt: signing_salt,
          web_push_public_key: Base.url_encode64(web_push_public_key, padding: false),
          web_push_private_key: Base.url_encode64(web_push_private_key, padding: false),
          db_configurable?: db_configurable?,
          static_dir: static_dir,
          uploads_dir: uploads_dir,
-          rum_enabled: rum_enabled
+          rum_enabled: rum_enabled,
          listen_ip: listen_ip,
          listen_port: listen_port
        )
      result_psql =
--- a/lib/mix/tasks/pleroma/relay.ex
+++ b/lib/mix/tasks/pleroma/relay.ex
@ -5,6 +5,7 @@
 defmodule Mix.Tasks.Pleroma.Relay do
  use Mix.Task
  import Mix.Pleroma
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.Relay
  @shortdoc "Manages remote relays"
@ -22,6 +23,10 @@ defmodule Mix.Tasks.Pleroma.Relay do
  ``mix pleroma.relay unfollow <relay_url>``
  Example: ``mix pleroma.relay unfollow https://example.org/relay``
  ## List relay subscriptions
  ``mix pleroma.relay list``
  """
  def run(["follow", target]) do
    start_pleroma()
@ -44,4 +49,19 @@ defmodule Mix.Tasks.Pleroma.Relay do
      {:error, e} -> shell_error("Error while following #{target}: #{inspect(e)}")
    end
  end
  def run(["list"]) do
    start_pleroma()
    with %User{} = user <- Relay.get_actor() do
      user.following
      |> Enum.each(fn entry ->
        URI.parse(entry)
        |> Map.get(:host)
        |> shell_info()
      end)
    else
      e -> shell_error("Error while fetching relay subscription list: #{inspect(e)}")
    end
  end
 end
--- a/lib/mix/tasks/pleroma/user.ex
+++ b/lib/mix/tasks/pleroma/user.ex
@ -31,8 +31,8 @@ defmodule Mix.Tasks.Pleroma.User do
      mix pleroma.user invite [OPTION...]
    Options:
-    - `--expires_at DATE` - last day on which token is active (e.g. "2019-04-05")
+    - `--expires-at DATE` - last day on which token is active (e.g. "2019-04-05")
-    - `--max_use NUMBER` - maximum numbers of token uses
+    - `--max-use NUMBER` - maximum numbers of token uses
  ## List generated invites
@ -62,6 +62,10 @@ defmodule Mix.Tasks.Pleroma.User do
      mix pleroma.user unsubscribe NICKNAME
  ## Unsubscribe local users from an entire instance and deactivate all accounts
      mix pleroma.user unsubscribe_all_from_instance INSTANCE
  ## Create a password reset link.
      mix pleroma.user reset_password NICKNAME
@ -246,6 +250,20 @@ defmodule Mix.Tasks.Pleroma.User do
    end
  end
  def run(["unsubscribe_all_from_instance", instance]) do
    start_pleroma()
    Pleroma.User.Query.build(%{nickname: "@#{instance}"})
    |> Pleroma.RepoStreamer.chunk_stream(500)
    |> Stream.each(fn users ->
      users
      |> Enum.each(fn user ->
        run(["unsubscribe", user.nickname])
      end)
    end)
    |> Stream.run()
  end
  def run(["set", nickname | rest]) do
    start_pleroma()
--- a/lib/pleroma/activity.ex
+++ b/lib/pleroma/activity.ex
@ -344,5 +344,5 @@ defmodule Pleroma.Activity do
    )
  end
-  defdelegate search(user, query), to: Pleroma.Activity.Search
+  defdelegate search(user, query, options \\ []), to: Pleroma.Activity.Search
 end
--- a/lib/pleroma/activity/search.ex
+++ b/lib/pleroma/activity/search.ex
@ -5,14 +5,19 @@
 defmodule Pleroma.Activity.Search do
  alias Pleroma.Activity
  alias Pleroma.Object.Fetcher
-  alias Pleroma.Repo
+  alias Pleroma.Pagination
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.Visibility
  require Pleroma.Constants
  import Ecto.Query
-  def search(user, search_query) do
+  def search(user, search_query, options \\ []) do
    index_type = if Pleroma.Config.get([:database, :rum_enabled]), do: :rum, else: :gin
    limit = Enum.min([Keyword.get(options, :limit), 40])
    offset = Keyword.get(options, :offset, 0)
    author = Keyword.get(options, :author)
    Activity
    |> Activity.with_preloaded_object()
@ -20,15 +25,23 @@ defmodule Pleroma.Activity.Search do
    |> restrict_public()
    |> query_with(index_type, search_query)
    |> maybe_restrict_local(user)
-    |> Repo.all()
+    |> maybe_restrict_author(author)
    |> Pagination.fetch_paginated(%{"offset" => offset, "limit" => limit}, :offset)
    |> maybe_fetch(user, search_query)
  end
  def maybe_restrict_author(query, %User{} = author) do
    from([a, o] in query,
      where: a.actor == ^author.ap_id
    )
  end
  def maybe_restrict_author(query, _), do: query
  defp restrict_public(q) do
    from([a, o] in q,
      where: fragment("?->>'type' = 'Create'", a.data),
-      where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
+      where: ^Pleroma.Constants.as_public() in a.recipients
      limit: 40
    )
  end
--- a/lib/pleroma/application.ex
+++ b/lib/pleroma/application.ex
@ -140,6 +140,11 @@ defmodule Pleroma.Application do
            id: :federator_init,
            start: {Task, :start_link, [&Pleroma.Web.Federator.init/0]},
            restart: :temporary
          },
          %{
            id: :internal_fetch_init,
            start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
            restart: :temporary
          }
        ] ++
        streamer_child() ++
@ -157,7 +162,9 @@ defmodule Pleroma.Application do
    # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
    # for other strategies and supported options
    opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
-    Supervisor.start_link(children, opts)
+    result = Supervisor.start_link(children, opts)
    :ok = after_supervisor_start()
    result
  end
  defp setup_instrumenters do
@ -222,4 +229,17 @@ defmodule Pleroma.Application do
      :hackney_pool.child_spec(pool, options)
    end
  end
  defp after_supervisor_start do
    with digest_config <- Application.get_env(:pleroma, :email_notifications)[:digest],
         true <- digest_config[:active] do
      PleromaJobQueue.schedule(
        digest_config[:schedule],
        :digest_emails,
        Pleroma.DigestEmailWorker
      )
    end
    :ok
  end
 end
--- a/lib/pleroma/bbs/authenticator.ex
+++ b/lib/pleroma/bbs/authenticator.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.BBS.Authenticator do
  use Sshd.PasswordAuthenticator
  alias Comeonin.Pbkdf2
--- a/lib/pleroma/bbs/handler.ex
+++ b/lib/pleroma/bbs/handler.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.BBS.Handler do
  use Sshd.ShellHandler
  alias Pleroma.Activity
--- a/lib/pleroma/bookmark.ex
+++ b/lib/pleroma/bookmark.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Bookmark do
  use Ecto.Schema
--- a/lib/pleroma/captcha/captcha.ex
+++ b/lib/pleroma/captcha/captcha.ex
@ -3,6 +3,8 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Captcha do
  import Pleroma.Web.Gettext
  alias Calendar.DateTime
  alias Plug.Crypto.KeyGenerator
  alias Plug.Crypto.MessageEncryptor
@ -83,10 +85,11 @@ defmodule Pleroma.Captcha do
      with {:ok, data} <- MessageEncryptor.decrypt(answer_data, secret, sign_secret),
           %{at: at, answer_data: answer_md5} <- :erlang.binary_to_term(data) do
        try do
-          if DateTime.before?(at, valid_if_after), do: throw({:error, "CAPTCHA expired"})
+          if DateTime.before?(at, valid_if_after),
            do: throw({:error, dgettext("errors", "CAPTCHA expired")})
          if not is_nil(Cachex.get!(:used_captcha_cache, token)),
-            do: throw({:error, "CAPTCHA already used"})
+            do: throw({:error, dgettext("errors", "CAPTCHA already used")})
          res = method().validate(token, captcha, answer_md5)
          # Throw if an error occurs
@ -101,7 +104,7 @@ defmodule Pleroma.Captcha do
          :throw, e -> e
        end
      else
-        _ -> {:error, "Invalid answer data"}
+        _ -> {:error, dgettext("errors", "Invalid answer data")}
      end
    {:reply, result, state}
--- a/lib/pleroma/captcha/kocaptcha.ex
+++ b/lib/pleroma/captcha/kocaptcha.ex
@ -3,6 +3,7 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Captcha.Kocaptcha do
  import Pleroma.Web.Gettext
  alias Pleroma.Captcha.Service
  @behaviour Service
@ -12,7 +13,7 @@ defmodule Pleroma.Captcha.Kocaptcha do
    case Tesla.get(endpoint <> "/new") do
      {:error, _} ->
-        %{error: "Kocaptcha service unavailable"}
+        %{error: dgettext("errors", "Kocaptcha service unavailable")}
      {:ok, res} ->
        json_resp = Jason.decode!(res.body)
@ -32,6 +33,6 @@ defmodule Pleroma.Captcha.Kocaptcha do
    if not is_nil(captcha) and
         :crypto.hash(:md5, captcha) |> Base.encode16() == String.upcase(answer_data),
       do: :ok,
-       else: {:error, "Invalid CAPTCHA"}
+       else: {:error, dgettext("errors", "Invalid CAPTCHA")}
  end
 end
--- a/lib/pleroma/config/transfer_task.ex
+++ b/lib/pleroma/config/transfer_task.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Config.TransferTask do
  use Task
  alias Pleroma.Web.AdminAPI.Config
@ -31,7 +35,7 @@ defmodule Pleroma.Config.TransferTask do
        if String.starts_with?(setting.key, "Pleroma.") do
          "Elixir." <> setting.key
        else
-          setting.key
+          String.trim_leading(setting.key, ":")
        end
      group = String.to_existing_atom(setting.group)
--- a/lib/pleroma/constants.ex
+++ b/lib/pleroma/constants.ex
@ -0,0 +1,9 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Constants do
  use Const
  const(as_public, do: "https://www.w3.org/ns/activitystreams#Public")
 end
--- a/lib/pleroma/digest_email_worker.ex
+++ b/lib/pleroma/digest_email_worker.ex
@ -0,0 +1,35 @@
 defmodule Pleroma.DigestEmailWorker do
  import Ecto.Query
  @queue_name :digest_emails
  def perform do
    config = Pleroma.Config.get([:email_notifications, :digest])
    negative_interval = -Map.fetch!(config, :interval)
    inactivity_threshold = Map.fetch!(config, :inactivity_threshold)
    inactive_users_query = Pleroma.User.list_inactive_users_query(inactivity_threshold)
    now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
    from(u in inactive_users_query,
      where: fragment(~s(? #> '{"email_notifications","digest"}' @> 'true'), u.info),
      where: u.last_digest_emailed_at < datetime_add(^now, ^negative_interval, "day"),
      select: u
    )
    |> Pleroma.Repo.all()
    |> Enum.each(&PleromaJobQueue.enqueue(@queue_name, __MODULE__, [&1]))
  end
  @doc """
  Send digest email to the given user.
  Updates `last_digest_emailed_at` field for the user and returns the updated user.
  """
  @spec perform(Pleroma.User.t()) :: Pleroma.User.t()
  def perform(user) do
    with %Swoosh.Email{} = email <- Pleroma.Emails.UserEmail.digest_email(user) do
      Pleroma.Emails.Mailer.deliver_async(email)
    end
    Pleroma.User.touch_last_digest_emailed_at(user)
  end
 end
--- a/lib/pleroma/emails/admin_email.ex
+++ b/lib/pleroma/emails/admin_email.ex
@ -63,7 +63,6 @@ defmodule Pleroma.Emails.AdminEmail do
    new()
    |> to({to.name, to.email})
    |> from({instance_name(), instance_notify_email()})
    |> reply_to({reporter.name, reporter.email})
    |> subject("#{instance_name()} Report")
    |> html_body(html_body)
  end
--- a/lib/pleroma/emails/mailer.ex
+++ b/lib/pleroma/emails/mailer.ex
@ -3,11 +3,58 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Emails.Mailer do
-  use Swoosh.Mailer, otp_app: :pleroma
+  @moduledoc """
  Defines the Pleroma mailer.
  The module contains functions to delivery email using Swoosh.Mailer.
  """
  alias Swoosh.DeliveryError
  @otp_app :pleroma
  @mailer_config [otp: :pleroma]
  @spec enabled?() :: boolean()
  def enabled?, do: Pleroma.Config.get([__MODULE__, :enabled])
  @doc "add email to queue"
  def deliver_async(email, config \\ []) do
    PleromaJobQueue.enqueue(:mailer, __MODULE__, [:deliver_async, email, config])
  end
  @doc "callback to perform send email from queue"
  def perform(:deliver_async, email, config), do: deliver(email, config)
  @spec deliver(Swoosh.Email.t(), Keyword.t()) :: {:ok, term} | {:error, term}
  def deliver(email, config \\ [])
  def deliver(email, config) do
    case enabled?() do
      true -> Swoosh.Mailer.deliver(email, parse_config(config))
      false -> {:error, :deliveries_disabled}
    end
  end
  @spec deliver!(Swoosh.Email.t(), Keyword.t()) :: term | no_return
  def deliver!(email, config \\ [])
  def deliver!(email, config) do
    case deliver(email, config) do
      {:ok, result} -> result
      {:error, reason} -> raise DeliveryError, reason: reason
    end
  end
  @on_load :validate_dependency
  @doc false
  def validate_dependency do
    parse_config([])
    |> Keyword.get(:adapter)
    |> Swoosh.Mailer.validate_dependency()
  end
  defp parse_config(config) do
    Swoosh.Mailer.parse_config(@otp_app, __MODULE__, @mailer_config, config)
  end
 end
--- a/lib/pleroma/emails/user_email.ex
+++ b/lib/pleroma/emails/user_email.ex
@ -5,7 +5,7 @@
 defmodule Pleroma.Emails.UserEmail do
  @moduledoc "User emails"
-  import Swoosh.Email
+  use Phoenix.Swoosh, view: Pleroma.Web.EmailView, layout: {Pleroma.Web.LayoutView, :email}
  alias Pleroma.Web.Endpoint
  alias Pleroma.Web.Router
@ -87,4 +87,73 @@ defmodule Pleroma.Emails.UserEmail do
    |> subject("#{instance_name()} account confirmation")
    |> html_body(html_body)
  end
  @doc """
  Email used in digest email notifications
  Includes Mentions and New Followers data
  If there are no mentions (even when new followers exist), the function will return nil
  """
  @spec digest_email(Pleroma.User.t()) :: Swoosh.Email.t() | nil
  def digest_email(user) do
    new_notifications =
      Pleroma.Notification.for_user_since(user, user.last_digest_emailed_at)
      |> Enum.reduce(%{followers: [], mentions: []}, fn
        %{activity: %{data: %{"type" => "Create"}, actor: actor} = activity} = notification,
        acc ->
          new_mention = %{
            data: notification,
            object: Pleroma.Object.normalize(activity),
            from: Pleroma.User.get_by_ap_id(actor)
          }
          %{acc | mentions: [new_mention | acc.mentions]}
        %{activity: %{data: %{"type" => "Follow"}, actor: actor} = activity} = notification,
        acc ->
          new_follower = %{
            data: notification,
            object: Pleroma.Object.normalize(activity),
            from: Pleroma.User.get_by_ap_id(actor)
          }
          %{acc | followers: [new_follower | acc.followers]}
        _, acc ->
          acc
      end)
    with [_ | _] = mentions <- new_notifications.mentions do
      html_data = %{
        instance: instance_name(),
        user: user,
        mentions: mentions,
        followers: new_notifications.followers,
        unsubscribe_link: unsubscribe_url(user, "digest")
      }
      new()
      |> to(recipient(user))
      |> from(sender())
      |> subject("Your digest from #{instance_name()}")
      |> render_body("digest.html", html_data)
    else
      _ ->
        nil
    end
  end
  @doc """
  Generate unsubscribe link for given user and notifications type.
  The link contains JWT token with the data, and subscription can be modified without
  authorization.
  """
  @spec unsubscribe_url(Pleroma.User.t(), String.t()) :: String.t()
  def unsubscribe_url(user, notifications_type) do
    token =
      %{"sub" => user.id, "act" => %{"unsubscribe" => notifications_type}, "exp" => false}
      |> Pleroma.JWT.generate_and_sign!()
      |> Base.encode64()
    Router.Helpers.subscription_url(Pleroma.Web.Endpoint, :unsubscribe, token)
  end
 end
--- a/lib/pleroma/flake_id.ex
+++ b/lib/pleroma/flake_id.ex
@ -66,6 +66,16 @@ defmodule Pleroma.FlakeId do
  @spec get :: binary
  def get, do: to_string(:gen_server.call(:flake, :get))
  # checks that ID is is valid FlakeID
  #
  @spec is_flake_id?(String.t()) :: boolean
  def is_flake_id?(id), do: is_flake_id?(String.to_charlist(id), true)
  defp is_flake_id?([c | cs], true) when c >= ?0 and c <= ?9, do: is_flake_id?(cs, true)
  defp is_flake_id?([c | cs], true) when c >= ?A and c <= ?Z, do: is_flake_id?(cs, true)
  defp is_flake_id?([c | cs], true) when c >= ?a and c <= ?z, do: is_flake_id?(cs, true)
  defp is_flake_id?([], true), do: true
  defp is_flake_id?(_, _), do: false
  # -- Ecto.Type API
  @impl Ecto.Type
  def type, do: :uuid
--- a/lib/pleroma/http/connection.ex
+++ b/lib/pleroma/http/connection.ex
@ -11,6 +11,7 @@ defmodule Pleroma.HTTP.Connection do
    connect_timeout: 10_000,
    recv_timeout: 20_000,
    follow_redirect: true,
    force_redirect: true,
    pool: :federation
  ]
  @adapter Application.get_env(:tesla, :adapter)
@ -29,7 +30,7 @@ defmodule Pleroma.HTTP.Connection do
  # fetch Hackney options
  #
-  defp hackney_options(opts) do
+  def hackney_options(opts) do
    options = Keyword.get(opts, :adapter, [])
    adapter_options = Pleroma.Config.get([:http, :adapter], [])
    proxy_url = Pleroma.Config.get([:http, :proxy_url], nil)
--- a/lib/pleroma/http/http.ex
+++ b/lib/pleroma/http/http.ex
@ -65,10 +65,7 @@ defmodule Pleroma.HTTP do
  end
  def process_request_options(options) do
-    case Pleroma.Config.get([:http, :proxy_url]) do
+    Keyword.merge(Pleroma.HTTP.Connection.hackney_options([]), options)
      nil -> options
      proxy -> options ++ [proxy: proxy]
    end
  end
  @doc """
--- a/lib/pleroma/instances.ex
+++ b/lib/pleroma/instances.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Instances do
  @moduledoc "Instances context."
--- a/lib/pleroma/instances/instance.ex
+++ b/lib/pleroma/instances/instance.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Instances.Instance do
  @moduledoc "Instance."
--- a/lib/pleroma/jwt.ex
+++ b/lib/pleroma/jwt.ex
@ -0,0 +1,9 @@
 defmodule Pleroma.JWT do
  use Joken.Config
  @impl true
  def token_config do
    default_claims(skip: [:aud])
    |> add_claim("aud", &Pleroma.Web.Endpoint.url/0, &(&1 == Pleroma.Web.Endpoint.url()))
  end
 end
--- a/lib/pleroma/keys.ex
+++ b/lib/pleroma/keys.ex
@ -35,10 +35,12 @@ defmodule Pleroma.Keys do
  end
  def keys_from_pem(pem) do
-    [private_key_code] = :public_key.pem_decode(pem)
+    with [private_key_code] <- :public_key.pem_decode(pem),
-    private_key = :public_key.pem_entry_decode(private_key_code)
+         private_key <- :public_key.pem_entry_decode(private_key_code),
-    {:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
+         {:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} <- private_key do
-    public_key = {:RSAPublicKey, modulus, exponent}
+      {:ok, private_key, {:RSAPublicKey, modulus, exponent}}
-    {:ok, private_key, public_key}
+    else
      error -> {:error, error}
    end
  end
 end
--- a/lib/pleroma/list.ex
+++ b/lib/pleroma/list.ex
@ -16,6 +16,7 @@ defmodule Pleroma.List do
    belongs_to(:user, User, type: Pleroma.FlakeId)
    field(:title, :string)
    field(:following, {:array, :string}, default: [])
    field(:ap_id, :string)
    timestamps()
  end
@ -55,6 +56,10 @@ defmodule Pleroma.List do
    Repo.one(query)
  end
  def get_by_ap_id(ap_id) do
    Repo.get_by(__MODULE__, ap_id: ap_id)
  end
  def get_following(%Pleroma.List{following: following} = _list) do
    q =
      from(
@ -105,7 +110,14 @@ defmodule Pleroma.List do
  def create(title, %User{} = creator) do
    list = %Pleroma.List{user_id: creator.id, title: title}
-    Repo.insert(list)
+
    Repo.transaction(fn ->
      list = Repo.insert!(list)
      list
      |> change(ap_id: "#{creator.ap_id}/lists/#{list.id}")
      |> Repo.update!()
    end)
  end
  def follow(%Pleroma.List{following: following} = list, %User{} = followed) do
@ -125,4 +137,19 @@ defmodule Pleroma.List do
    |> follow_changeset(attrs)
    |> Repo.update()
  end
  def memberships(%User{follower_address: follower_address}) do
    Pleroma.List
    |> where([l], ^follower_address in l.following)
    |> select([l], l.ap_id)
    |> Repo.all()
  end
  def memberships(_), do: []
  def member?(%Pleroma.List{following: following}, %User{follower_address: follower_address}) do
    Enum.member?(following, follower_address)
  end
  def member?(_, _), do: false
 end
--- a/lib/pleroma/notification.ex
+++ b/lib/pleroma/notification.ex
@ -11,7 +11,6 @@ defmodule Pleroma.Notification do
  alias Pleroma.Pagination
  alias Pleroma.Repo
  alias Pleroma.User
  alias Pleroma.Web.CommonAPI
  alias Pleroma.Web.CommonAPI.Utils
  alias Pleroma.Web.Push
  alias Pleroma.Web.Streamer
@ -19,6 +18,8 @@ defmodule Pleroma.Notification do
  import Ecto.Query
  import Ecto.Changeset
  @type t :: %__MODULE__{}
  schema "notifications" do
    field(:seen, :boolean, default: false)
    belongs_to(:user, User, type: Pleroma.FlakeId)
@ -32,7 +33,8 @@ defmodule Pleroma.Notification do
    |> cast(attrs, [:seen])
  end
-  def for_user_query(user) do
+  def for_user_query(user, opts \\ []) do
    query =
      Notification
      |> where(user_id: ^user.id)
      |> where(
@ -52,14 +54,48 @@ defmodule Pleroma.Notification do
          )
      )
      |> preload([n, a, o], activity: {a, object: o})
    if opts[:with_muted] do
      query
    else
      where(query, [n, a], a.actor not in ^user.info.muted_notifications)
      |> where([n, a], a.actor not in ^user.info.blocks)
      |> where(
        [n, a],
        fragment("substring(? from '.*://([^/]*)')", a.actor) not in ^user.info.domain_blocks
      )
      |> join(:left, [n, a], tm in Pleroma.ThreadMute,
        on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data)
      )
      |> where([n, a, o, tm], is_nil(tm.user_id))
    end
  end
  def for_user(user, opts \\ %{}) do
    user
-    |> for_user_query()
+    |> for_user_query(opts)
    |> Pagination.fetch_paginated(opts)
  end
  @doc """
  Returns notifications for user received since given date.
  ## Examples
      iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-13 11:22:33])
      [%Pleroma.Notification{}, %Pleroma.Notification{}]
      iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-15 11:22:33])
      []
  """
  @spec for_user_since(Pleroma.User.t(), NaiveDateTime.t()) :: [t()]
  def for_user_since(user, date) do
    from(n in for_user_query(user),
      where: n.updated_at > ^date
    )
    |> Repo.all()
  end
  def set_read_up_to(%{id: user_id} = _user, id) do
    query =
      from(
@ -67,7 +103,10 @@ defmodule Pleroma.Notification do
        where: n.user_id == ^user_id,
        where: n.id <= ^id,
        update: [
-          set: [seen: true]
+          set: [
            seen: true,
            updated_at: ^NaiveDateTime.utc_now()
          ]
        ]
      )
@ -179,11 +218,10 @@ defmodule Pleroma.Notification do
  def get_notified_from_activity(_, _local_only), do: []
  @spec skip?(Activity.t(), User.t()) :: boolean()
  def skip?(activity, user) do
    [
      :self,
      :blocked,
      :muted,
      :followers,
      :follows,
      :non_followers,
@ -193,21 +231,11 @@ defmodule Pleroma.Notification do
    |> Enum.any?(&skip?(&1, activity, user))
  end
  @spec skip?(atom(), Activity.t(), User.t()) :: boolean()
  def skip?(:self, activity, user) do
    activity.data["actor"] == user.ap_id
  end
  def skip?(:blocked, activity, user) do
    actor = activity.data["actor"]
    User.blocks?(user, %{ap_id: actor})
  end
  def skip?(:muted, activity, user) do
    actor = activity.data["actor"]
    User.mutes?(user, %{ap_id: actor}) or CommonAPI.thread_muted?(user, activity)
  end
  def skip?(
        :followers,
        activity,
--- a/lib/pleroma/object.ex
+++ b/lib/pleroma/object.ex
@ -44,44 +44,46 @@ defmodule Pleroma.Object do
    Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
  end
-  def normalize(_, fetch_remote \\ true)
+  defp warn_on_no_object_preloaded(ap_id) do
    "Object.normalize() called without preloaded object (#{ap_id}). Consider preloading the object"
    |> Logger.debug()
    Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
  end
  def normalize(_, fetch_remote \\ true, options \\ [])
  # If we pass an Activity to Object.normalize(), we can try to use the preloaded object.
  # Use this whenever possible, especially when walking graphs in an O(N) loop!
-  def normalize(%Object{} = object, _), do: object
+  def normalize(%Object{} = object, _, _), do: object
-  def normalize(%Activity{object: %Object{} = object}, _), do: object
+  def normalize(%Activity{object: %Object{} = object}, _, _), do: object
  # A hack for fake activities
-  def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _) do
+  def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _, _) do
    %Object{id: "pleroma:fake_object_id", data: data}
  end
-  # Catch and log Object.normalize() calls where the Activity's child object is not
+  # No preloaded object
-  # preloaded.
+  def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, fetch_remote, _) do
-  def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, fetch_remote) do
+    warn_on_no_object_preloaded(ap_id)
    Logger.debug(
      "Object.normalize() called without preloaded object (#{ap_id}).  Consider preloading the object!"
    )
    Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
    normalize(ap_id, fetch_remote)
  end
-  def normalize(%Activity{data: %{"object" => ap_id}}, fetch_remote) do
+  # No preloaded object
-    Logger.debug(
+  def normalize(%Activity{data: %{"object" => ap_id}}, fetch_remote, _) do
-      "Object.normalize() called without preloaded object (#{ap_id}).  Consider preloading the object!"
+    warn_on_no_object_preloaded(ap_id)
    )
    Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
    normalize(ap_id, fetch_remote)
  end
  # Old way, try fetching the object through cache.
-  def normalize(%{"id" => ap_id}, fetch_remote), do: normalize(ap_id, fetch_remote)
+  def normalize(%{"id" => ap_id}, fetch_remote, _), do: normalize(ap_id, fetch_remote)
-  def normalize(ap_id, false) when is_binary(ap_id), do: get_cached_by_ap_id(ap_id)
+  def normalize(ap_id, false, _) when is_binary(ap_id), do: get_cached_by_ap_id(ap_id)
-  def normalize(ap_id, true) when is_binary(ap_id), do: Fetcher.fetch_object_from_id!(ap_id)
+
-  def normalize(_, _), do: nil
+  def normalize(ap_id, true, options) when is_binary(ap_id) do
    Fetcher.fetch_object_from_id!(ap_id, options)
  end
  def normalize(_, _, _), do: nil
  # Owned objects can only be mutated by their owner
  def authorize_mutation(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}),
--- a/lib/pleroma/object/containment.ex
+++ b/lib/pleroma/object/containment.ex
@ -48,6 +48,9 @@ defmodule Pleroma.Object.Containment do
    end
  end
  def contain_origin(id, %{"attributedTo" => actor} = params),
    do: contain_origin(id, Map.put(params, "actor", actor))
  def contain_origin_from_id(_id, %{"id" => nil}), do: :error
  def contain_origin_from_id(id, %{"id" => other_id} = _params) do
@ -60,4 +63,9 @@ defmodule Pleroma.Object.Containment do
      :error
    end
  end
  def contain_child(%{"object" => %{"id" => id, "attributedTo" => _} = object}),
    do: contain_origin(id, object)
  def contain_child(_), do: :ok
 end
--- a/lib/pleroma/object/fetcher.ex
+++ b/lib/pleroma/object/fetcher.ex
@ -1,7 +1,13 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Object.Fetcher do
  alias Pleroma.HTTP
  alias Pleroma.Object
  alias Pleroma.Object.Containment
  alias Pleroma.Signature
  alias Pleroma.Web.ActivityPub.InternalFetchActor
  alias Pleroma.Web.ActivityPub.Transmogrifier
  alias Pleroma.Web.OStatus
@ -22,39 +28,45 @@ defmodule Pleroma.Object.Fetcher do
  # TODO:
  # This will create a Create activity, which we need internally at the moment.
-  def fetch_object_from_id(id) do
+  def fetch_object_from_id(id, options \\ []) do
    if object = Object.get_cached_by_ap_id(id) do
      {:ok, object}
    else
      Logger.info("Fetching #{id} via AP")
-      with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
+      with {:fetch, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
-           nil <- Object.normalize(data, false),
+           {:normalize, nil} <- {:normalize, Object.normalize(data, false)},
           params <- %{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
             # Should we seriously keep this attributedTo thing?
             "actor" => data["actor"] || data["attributedTo"],
             "object" => data
           },
-           :ok <- Containment.contain_origin(id, params),
+           {:containment, :ok} <- {:containment, Containment.contain_origin(id, params)},
-           {:ok, activity} <- Transmogrifier.handle_incoming(params),
+           {:ok, activity} <- Transmogrifier.handle_incoming(params, options),
           {:object, _data, %Object{} = object} <-
             {:object, data, Object.normalize(activity, false)} do
        {:ok, object}
      else
        {:containment, _} ->
          {:error, "Object containment failed."}
        {:error, {:reject, nil}} ->
          {:reject, nil}
        {:object, data, nil} ->
          reinject_object(data)
-        object = %Object{} ->
+        {:normalize, object = %Object{}} ->
          {:ok, object}
        _e ->
          # Only fallback when receiving a fetch/normalization error with ActivityPub
          Logger.info("Couldn't get object via AP, trying out OStatus fetching...")
          # FIXME: OStatus Object Containment?
          case OStatus.fetch_activity_from_url(id) do
            {:ok, [activity | _]} -> {:ok, Object.normalize(activity, false)}
            e -> e
@ -63,8 +75,8 @@ defmodule Pleroma.Object.Fetcher do
    end
  end
-  def fetch_object_from_id!(id) do
+  def fetch_object_from_id!(id, options \\ []) do
-    with {:ok, object} <- fetch_object_from_id(id) do
+    with {:ok, object} <- fetch_object_from_id(id, options) do
      object
    else
      _e ->
@ -72,15 +84,52 @@ defmodule Pleroma.Object.Fetcher do
    end
  end
-  def fetch_and_contain_remote_object_from_id(id) do
+  defp make_signature(id, date) do
    uri = URI.parse(id)
    signature =
      InternalFetchActor.get_actor()
      |> Signature.sign(%{
        "(request-target)": "get #{uri.path}",
        host: uri.host,
        date: date
      })
    [{:Signature, signature}]
  end
  defp sign_fetch(headers, id, date) do
    if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
      headers ++ make_signature(id, date)
    else
      headers
    end
  end
  defp maybe_date_fetch(headers, date) do
    if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
      headers ++ [{:Date, date}]
    else
      headers
    end
  end
  def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
    Logger.info("Fetching object #{id} via AP")
-    with true <- String.starts_with?(id, "http"),
+    date =
-         {:ok, %{body: body, status: code}} when code in 200..299 <-
+      NaiveDateTime.utc_now()
-           HTTP.get(
+      |> Timex.format!("{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT")
-             id,
+
    headers =
      [{:Accept, "application/activity+json"}]
-           ),
+      |> maybe_date_fetch(date)
      |> sign_fetch(id, date)
    Logger.debug("Fetch headers: #{inspect(headers)}")
    with true <- String.starts_with?(id, "http"),
         {:ok, %{body: body, status: code}} when code in 200..299 <- HTTP.get(id, headers),
         {:ok, data} <- Jason.decode(body),
         :ok <- Containment.contain_origin_from_id(id, data) do
      {:ok, data}
@ -92,4 +141,9 @@ defmodule Pleroma.Object.Fetcher do
        {:error, e}
    end
  end
  def fetch_and_contain_remote_object_from_id(%{"id" => id}),
    do: fetch_and_contain_remote_object_from_id(id)
  def fetch_and_contain_remote_object_from_id(_id), do: {:error, "id must be a string"}
 end
--- a/lib/pleroma/object_tombstone.ex
+++ b/lib/pleroma/object_tombstone.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.ObjectTombstone do
  @enforce_keys [:id, :formerType, :deleted]
  defstruct [:id, :formerType, :deleted, type: "Tombstone"]
--- a/lib/pleroma/pagination.ex
+++ b/lib/pleroma/pagination.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Pagination do
  @moduledoc """
  Implements Mastodon-compatible pagination.
@ -10,16 +14,28 @@ defmodule Pleroma.Pagination do
  @default_limit 20
-  def fetch_paginated(query, params) do
+  def fetch_paginated(query, params, type \\ :keyset)
  def fetch_paginated(query, params, :keyset) do
    options = cast_params(params)
    query
-    |> paginate(options)
+    |> paginate(options, :keyset)
    |> Repo.all()
    |> enforce_order(options)
  end
-  def paginate(query, options) do
+  def fetch_paginated(query, params, :offset) do
    options = cast_params(params)
    query
    |> paginate(options, :offset)
    |> Repo.all()
  end
  def paginate(query, options, method \\ :keyset)
  def paginate(query, options, :keyset) do
    query
    |> restrict(:min_id, options)
    |> restrict(:since_id, options)
@ -28,11 +44,18 @@ defmodule Pleroma.Pagination do
    |> restrict(:limit, options)
  end
  def paginate(query, options, :offset) do
    query
    |> restrict(:offset, options)
    |> restrict(:limit, options)
  end
  defp cast_params(params) do
    param_types = %{
      min_id: :string,
      since_id: :string,
      max_id: :string,
      offset: :integer,
      limit: :integer
    }
@ -66,6 +89,10 @@ defmodule Pleroma.Pagination do
    order_by(query, [u], fragment("? desc nulls last", u.id))
  end
  defp restrict(query, :offset, %{offset: offset}) do
    offset(query, ^offset)
  end
  defp restrict(query, :limit, options) do
    limit = Map.get(options, :limit, @default_limit)
--- a/lib/pleroma/plugs/authentication_plug.ex
+++ b/lib/pleroma/plugs/authentication_plug.ex
@ -6,9 +6,21 @@ defmodule Pleroma.Plugs.AuthenticationPlug do
  alias Comeonin.Pbkdf2
  import Plug.Conn
  alias Pleroma.User
  require Logger
-  def init(options) do
+  def init(options), do: options
-    options
+
  def checkpw(password, "$6" <> _ = password_hash) do
    :crypt.crypt(password, password_hash) == password_hash
  end
  def checkpw(password, "$pbkdf2" <> _ = password_hash) do
    Pbkdf2.checkpw(password, password_hash)
  end
  def checkpw(_password, _password_hash) do
    Logger.error("Password hash not recognized")
    false
  end
  def call(%{assigns: %{user: %User{}}} = conn, _), do: conn
--- a/lib/pleroma/plugs/ensure_authenticated_plug.ex
+++ b/lib/pleroma/plugs/ensure_authenticated_plug.ex
@ -4,6 +4,7 @@
 defmodule Pleroma.Plugs.EnsureAuthenticatedPlug do
  import Plug.Conn
  import Pleroma.Web.TranslationHelpers
  alias Pleroma.User
  def init(options) do
@ -16,8 +17,7 @@ defmodule Pleroma.Plugs.EnsureAuthenticatedPlug do
  def call(conn, _) do
    conn
-    |> put_resp_content_type("application/json")
+    |> render_error(:forbidden, "Invalid credentials.")
    |> send_resp(403, Jason.encode!(%{error: "Invalid credentials."}))
    |> halt
  end
 end
--- a/lib/pleroma/plugs/ensure_public_or_authenticated_plug.ex
+++ b/lib/pleroma/plugs/ensure_public_or_authenticated_plug.ex
@ -3,6 +3,7 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug do
  import Pleroma.Web.TranslationHelpers
  import Plug.Conn
  alias Pleroma.Config
  alias Pleroma.User
@ -23,8 +24,7 @@ defmodule Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug do
      {false, _} ->
        conn
-        |> put_resp_content_type("application/json")
+        |> render_error(:forbidden, "This resource requires authentication.")
        |> send_resp(403, Jason.encode!(%{error: "This resource requires authentication."}))
        |> halt
    end
  end
--- a/lib/pleroma/plugs/http_signature.ex
+++ b/lib/pleroma/plugs/http_signature.ex
@ -3,7 +3,6 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Web.Plugs.HTTPSignaturePlug do
  alias Pleroma.Web.ActivityPub.Utils
  import Plug.Conn
  require Logger
@ -16,12 +15,9 @@ defmodule Pleroma.Web.Plugs.HTTPSignaturePlug do
  end
  def call(conn, _opts) do
    user = Utils.get_ap_id(conn.params["actor"])
    Logger.debug("Checking sig for #{user}")
    [signature | _] = get_req_header(conn, "signature")
-    cond do
+    if signature do
      signature && String.contains?(signature, user) ->
      # set (request-target) header to the appropriate value
      # we also replace the digest header with the one we computed
      conn =
@ -40,12 +36,7 @@ defmodule Pleroma.Web.Plugs.HTTPSignaturePlug do
        end
      assign(conn, :valid_signature, HTTPSignatures.validate_conn(conn))
-
+    else
      signature ->
        Logger.debug("Signature not from actor")
        assign(conn, :valid_signature, false)
      true ->
      Logger.debug("No signature header!")
      conn
    end
--- a/lib/pleroma/plugs/mapped_signature_to_identity_plug.ex
+++ b/lib/pleroma/plugs/mapped_signature_to_identity_plug.ex
@ -0,0 +1,70 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Web.Plugs.MappedSignatureToIdentityPlug do
  alias Pleroma.Signature
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.Utils
  import Plug.Conn
  require Logger
  def init(options), do: options
  defp key_id_from_conn(conn) do
    with %{"keyId" => key_id} <- HTTPSignatures.signature_for_conn(conn) do
      Signature.key_id_to_actor_id(key_id)
    else
      _ ->
        nil
    end
  end
  defp user_from_key_id(conn) do
    with key_actor_id when is_binary(key_actor_id) <- key_id_from_conn(conn),
         {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(key_actor_id) do
      user
    else
      _ ->
        nil
    end
  end
  def call(%{assigns: %{user: _}} = conn, _opts), do: conn
  # if this has payload make sure it is signed by the same actor that made it
  def call(%{assigns: %{valid_signature: true}, params: %{"actor" => actor}} = conn, _opts) do
    with actor_id <- Utils.get_ap_id(actor),
         {:user, %User{} = user} <- {:user, user_from_key_id(conn)},
         {:user_match, true} <- {:user_match, user.ap_id == actor_id} do
      assign(conn, :user, user)
    else
      {:user_match, false} ->
        Logger.debug("Failed to map identity from signature (payload actor mismatch)")
        Logger.debug("key_id=#{key_id_from_conn(conn)}, actor=#{actor}")
        assign(conn, :valid_signature, false)
      # remove me once testsuite uses mapped capabilities instead of what we do now
      {:user, nil} ->
        Logger.debug("Failed to map identity from signature (lookup failure)")
        Logger.debug("key_id=#{key_id_from_conn(conn)}, actor=#{actor}")
        conn
    end
  end
  # no payload, probably a signed fetch
  def call(%{assigns: %{valid_signature: true}} = conn, _opts) do
    with %User{} = user <- user_from_key_id(conn) do
      assign(conn, :user, user)
    else
      _ ->
        Logger.debug("Failed to map identity from signature (no payload actor mismatch)")
        Logger.debug("key_id=#{key_id_from_conn(conn)}")
        assign(conn, :valid_signature, false)
    end
  end
  # no signature at all
  def call(conn, _opts), do: conn
 end
--- a/lib/pleroma/plugs/oauth_scopes_plug.ex
+++ b/lib/pleroma/plugs/oauth_scopes_plug.ex
@ -4,6 +4,7 @@
 defmodule Pleroma.Plugs.OAuthScopesPlug do
  import Plug.Conn
  import Pleroma.Web.Gettext
  @behaviour Plug
@ -30,11 +31,14 @@ defmodule Pleroma.Plugs.OAuthScopesPlug do
      true ->
        missing_scopes = scopes -- token.scopes
-        error_message = "Insufficient permissions: #{Enum.join(missing_scopes, " #{op} ")}."
+        permissions = Enum.join(missing_scopes, " #{op} ")
        error_message =
          dgettext("errors", "Insufficient permissions: %{permissions}.", permissions: permissions)
        conn
        |> put_resp_content_type("application/json")
-        |> send_resp(403, Jason.encode!(%{error: error_message}))
+        |> send_resp(:forbidden, Jason.encode!(%{error: error_message}))
        |> halt()
    end
  end
--- a/lib/pleroma/plugs/rate_limiter.ex
+++ b/lib/pleroma/plugs/rate_limiter.ex
@ -31,12 +31,28 @@ defmodule Pleroma.Plugs.RateLimiter do
  ## Usage
  AllowedSyntax:
      plug(Pleroma.Plugs.RateLimiter, :limiter_name)
      plug(Pleroma.Plugs.RateLimiter, {:limiter_name, options})
  Allowed options:
      * `bucket_name` overrides bucket name (e.g. to have a separate limit for a set of actions)
      * `params` appends values of specified request params (e.g. ["id"]) to bucket name
  Inside a controller:
      plug(Pleroma.Plugs.RateLimiter, :one when action == :one)
      plug(Pleroma.Plugs.RateLimiter, :two when action in [:two, :three])
-  or inside a router pipiline:
+      plug(
        Pleroma.Plugs.RateLimiter,
        {:status_id_action, bucket_name: "status_id_action:fav_unfav", params: ["id"]}
        when action in ~w(fav_status unfav_status)a
      )
  or inside a router pipeline:
      pipeline :api do
        ...
@ -44,39 +60,61 @@ defmodule Pleroma.Plugs.RateLimiter do
        ...
      end
  """
-
+  import Pleroma.Web.TranslationHelpers
  import Phoenix.Controller, only: [json: 2]
  import Plug.Conn
  alias Pleroma.User
-  def init(limiter_name) do
+  def init(limiter_name) when is_atom(limiter_name) do
    init({limiter_name, []})
  end
  def init({limiter_name, opts}) do
    case Pleroma.Config.get([:rate_limit, limiter_name]) do
      nil -> nil
-      config -> {limiter_name, config}
+      config -> {limiter_name, config, opts}
    end
  end
-  # do not limit if there is no limiter configuration
+  # Do not limit if there is no limiter configuration
  def call(conn, nil), do: conn
-  def call(conn, opts) do
+  def call(conn, settings) do
-    case check_rate(conn, opts) do
+    case check_rate(conn, settings) do
-      {:ok, _count} -> conn
+      {:ok, _count} ->
-      {:error, _count} -> render_error(conn)
+        conn
      {:error, _count} ->
        render_throttled_error(conn)
    end
  end
-  defp check_rate(%{assigns: %{user: %User{id: user_id}}}, {limiter_name, [_, {scale, limit}]}) do
+  defp bucket_name(conn, limiter_name, opts) do
-    ExRated.check_rate("#{limiter_name}:#{user_id}", scale, limit)
+    bucket_name = opts[:bucket_name] || limiter_name
    if params_names = opts[:params] do
      params_values = for p <- Enum.sort(params_names), do: conn.params[p]
      Enum.join([bucket_name] ++ params_values, ":")
    else
      bucket_name
    end
  end
-  defp check_rate(conn, {limiter_name, [{scale, limit} | _]}) do
+  defp check_rate(
-    ExRated.check_rate("#{limiter_name}:#{ip(conn)}", scale, limit)
+         %{assigns: %{user: %User{id: user_id}}} = conn,
         {limiter_name, [_, {scale, limit}], opts}
       ) do
    bucket_name = bucket_name(conn, limiter_name, opts)
    ExRated.check_rate("#{bucket_name}:#{user_id}", scale, limit)
  end
-  defp check_rate(conn, {limiter_name, {scale, limit}}) do
+  defp check_rate(conn, {limiter_name, [{scale, limit} | _], opts}) do
-    check_rate(conn, {limiter_name, [{scale, limit}]})
+    bucket_name = bucket_name(conn, limiter_name, opts)
    ExRated.check_rate("#{bucket_name}:#{ip(conn)}", scale, limit)
  end
  defp check_rate(conn, {limiter_name, {scale, limit}, opts}) do
    check_rate(conn, {limiter_name, [{scale, limit}, {scale, limit}], opts})
  end
  def ip(%{remote_ip: remote_ip}) do
@ -85,10 +123,9 @@ defmodule Pleroma.Plugs.RateLimiter do
    |> Enum.join(".")
  end
-  defp render_error(conn) do
+  defp render_throttled_error(conn) do
    conn
-    |> put_status(:too_many_requests)
+    |> render_error(:too_many_requests, "Throttled")
    |> json(%{error: "Throttled"})
    |> halt()
  end
 end
--- a/lib/pleroma/plugs/set_format_plug.ex
+++ b/lib/pleroma/plugs/set_format_plug.ex
@ -0,0 +1,24 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Plugs.SetFormatPlug do
  import Plug.Conn, only: [assign: 3, fetch_query_params: 1]
  def init(_), do: nil
  def call(conn, _) do
    case get_format(conn) do
      nil -> conn
      format -> assign(conn, :format, format)
    end
  end
  defp get_format(conn) do
    conn.private[:phoenix_format] ||
      case fetch_query_params(conn) do
        %{query_params: %{"_format" => format}} -> format
        _ -> nil
      end
  end
 end
--- a/lib/pleroma/plugs/set_locale_plug.ex
+++ b/lib/pleroma/plugs/set_locale_plug.ex
@ -0,0 +1,63 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 # NOTE: this module is based on https://github.com/smeevil/set_locale
 defmodule Pleroma.Plugs.SetLocalePlug do
  import Plug.Conn, only: [get_req_header: 2, assign: 3]
  def init(_), do: nil
  def call(conn, _) do
    locale = get_locale_from_header(conn) || Gettext.get_locale()
    Gettext.put_locale(locale)
    assign(conn, :locale, locale)
  end
  defp get_locale_from_header(conn) do
    conn
    |> extract_accept_language()
    |> Enum.find(&supported_locale?/1)
  end
  defp extract_accept_language(conn) do
    case get_req_header(conn, "accept-language") do
      [value | _] ->
        value
        |> String.split(",")
        |> Enum.map(&parse_language_option/1)
        |> Enum.sort(&(&1.quality > &2.quality))
        |> Enum.map(& &1.tag)
        |> Enum.reject(&is_nil/1)
        |> ensure_language_fallbacks()
      _ ->
        []
    end
  end
  defp supported_locale?(locale) do
    Pleroma.Web.Gettext
    |> Gettext.known_locales()
    |> Enum.member?(locale)
  end
  defp parse_language_option(string) do
    captures = Regex.named_captures(~r/^\s?(?<tag>[\w\-]+)(?:;q=(?<quality>[\d\.]+))?$/i, string)
    quality =
      case Float.parse(captures["quality"] || "1.0") do
        {val, _} -> val
        :error -> 1.0
      end
    %{tag: captures["tag"], quality: quality}
  end
  defp ensure_language_fallbacks(tags) do
    Enum.flat_map(tags, fn tag ->
      [language | _] = String.split(tag, "-")
      if Enum.member?(tags, language), do: [tag], else: [tag, language]
    end)
  end
 end
--- a/lib/pleroma/plugs/uploaded_media.ex
+++ b/lib/pleroma/plugs/uploaded_media.ex
@ -7,6 +7,7 @@ defmodule Pleroma.Plugs.UploadedMedia do
  """
  import Plug.Conn
  import Pleroma.Web.Gettext
  require Logger
  @behaviour Plug
@ -45,7 +46,7 @@ defmodule Pleroma.Plugs.UploadedMedia do
    else
      _ ->
        conn
-        |> send_resp(500, "Failed")
+        |> send_resp(:internal_server_error, dgettext("errors", "Failed"))
        |> halt()
    end
  end
@ -64,7 +65,7 @@ defmodule Pleroma.Plugs.UploadedMedia do
      conn
    else
      conn
-      |> send_resp(404, "Not found")
+      |> send_resp(:not_found, dgettext("errors", "Not found"))
      |> halt()
    end
  end
@ -84,7 +85,7 @@ defmodule Pleroma.Plugs.UploadedMedia do
    Logger.error("#{__MODULE__}: Unknown get startegy: #{inspect(unknown)}")
    conn
-    |> send_resp(500, "Internal Error")
+    |> send_resp(:internal_server_error, dgettext("errors", "Internal Error"))
    |> halt()
  end
 end
--- a/lib/pleroma/plugs/user_is_admin_plug.ex
+++ b/lib/pleroma/plugs/user_is_admin_plug.ex
@ -3,6 +3,7 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Plugs.UserIsAdminPlug do
  import Pleroma.Web.TranslationHelpers
  import Plug.Conn
  alias Pleroma.User
@ -16,8 +17,7 @@ defmodule Pleroma.Plugs.UserIsAdminPlug do
  def call(conn, _) do
    conn
-    |> put_resp_content_type("application/json")
+    |> render_error(:forbidden, "User is not admin.")
    |> send_resp(403, Jason.encode!(%{error: "User is not admin."}))
    |> halt
  end
 end
--- a/lib/pleroma/reverse_proxy/client.ex
+++ b/lib/pleroma/reverse_proxy/client.ex
@ -0,0 +1,28 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.ReverseProxy.Client do
  @callback request(atom(), String.t(), [tuple()], String.t(), list()) ::
              {:ok, pos_integer(), [tuple()], reference() | map()}
              | {:ok, pos_integer(), [tuple()]}
              | {:ok, reference()}
              | {:error, term()}
  @callback stream_body(reference() | pid() | map()) ::
              {:ok, binary()} | :done | {:error, String.t()}
  @callback close(reference() | pid() | map()) :: :ok
  def request(method, url, headers, "", opts \\ []) do
    client().request(method, url, headers, "", opts)
  end
  def stream_body(ref), do: client().stream_body(ref)
  def close(ref), do: client().close(ref)
  defp client do
    Pleroma.Config.get([Pleroma.ReverseProxy.Client], :hackney)
  end
 end
--- a/lib/pleroma/reverse_proxy/reverse_proxy.ex
+++ b/lib/pleroma/reverse_proxy/reverse_proxy.ex
@ -61,7 +61,7 @@ defmodule Pleroma.ReverseProxy do
  * `http`: options for [hackney](https://github.com/benoitc/hackney).
  """
-  @default_hackney_options []
+  @default_hackney_options [pool: :media]
  @inline_content_types [
    "image/gif",
@ -94,7 +94,8 @@ defmodule Pleroma.ReverseProxy do
  def call(conn = %{method: method}, url, opts) when method in @methods do
    hackney_opts =
-      @default_hackney_options
+      Pleroma.HTTP.Connection.hackney_options([])
      |> Keyword.merge(@default_hackney_options)
      |> Keyword.merge(Keyword.get(opts, :http, []))
      |> HTTP.process_request_options()
@ -146,7 +147,7 @@ defmodule Pleroma.ReverseProxy do
    Logger.debug("#{__MODULE__} #{method} #{url} #{inspect(headers)}")
    method = method |> String.downcase() |> String.to_existing_atom()
-    case hackney().request(method, url, headers, "", hackney_opts) do
+    case client().request(method, url, headers, "", hackney_opts) do
      {:ok, code, headers, client} when code in @valid_resp_codes ->
        {:ok, code, downcase_headers(headers), client}
@ -173,7 +174,7 @@ defmodule Pleroma.ReverseProxy do
        halt(conn)
      {:error, :closed, conn} ->
-        :hackney.close(client)
+        client().close(client)
        halt(conn)
      {:error, error, conn} ->
@ -181,7 +182,7 @@ defmodule Pleroma.ReverseProxy do
          "#{__MODULE__} request to #{url} failed while reading/chunking: #{inspect(error)}"
        )
-        :hackney.close(client)
+        client().close(client)
        halt(conn)
    end
  end
@ -196,7 +197,7 @@ defmodule Pleroma.ReverseProxy do
             duration,
             Keyword.get(opts, :max_read_duration, @max_read_duration)
           ),
-         {:ok, data} <- hackney().stream_body(client),
+         {:ok, data} <- client().stream_body(client),
         {:ok, duration} <- increase_read_duration(duration),
         sent_so_far = sent_so_far + byte_size(data),
         :ok <- body_size_constraint(sent_so_far, Keyword.get(opts, :max_body_size)),
@ -378,5 +379,5 @@ defmodule Pleroma.ReverseProxy do
    {:ok, :no_duration_limit, :no_duration_limit}
  end
-  defp hackney, do: Pleroma.Config.get(:hackney, :hackney)
+  defp client, do: Pleroma.ReverseProxy.Client
 end
--- a/lib/pleroma/signature.ex
+++ b/lib/pleroma/signature.ex
@ -8,10 +8,25 @@ defmodule Pleroma.Signature do
  alias Pleroma.Keys
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.ActivityPub
-  alias Pleroma.Web.ActivityPub.Utils
+
  def key_id_to_actor_id(key_id) do
    uri =
      URI.parse(key_id)
      |> Map.put(:fragment, nil)
    uri =
      if not is_nil(uri.path) and String.ends_with?(uri.path, "/publickey") do
        Map.put(uri, :path, String.replace(uri.path, "/publickey", ""))
      else
        uri
      end
    URI.to_string(uri)
  end
  def fetch_public_key(conn) do
-    with actor_id <- Utils.get_ap_id(conn.params["actor"]),
+    with %{"keyId" => kid} <- HTTPSignatures.signature_for_conn(conn),
         actor_id <- key_id_to_actor_id(kid),
         {:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
      {:ok, public_key}
    else
@ -21,7 +36,8 @@ defmodule Pleroma.Signature do
  end
  def refetch_public_key(conn) do
-    with actor_id <- Utils.get_ap_id(conn.params["actor"]),
+    with %{"keyId" => kid} <- HTTPSignatures.signature_for_conn(conn),
         actor_id <- key_id_to_actor_id(kid),
         {:ok, _user} <- ActivityPub.make_user_from_ap_id(actor_id),
         {:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
      {:ok, public_key}
--- a/lib/pleroma/upload.ex
+++ b/lib/pleroma/upload.ex
@ -228,7 +228,14 @@ defmodule Pleroma.Upload do
          ""
        end
-    [base_url, "media", path]
+    prefix =
      if is_nil(Pleroma.Config.get([__MODULE__, :base_url])) do
        "media"
      else
        ""
      end
    [base_url, prefix, path]
    |> Path.join()
  end
--- a/lib/pleroma/upload/filter/dedupe.ex
+++ b/lib/pleroma/upload/filter/dedupe.ex
@ -6,10 +6,19 @@ defmodule Pleroma.Upload.Filter.Dedupe do
  @behaviour Pleroma.Upload.Filter
  alias Pleroma.Upload
-  def filter(%Upload{name: name} = upload) do
+  def filter(%Upload{name: name, tempfile: tempfile} = upload) do
-    extension = String.split(name, ".") |> List.last()
+    extension =
-    shasum = :crypto.hash(:sha256, File.read!(upload.tempfile)) |> Base.encode16(case: :lower)
+      name
      |> String.split(".")
      |> List.last()
    shasum =
      :crypto.hash(:sha256, File.read!(tempfile))
      |> Base.encode16(case: :lower)
    filename = shasum <> "." <> extension
    {:ok, %Upload{upload | id: shasum, path: filename}}
  end
  def filter(_), do: :ok
 end
--- a/lib/pleroma/upload/filter/mogrifun.ex
+++ b/lib/pleroma/upload/filter/mogrifun.ex
@ -4,6 +4,7 @@
 defmodule Pleroma.Upload.Filter.Mogrifun do
  @behaviour Pleroma.Upload.Filter
  alias Pleroma.Upload.Filter
  @filters [
    {"implode", "1"},
@ -34,31 +35,10 @@ defmodule Pleroma.Upload.Filter.Mogrifun do
  ]
  def filter(%Pleroma.Upload{tempfile: file, content_type: "image" <> _}) do
-    filter = Enum.random(@filters)
+    Filter.Mogrify.do_filter(file, [Enum.random(@filters)])
    file
    |> Mogrify.open()
    |> mogrify_filter(filter)
    |> Mogrify.save(in_place: true)
    :ok
  end
  def filter(_), do: :ok
  defp mogrify_filter(mogrify, [filter | rest]) do
    mogrify
    |> mogrify_filter(filter)
    |> mogrify_filter(rest)
  end
  defp mogrify_filter(mogrify, []), do: mogrify
  defp mogrify_filter(mogrify, {action, options}) do
    Mogrify.custom(mogrify, action, options)
  end
  defp mogrify_filter(mogrify, string) when is_binary(string) do
    Mogrify.custom(mogrify, string)
  end
 end
--- a/lib/pleroma/upload/filter/mogrify.ex
+++ b/lib/pleroma/upload/filter/mogrify.ex
@ -11,16 +11,19 @@ defmodule Pleroma.Upload.Filter.Mogrify do
  def filter(%Pleroma.Upload{tempfile: file, content_type: "image" <> _}) do
    filters = Pleroma.Config.get!([__MODULE__, :args])
-    file
+    do_filter(file, filters)
    |> Mogrify.open()
    |> mogrify_filter(filters)
    |> Mogrify.save(in_place: true)
    :ok
  end
  def filter(_), do: :ok
  def do_filter(file, filters) do
    file
    |> Mogrify.open()
    |> mogrify_filter(filters)
    |> Mogrify.save(in_place: true)
  end
  defp mogrify_filter(mogrify, nil), do: mogrify
  defp mogrify_filter(mogrify, [filter | rest]) do
--- a/lib/pleroma/uploaders/local.ex
+++ b/lib/pleroma/uploaders/local.ex
@ -11,7 +11,7 @@ defmodule Pleroma.Uploaders.Local do
  def put_file(upload) do
    {local_path, file} =
-      case Enum.reverse(String.split(upload.path, "/", trim: true)) do
+      case Enum.reverse(Path.split(upload.path)) do
        [file] ->
          {upload_path(), file}
@ -23,7 +23,7 @@ defmodule Pleroma.Uploaders.Local do
    result_file = Path.join(local_path, file)
-    unless File.exists?(result_file) do
+    if not File.exists?(result_file) do
      File.cp!(upload.tempfile, result_file)
    end
--- a/lib/pleroma/uploaders/mdii.ex
+++ b/lib/pleroma/uploaders/mdii.ex
@ -3,6 +3,8 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Uploaders.MDII do
  @moduledoc "Represents uploader for https://github.com/hakaba-hitoyo/minimal-digital-image-infrastructure"
  alias Pleroma.Config
  alias Pleroma.HTTP
--- a/lib/pleroma/uploaders/s3.ex
+++ b/lib/pleroma/uploaders/s3.ex
@ -6,10 +6,12 @@ defmodule Pleroma.Uploaders.S3 do
  @behaviour Pleroma.Uploaders.Uploader
  require Logger
  alias Pleroma.Config
  # The file name is re-encoded with S3's constraints here to comply with previous
  # links with less strict filenames
  def get_file(file) do
-    config = Pleroma.Config.get([__MODULE__])
+    config = Config.get([__MODULE__])
    bucket = Keyword.fetch!(config, :bucket)
    bucket_with_namespace =
@ -34,15 +36,15 @@ defmodule Pleroma.Uploaders.S3 do
  end
  def put_file(%Pleroma.Upload{} = upload) do
-    config = Pleroma.Config.get([__MODULE__])
+    config = Config.get([__MODULE__])
    bucket = Keyword.get(config, :bucket)
    {:ok, file_data} = File.read(upload.tempfile)
    s3_name = strict_encode(upload.path)
    op =
-      ExAws.S3.put_object(bucket, s3_name, file_data, [
+      upload.tempfile
      |> ExAws.S3.Upload.stream_file()
      |> ExAws.S3.upload(bucket, s3_name, [
        {:acl, :public_read},
        {:content_type, upload.content_type}
      ])
--- a/lib/pleroma/uploaders/swift/keystone.ex
+++ b/lib/pleroma/uploaders/swift/keystone.ex
@ -1,51 +0,0 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Uploaders.Swift.Keystone do
  use HTTPoison.Base
  def process_url(url) do
    Enum.join(
      [Pleroma.Config.get!([Pleroma.Uploaders.Swift, :auth_url]), url],
      "/"
    )
  end
  def process_response_body(body) do
    body
    |> Jason.decode!()
  end
  def get_token do
    settings = Pleroma.Config.get(Pleroma.Uploaders.Swift)
    username = Keyword.fetch!(settings, :username)
    password = Keyword.fetch!(settings, :password)
    tenant_id = Keyword.fetch!(settings, :tenant_id)
    case post(
           "/tokens",
           make_auth_body(username, password, tenant_id),
           ["Content-Type": "application/json"],
           hackney: [:insecure]
         ) do
      {:ok, %Tesla.Env{status: 200, body: body}} ->
        body["access"]["token"]["id"]
      {:ok, %Tesla.Env{status: _}} ->
        ""
    end
  end
  def make_auth_body(username, password, tenant) do
    Jason.encode!(%{
      :auth => %{
        :passwordCredentials => %{
          :username => username,
          :password => password
        },
        :tenantId => tenant
      }
    })
  end
 end
--- a/lib/pleroma/uploaders/swift/swift.ex
+++ b/lib/pleroma/uploaders/swift/swift.ex
@ -1,29 +0,0 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Uploaders.Swift.Client do
  use HTTPoison.Base
  def process_url(url) do
    Enum.join(
      [Pleroma.Config.get!([Pleroma.Uploaders.Swift, :storage_url]), url],
      "/"
    )
  end
  def upload_file(filename, body, content_type) do
    token = Pleroma.Uploaders.Swift.Keystone.get_token()
    case put("#{filename}", body, "X-Auth-Token": token, "Content-Type": content_type) do
      {:ok, %Tesla.Env{status: 201}} ->
        {:ok, {:file, filename}}
      {:ok, %Tesla.Env{status: 401}} ->
        {:error, "Unauthorized, Bad Token"}
      {:error, _} ->
        {:error, "Swift Upload Error"}
    end
  end
 end
--- a/lib/pleroma/uploaders/swift/uploader.ex
+++ b/lib/pleroma/uploaders/swift/uploader.ex
@ -1,19 +0,0 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Uploaders.Swift do
  @behaviour Pleroma.Uploaders.Uploader
  def get_file(name) do
    {:ok, {:url, Path.join([Pleroma.Config.get!([__MODULE__, :object_url]), name])}}
  end
  def put_file(upload) do
    Pleroma.Uploaders.Swift.Client.upload_file(
      upload.path,
      File.read!(upload.tmpfile),
      upload.content_type
    )
  end
 end
--- a/lib/pleroma/uploaders/uploader.ex
+++ b/lib/pleroma/uploaders/uploader.ex
@ -3,6 +3,8 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Uploaders.Uploader do
  import Pleroma.Web.Gettext
  @moduledoc """
  Defines the contract to put and get an uploaded file to any backend.
  """
@ -66,7 +68,14 @@ defmodule Pleroma.Uploaders.Uploader do
            {:error, error}
        end
    after
-      30_000 -> {:error, "Uploader callback timeout"}
+      callback_timeout() -> {:error, dgettext("errors", "Uploader callback timeout")}
    end
  end
  defp callback_timeout do
    case Mix.env() do
      :test -> 1_000
      _ -> 30_000
    end
  end
 end
--- a/lib/pleroma/user.ex
+++ b/lib/pleroma/user.ex
@ -52,10 +52,12 @@ defmodule Pleroma.User do
    field(:avatar, :map)
    field(:local, :boolean, default: true)
    field(:follower_address, :string)
    field(:following_address, :string)
    field(:search_rank, :float, virtual: true)
    field(:search_type, :integer, virtual: true)
    field(:tags, {:array, :string}, default: [])
    field(:last_refreshed_at, :naive_datetime_usec)
    field(:last_digest_emailed_at, :naive_datetime)
    has_many(:notifications, Notification)
    has_many(:registrations, Registration)
    embeds_one(:info, User.Info)
@ -107,17 +109,34 @@ defmodule Pleroma.User do
  def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
  def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
-  def user_info(%User{} = user) do
+  @spec ap_following(User.t()) :: Sring.t()
  def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
  def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
  def user_info(%User{} = user, args \\ %{}) do
    following_count =
      if args[:following_count],
        do: args[:following_count],
        else: user.info.following_count || following_count(user)
    follower_count =
      if args[:follower_count], do: args[:follower_count], else: user.info.follower_count
    %{
      following_count: following_count(user),
      note_count: user.info.note_count,
      follower_count: user.info.follower_count,
      locked: user.info.locked,
      confirmation_pending: user.info.confirmation_pending,
      default_scope: user.info.default_scope
    }
    |> Map.put(:following_count, following_count)
    |> Map.put(:follower_count, follower_count)
  end
  def set_info_cache(user, args) do
    Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user, args))
  end
  @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
  def restrict_deactivated(query) do
    from(u in query,
      where: not fragment("? \\? 'deactivated' AND ?->'deactivated' @> 'true'", u.info, u.info)
@ -152,9 +171,10 @@ defmodule Pleroma.User do
    if changes.valid? do
      case info_cng.changes[:source_data] do
-        %{"followers" => followers} ->
+        %{"followers" => followers, "following" => following} ->
          changes
          |> put_change(:follower_address, followers)
          |> put_change(:following_address, following)
        _ ->
          followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})
@ -186,7 +206,14 @@ defmodule Pleroma.User do
      |> User.Info.user_upgrade(params[:info])
    struct
-    |> cast(params, [:bio, :name, :follower_address, :avatar, :last_refreshed_at])
+    |> cast(params, [
      :bio,
      :name,
      :follower_address,
      :following_address,
      :avatar,
      :last_refreshed_at
    ])
    |> unique_constraint(:nickname)
    |> validate_format(:nickname, local_nickname_regex())
    |> validate_length(:bio, max: 5000)
@ -202,6 +229,7 @@ defmodule Pleroma.User do
    |> put_password_hash
  end
  @spec reset_password(User.t(), map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
  def reset_password(%User{id: user_id} = user, data) do
    multi =
      Multi.new()
@ -306,6 +334,7 @@ defmodule Pleroma.User do
  def needs_update?(_), do: true
  @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
  def maybe_direct_follow(%User{} = follower, %User{local: true, info: %{locked: true}}) do
    {:ok, follower}
  end
@ -380,6 +409,8 @@ defmodule Pleroma.User do
        {1, [follower]} = Repo.update_all(q, [])
        follower = maybe_update_following_count(follower)
        {:ok, _} = update_follower_count(followed)
        set_cache(follower)
@ -399,6 +430,8 @@ defmodule Pleroma.User do
      {1, [follower]} = Repo.update_all(q, [])
      follower = maybe_update_following_count(follower)
      {:ok, followed} = update_follower_count(followed)
      set_cache(follower)
@ -447,7 +480,7 @@ defmodule Pleroma.User do
  end
  def update_and_set_cache(changeset) do
-    with {:ok, user} <- Repo.update(changeset) do
+    with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
      set_cache(user)
    else
      e -> e
@ -562,12 +595,23 @@ defmodule Pleroma.User do
  @spec get_followers_query(User.t()) :: Ecto.Query.t()
  def get_followers_query(user), do: get_followers_query(user, nil)
  @spec get_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
  def get_followers(user, page \\ nil) do
    q = get_followers_query(user, page)
    {:ok, Repo.all(q)}
  end
  @spec get_external_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
  def get_external_followers(user, page \\ nil) do
    q =
      user
      |> get_followers_query(page)
      |> User.Query.build(%{external: true})
    {:ok, Repo.all(q)}
  end
  def get_followers_ids(user, page \\ nil) do
    q = get_followers_query(user, page)
@ -672,7 +716,35 @@ defmodule Pleroma.User do
    |> update_and_set_cache()
  end
  def maybe_fetch_follow_information(user) do
    with {:ok, user} <- fetch_follow_information(user) do
      user
    else
      e ->
        Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
        user
    end
  end
  def fetch_follow_information(user) do
    with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
      info_cng = User.Info.follow_information_update(user.info, info)
      changeset =
        user
        |> change()
        |> put_embed(:info, info_cng)
      update_and_set_cache(changeset)
    else
      {:error, _} = e -> e
      e -> {:error, e}
    end
  end
  def update_follower_count(%User{} = user) do
    if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
      follower_count_query =
        User.Query.build(%{followers: user, deactivated: false})
        |> select([u], %{count: count(u.id)})
@ -696,7 +768,20 @@ defmodule Pleroma.User do
        {1, [user]} -> set_cache(user)
        _ -> {:error, user}
      end
    else
      {:ok, maybe_fetch_follow_information(user)}
    end
  end
  def maybe_update_following_count(%User{local: false} = user) do
    if Pleroma.Config.get([:instance, :external_user_synchronization]) do
      {:ok, maybe_fetch_follow_information(user)}
    else
      user
    end
  end
  def maybe_update_following_count(user), do: user
  def remove_duplicated_following(%User{following: following} = user) do
    uniq_following = Enum.uniq(following)
@ -725,10 +810,13 @@ defmodule Pleroma.User do
    |> Repo.all()
  end
-  def mute(muter, %User{ap_id: ap_id}) do
+  @spec mute(User.t(), User.t(), boolean()) :: {:ok, User.t()} | {:error, String.t()}
  def mute(muter, %User{ap_id: ap_id}, notifications? \\ true) do
    info = muter.info
    info_cng =
-      muter.info
+      User.Info.add_to_mutes(info, ap_id)
-      |> User.Info.add_to_mutes(ap_id)
+      |> User.Info.add_to_muted_notifications(info, ap_id, notifications?)
    cng =
      change(muter)
@ -738,9 +826,11 @@ defmodule Pleroma.User do
  end
  def unmute(muter, %{ap_id: ap_id}) do
    info = muter.info
    info_cng =
-      muter.info
+      User.Info.remove_from_mutes(info, ap_id)
-      |> User.Info.remove_from_mutes(ap_id)
+      |> User.Info.remove_from_muted_notifications(info, ap_id)
    cng =
      change(muter)
@ -836,14 +926,32 @@ defmodule Pleroma.User do
  def mutes?(nil, _), do: false
  def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)
-  def blocks?(%User{info: info} = _user, %{ap_id: ap_id}) do
+  @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
-    blocks = info.blocks
+  def muted_notifications?(nil, _), do: false
    domain_blocks = info.domain_blocks
    %{host: host} = URI.parse(ap_id)
-    Enum.member?(blocks, ap_id) || Enum.any?(domain_blocks, &(&1 == host))
+  def muted_notifications?(user, %{ap_id: ap_id}),
    do: Enum.member?(user.info.muted_notifications, ap_id)
  def blocks?(%User{} = user, %User{} = target) do
    blocks_ap_id?(user, target) || blocks_domain?(user, target)
  end
  def blocks?(nil, _), do: false
  def blocks_ap_id?(%User{} = user, %User{} = target) do
    Enum.member?(user.info.blocks, target.ap_id)
  end
  def blocks_ap_id?(_, _), do: false
  def blocks_domain?(%User{} = user, %User{} = target) do
    domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.info.domain_blocks)
    %{host: host} = URI.parse(target.ap_id)
    Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
  end
  def blocks_domain?(_, _), do: false
  def subscribed_to?(user, %{ap_id: ap_id}) do
    with %User{} = target <- get_cached_by_ap_id(ap_id) do
      Enum.member?(target.info.subscribers, user.ap_id)
@ -927,6 +1035,8 @@ defmodule Pleroma.User do
  @spec perform(atom(), User.t()) :: {:ok, User.t()}
  def perform(:delete, %User{} = user) do
    {:ok, _user} = ActivityPub.delete(user)
    # Remove all relationships
    {:ok, followers} = User.get_followers(user)
@ -943,8 +1053,8 @@ defmodule Pleroma.User do
    end)
    delete_user_activities(user)
-
+    invalidate_cache(user)
-    {:ok, _user} = Repo.delete(user)
+    Repo.delete(user)
  end
  @spec perform(atom(), User.t()) :: {:ok, User.t()}
@ -1000,6 +1110,34 @@ defmodule Pleroma.User do
    )
  end
  @spec external_users_query() :: Ecto.Query.t()
  def external_users_query do
    User.Query.build(%{
      external: true,
      active: true,
      order_by: :id
    })
  end
  @spec external_users(keyword()) :: [User.t()]
  def external_users(opts \\ []) do
    query =
      external_users_query()
      |> select([u], struct(u, [:id, :ap_id, :info]))
    query =
      if opts[:max_id],
        do: where(query, [u], u.id > ^opts[:max_id]),
        else: query
    query =
      if opts[:limit],
        do: limit(query, ^opts[:limit]),
        else: query
    Repo.all(query)
  end
  def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers),
    do:
      PleromaJobQueue.enqueue(:background, __MODULE__, [
@ -1092,19 +1230,18 @@ defmodule Pleroma.User do
    end
  end
-  def get_or_create_instance_user do
+  @doc "Creates an internal service actor by URI if missing.  Optionally takes nickname for addressing."
-    relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
+  def get_or_create_service_actor_by_ap_id(uri, nickname \\ nil) do
-
+    if user = get_cached_by_ap_id(uri) do
    if user = get_cached_by_ap_id(relay_uri) do
      user
    else
      changes =
        %User{info: %User.Info{}}
        |> cast(%{}, [:ap_id, :nickname, :local])
-        |> put_change(:ap_id, relay_uri)
+        |> put_change(:ap_id, uri)
-        |> put_change(:nickname, nil)
+        |> put_change(:nickname, nickname)
        |> put_change(:local, true)
-        |> put_change(:follower_address, relay_uri <> "/followers")
+        |> put_change(:follower_address, uri <> "/followers")
      {:ok, user} = Repo.insert(changes)
      user
@ -1125,10 +1262,12 @@ defmodule Pleroma.User do
  end
  # OStatus Magic Key
-  def public_key_from_info(%{magic_key: magic_key}) do
+  def public_key_from_info(%{magic_key: magic_key}) when not is_nil(magic_key) do
    {:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
  end
  def public_key_from_info(_), do: {:error, "not found key"}
  def get_public_key_for_ap_id(ap_id) do
    with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
         {:ok, public_key} <- public_key_from_info(user.info) do
@ -1145,7 +1284,7 @@ defmodule Pleroma.User do
    data
    |> Map.put(:name, blank?(data[:name]) || data[:nickname])
    |> remote_user_creation()
-    |> Repo.insert(on_conflict: :replace_all, conflict_target: :nickname)
+    |> Repo.insert(on_conflict: :replace_all_except_primary_key, conflict_target: :nickname)
    |> set_cache()
  end
@ -1281,6 +1420,80 @@ defmodule Pleroma.User do
    target.ap_id not in user.info.muted_reblogs
  end
  @doc """
  The function returns a query to get users with no activity for given interval of days.
  Inactive users are those who didn't read any notification, or had any activity where
  the user is the activity's actor, during `inactivity_threshold` days.
  Deactivated users will not appear in this list.
  ## Examples
      iex> Pleroma.User.list_inactive_users()
      %Ecto.Query{}
  """
  @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
  def list_inactive_users_query(inactivity_threshold \\ 7) do
    negative_inactivity_threshold = -inactivity_threshold
    now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
    # Subqueries are not supported in `where` clauses, join gets too complicated.
    has_read_notifications =
      from(n in Pleroma.Notification,
        where: n.seen == true,
        group_by: n.id,
        having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
        select: n.user_id
      )
      |> Pleroma.Repo.all()
    from(u in Pleroma.User,
      left_join: a in Pleroma.Activity,
      on: u.ap_id == a.actor,
      where: not is_nil(u.nickname),
      where: fragment("not (?->'deactivated' @> 'true')", u.info),
      where: u.id not in ^has_read_notifications,
      group_by: u.id,
      having:
        max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
          is_nil(max(a.inserted_at))
    )
  end
  @doc """
  Enable or disable email notifications for user
  ## Examples
      iex> Pleroma.User.switch_email_notifications(Pleroma.User{info: %{email_notifications: %{"digest" => false}}}, "digest", true)
      Pleroma.User{info: %{email_notifications: %{"digest" => true}}}
      iex> Pleroma.User.switch_email_notifications(Pleroma.User{info: %{email_notifications: %{"digest" => true}}}, "digest", false)
      Pleroma.User{info: %{email_notifications: %{"digest" => false}}}
  """
  @spec switch_email_notifications(t(), String.t(), boolean()) ::
          {:ok, t()} | {:error, Ecto.Changeset.t()}
  def switch_email_notifications(user, type, status) do
    info = Pleroma.User.Info.update_email_notifications(user.info, %{type => status})
    change(user)
    |> put_embed(:info, info)
    |> update_and_set_cache()
  end
  @doc """
  Set `last_digest_emailed_at` value for the user to current time
  """
  @spec touch_last_digest_emailed_at(t()) :: t()
  def touch_last_digest_emailed_at(user) do
    now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
    {:ok, updated_user} =
      user
      |> change(%{last_digest_emailed_at: now})
      |> update_and_set_cache()
    updated_user
  end
  @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
  def toggle_confirmation(%User{} = user) do
    need_confirmation? = !user.info.confirmation_pending
@ -1314,23 +1527,16 @@ defmodule Pleroma.User do
    }
  end
-  def ensure_keys_present(user) do
+  def ensure_keys_present(%User{info: info} = user) do
    info = user.info
    if info.keys do
      {:ok, user}
    else
      {:ok, pem} = Keys.generate_rsa_pem()
-      info_cng =
+      user
-        info
+      |> Ecto.Changeset.change()
-        |> User.Info.set_keys(pem)
+      |> Ecto.Changeset.put_embed(:info, User.Info.set_keys(info, pem))
-
+      |> update_and_set_cache()
      cng =
        Ecto.Changeset.change(user)
        |> Ecto.Changeset.put_embed(:info, info_cng)
      update_and_set_cache(cng)
    end
  end
@ -1351,4 +1557,8 @@ defmodule Pleroma.User do
  end
  defp put_password_hash(changeset), do: changeset
  def is_internal_user?(%User{nickname: nil}), do: true
  def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
  def is_internal_user?(_), do: false
 end
--- a/lib/pleroma/user/info.ex
+++ b/lib/pleroma/user/info.ex
@ -16,6 +16,8 @@ defmodule Pleroma.User.Info do
    field(:source_data, :map, default: %{})
    field(:note_count, :integer, default: 0)
    field(:follower_count, :integer, default: 0)
    # Should be filled in only for remote users
    field(:following_count, :integer, default: nil)
    field(:locked, :boolean, default: false)
    field(:confirmation_pending, :boolean, default: false)
    field(:confirmation_token, :string, default: nil)
@ -24,6 +26,7 @@ defmodule Pleroma.User.Info do
    field(:domain_blocks, {:array, :string}, default: [])
    field(:mutes, {:array, :string}, default: [])
    field(:muted_reblogs, {:array, :string}, default: [])
    field(:muted_notifications, {:array, :string}, default: [])
    field(:subscribers, {:array, :string}, default: [])
    field(:deactivated, :boolean, default: false)
    field(:no_rich_text, :boolean, default: false)
@ -42,6 +45,7 @@ defmodule Pleroma.User.Info do
    field(:hide_follows, :boolean, default: false)
    field(:hide_favorites, :boolean, default: true)
    field(:pinned_activities, {:array, :string}, default: [])
    field(:email_notifications, :map, default: %{"digest" => false})
    field(:mascot, :map, default: nil)
    field(:emoji, {:array, :map}, default: [])
    field(:pleroma_settings_store, :map, default: %{})
@ -92,6 +96,30 @@ defmodule Pleroma.User.Info do
    |> validate_required([:notification_settings])
  end
  @doc """
  Update email notifications in the given User.Info struct.
  Examples:
      iex> update_email_notifications(%Pleroma.User.Info{email_notifications: %{"digest" => false}}, %{"digest" => true})
      %Pleroma.User.Info{email_notifications: %{"digest" => true}}
  """
  @spec update_email_notifications(t(), map()) :: Ecto.Changeset.t()
  def update_email_notifications(info, settings) do
    email_notifications =
      info.email_notifications
      |> Map.merge(settings)
      |> Map.take(["digest"])
    params = %{email_notifications: email_notifications}
    fields = [:email_notifications]
    info
    |> cast(params, fields)
    |> validate_required(fields)
  end
  def add_to_note_count(info, number) do
    set_note_count(info, info.note_count + number)
  end
@ -120,6 +148,16 @@ defmodule Pleroma.User.Info do
    |> validate_required([:mutes])
  end
  @spec set_notification_mutes(Changeset.t(), [String.t()], boolean()) :: Changeset.t()
  def set_notification_mutes(changeset, muted_notifications, notifications?) do
    if notifications? do
      put_change(changeset, :muted_notifications, muted_notifications)
      |> validate_required([:muted_notifications])
    else
      changeset
    end
  end
  def set_blocks(info, blocks) do
    params = %{blocks: blocks}
@ -136,14 +174,31 @@ defmodule Pleroma.User.Info do
    |> validate_required([:subscribers])
  end
  @spec add_to_mutes(Info.t(), String.t()) :: Changeset.t()
  def add_to_mutes(info, muted) do
    set_mutes(info, Enum.uniq([muted | info.mutes]))
  end
  @spec add_to_muted_notifications(Changeset.t(), Info.t(), String.t(), boolean()) ::
          Changeset.t()
  def add_to_muted_notifications(changeset, info, muted, notifications?) do
    set_notification_mutes(
      changeset,
      Enum.uniq([muted | info.muted_notifications]),
      notifications?
    )
  end
  @spec remove_from_mutes(Info.t(), String.t()) :: Changeset.t()
  def remove_from_mutes(info, muted) do
    set_mutes(info, List.delete(info.mutes, muted))
  end
  @spec remove_from_muted_notifications(Changeset.t(), Info.t(), String.t()) :: Changeset.t()
  def remove_from_muted_notifications(changeset, info, muted) do
    set_notification_mutes(changeset, List.delete(info.muted_notifications, muted), true)
  end
  def add_to_block(info, blocked) do
    set_blocks(info, Enum.uniq([blocked | info.blocks]))
  end
@ -195,7 +250,11 @@ defmodule Pleroma.User.Info do
      :uri,
      :hub,
      :topic,
-      :salmon
+      :salmon,
      :hide_followers,
      :hide_follows,
      :follower_count,
      :following_count
    ])
  end
@ -206,7 +265,11 @@ defmodule Pleroma.User.Info do
      :source_data,
      :banner,
      :locked,
-      :magic_key
+      :magic_key,
      :follower_count,
      :following_count,
      :hide_follows,
      :hide_followers
    ])
  end
@ -320,4 +383,14 @@ defmodule Pleroma.User.Info do
    cast(info, params, [:muted_reblogs])
  end
  def follow_information_update(info, params) do
    info
    |> cast(params, [
      :hide_followers,
      :hide_follows,
      :follower_count,
      :following_count
    ])
  end
 end
--- a/lib/pleroma/user/query.ex
+++ b/lib/pleroma/user/query.ex
@ -7,7 +7,7 @@ defmodule Pleroma.User.Query do
  User query builder module. Builds query from new query or another user query.
    ## Example:
-        query = Pleroma.User.Query(%{nickname: "nickname"})
+        query = Pleroma.User.Query.build(%{nickname: "nickname"})
        another_query = Pleroma.User.Query.build(query, %{email: "email@example.com"})
        Pleroma.Repo.all(query)
        Pleroma.Repo.all(another_query)
@ -47,7 +47,10 @@ defmodule Pleroma.User.Query do
            friends: User.t(),
            recipients_from_activity: [String.t()],
            nickname: [String.t()],
-            ap_id: [String.t()]
+            ap_id: [String.t()],
            order_by: term(),
            select: term(),
            limit: pos_integer()
          }
          | %{}
@ -141,6 +144,18 @@ defmodule Pleroma.User.Query do
    where(query, [u], u.ap_id in ^to or fragment("? && ?", u.following, ^to))
  end
  defp compose_query({:order_by, key}, query) do
    order_by(query, [u], field(u, ^key))
  end
  defp compose_query({:select, keys}, query) do
    select(query, [u], ^keys)
  end
  defp compose_query({:limit, limit}, query) do
    limit(query, ^limit)
  end
  defp compose_query(_unsupported_param, query), do: query
  defp prepare_tag_criteria(tag, query) do
--- a/lib/pleroma/user/search.ex
+++ b/lib/pleroma/user/search.ex
@ -3,6 +3,7 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.User.Search do
  alias Pleroma.Pagination
  alias Pleroma.Repo
  alias Pleroma.User
  import Ecto.Query
@ -18,8 +19,7 @@ defmodule Pleroma.User.Search do
    for_user = Keyword.get(opts, :for_user)
-    # Strip the beginning @ off if there is a query
+    query_string = format_query(query_string)
    query_string = String.trim_leading(query_string, "@")
    maybe_resolve(resolve, for_user, query_string)
@ -33,13 +33,24 @@ defmodule Pleroma.User.Search do
        query_string
        |> search_query(for_user, following)
-        |> paginate(result_limit, offset)
+        |> Pagination.fetch_paginated(%{"offset" => offset, "limit" => result_limit}, :offset)
        |> Repo.all()
      end)
    results
  end
  defp format_query(query_string) do
    # Strip the beginning @ off if there is a query
    query_string = String.trim_leading(query_string, "@")
    with [name, domain] <- String.split(query_string, "@"),
         formatted_domain <- String.replace(domain, ~r/[!-\-|@|[-`|{-~|\/|:|\s]+/, "") do
      name <> "@" <> to_string(:idna.encode(formatted_domain))
    else
      _ -> query_string
    end
  end
  defp search_query(query_string, for_user, following) do
    for_user
    |> base_query(following)
@ -76,10 +87,6 @@ defmodule Pleroma.User.Search do
  defp filter_blocked_domains(query, _), do: query
  defp paginate(query, limit, offset) do
    from(q in query, limit: ^limit, offset: ^offset)
  end
  defp union_subqueries({fts_subquery, trigram_subquery}) do
    from(s in trigram_subquery, union_all: ^fts_subquery)
  end
@ -150,8 +157,8 @@ defmodule Pleroma.User.Search do
  @spec fts_search_subquery(User.t() | Ecto.Query.t(), String.t()) :: Ecto.Query.t()
  defp fts_search_subquery(query, term) do
    processed_query =
-      term
+      String.trim_trailing(term, "@" <> local_domain())
-      |> String.replace(~r/\W+/, " ")
+      |> String.replace(~r/[!-\/|@|[-`|{-~|:-?]+/, " ")
      |> String.trim()
      |> String.split()
      |> Enum.map(&(&1 <> ":*"))
@ -192,6 +199,8 @@ defmodule Pleroma.User.Search do
  @spec trigram_search_subquery(User.t() | Ecto.Query.t(), String.t()) :: Ecto.Query.t()
  defp trigram_search_subquery(query, term) do
    term = String.trim_trailing(term, "@" <> local_domain())
    from(
      u in query,
      select_merge: %{
@ -209,4 +218,6 @@ defmodule Pleroma.User.Search do
    )
    |> User.restrict_deactivated()
  end
  defp local_domain, do: Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])
 end
--- a/lib/pleroma/user/welcome_message.ex
+++ b/lib/pleroma/user/welcome_message.ex
@ -1,3 +1,7 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.User.WelcomeMessage do
  alias Pleroma.User
  alias Pleroma.Web.CommonAPI
--- a/lib/pleroma/user_invite_token.ex
+++ b/lib/pleroma/user_invite_token.ex
@ -74,7 +74,7 @@ defmodule Pleroma.UserInviteToken do
  @spec find_by_token(token()) :: {:ok, UserInviteToken.t()} | nil
  def find_by_token(token) do
-    with invite <- Repo.get_by(UserInviteToken, token: token) do
+    with %UserInviteToken{} = invite <- Repo.get_by(UserInviteToken, token: token) do
      {:ok, invite}
    end
  end
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@ -8,6 +8,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  alias Pleroma.Conversation
  alias Pleroma.Notification
  alias Pleroma.Object
  alias Pleroma.Object.Containment
  alias Pleroma.Object.Fetcher
  alias Pleroma.Pagination
  alias Pleroma.Repo
@ -22,23 +23,21 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  import Pleroma.Web.ActivityPub.Visibility
  require Logger
  require Pleroma.Constants
  # For Announce activities, we filter the recipients based on following status for any actors
  # that match actual users.  See issue #164 for more information about why this is necessary.
  defp get_recipients(%{"type" => "Announce"} = data) do
-    to = data["to"] || []
+    to = Map.get(data, "to", [])
-    cc = data["cc"] || []
+    cc = Map.get(data, "cc", [])
    bcc = Map.get(data, "bcc", [])
    actor = User.get_cached_by_ap_id(data["actor"])
    recipients =
-      (to ++ cc)
+      Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
      |> Enum.filter(fn recipient ->
        case User.get_cached_by_ap_id(recipient) do
-          nil ->
+          nil -> true
-            true
+          user -> User.following?(user, actor)
          user ->
            User.following?(user, actor)
        end
      end)
@ -46,17 +45,19 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  end
  defp get_recipients(%{"type" => "Create"} = data) do
-    to = data["to"] || []
+    to = Map.get(data, "to", [])
-    cc = data["cc"] || []
+    cc = Map.get(data, "cc", [])
-    actor = data["actor"] || []
+    bcc = Map.get(data, "bcc", [])
-    recipients = (to ++ cc ++ [actor]) |> Enum.uniq()
+    actor = Map.get(data, "actor", [])
    recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
    {recipients, to, cc}
  end
  defp get_recipients(data) do
-    to = data["to"] || []
+    to = Map.get(data, "to", [])
-    cc = data["cc"] || []
+    cc = Map.get(data, "cc", [])
-    recipients = to ++ cc
+    bcc = Map.get(data, "bcc", [])
    recipients = Enum.concat([to, cc, bcc])
    {recipients, to, cc}
  end
@ -126,6 +127,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
         {:ok, map} <- MRF.filter(map),
         {recipients, _, _} = get_recipients(map),
         {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
         :ok <- Containment.contain_child(map),
         {:ok, map, object} <- insert_full_object(map) do
      {:ok, activity} =
        Repo.insert(%Activity{
@ -206,8 +208,6 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  def stream_out_participations(_, _), do: :noop
  def stream_out(activity) do
    public = "https://www.w3.org/ns/activitystreams#Public"
    if activity.data["type"] in ["Create", "Announce", "Delete"] do
      object = Object.normalize(activity)
      # Do not stream out poll replies
@ -215,7 +215,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
        Pleroma.Web.Streamer.stream("user", activity)
        Pleroma.Web.Streamer.stream("list", activity)
-        if Enum.member?(activity.data["to"], public) do
+        if get_visibility(activity) == "public" do
          Pleroma.Web.Streamer.stream("public", activity)
          if activity.local do
@ -237,12 +237,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
            end
          end
        else
-          # TODO: Write test, replace with visibility test
+          if get_visibility(activity) == "direct",
          if !Enum.member?(activity.data["cc"] || [], public) &&
               !Enum.member?(
                 activity.data["to"],
                 User.get_cached_by_ap_id(activity.data["actor"]).follower_address
               ),
            do: Pleroma.Web.Streamer.stream("direct", activity)
        end
      end
@ -272,6 +267,9 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
    else
      {:fake, true, activity} ->
        {:ok, activity}
      {:error, message} ->
        {:error, message}
    end
  end
@ -405,6 +403,19 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
    end
  end
  def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
    with data <- %{
           "to" => [follower_address],
           "type" => "Delete",
           "actor" => ap_id,
           "object" => %{"type" => "Person", "id" => ap_id}
         },
         {:ok, activity} <- insert(data, true, true),
         :ok <- maybe_federate(activity) do
      {:ok, user}
    end
  end
  def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
    user = User.get_cached_by_ap_id(actor)
    to = (object.data["to"] || []) ++ (object.data["cc"] || [])
@ -500,7 +511,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  end
  defp fetch_activities_for_context_query(context, opts) do
-    public = ["https://www.w3.org/ns/activitystreams#Public"]
+    public = [Pleroma.Constants.as_public()]
    recipients =
      if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
@ -541,7 +552,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  end
  def fetch_public_activities(opts \\ %{}) do
-    q = fetch_activities_query(["https://www.w3.org/ns/activitystreams#Public"], opts)
+    q = fetch_activities_query([Pleroma.Constants.as_public()], opts)
    q
    |> restrict_unlisted()
@ -617,17 +628,27 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
      |> Map.put("pinned_activity_ids", user.info.pinned_activities)
    recipients =
-      if reading_user do
+      user_activities_recipients(%{
-        ["https://www.w3.org/ns/activitystreams#Public"] ++
+        "godmode" => params["godmode"],
-          [reading_user.ap_id | reading_user.following]
+        "reading_user" => reading_user
-      else
+      })
        ["https://www.w3.org/ns/activitystreams#Public"]
      end
    fetch_activities(recipients, params)
    |> Enum.reverse()
  end
  defp user_activities_recipients(%{"godmode" => true}) do
    []
  end
  defp user_activities_recipients(%{"reading_user" => reading_user}) do
    if reading_user do
      [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
    else
      [Pleroma.Constants.as_public()]
    end
  end
  defp restrict_since(query, %{"since_id" => ""}), do: query
  defp restrict_since(query, %{"since_id" => since_id}) do
@ -728,8 +749,8 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
    from(
-      activity in query,
+      [_activity, object] in query,
-      where: fragment(~s(? <@ (? #> '{"object","likes"}'\)), ^ap_id, activity.data)
+      where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
    )
  end
@ -809,7 +830,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
        fragment(
          "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
          activity.data,
-          ^["https://www.w3.org/ns/activitystreams#Public"]
+          ^[Pleroma.Constants.as_public()]
        )
    )
  end
@ -883,13 +904,11 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  defp maybe_order(query, _), do: query
  def fetch_activities_query(recipients, opts \\ %{}) do
    base_query = from(activity in Activity)
    config = %{
      skip_thread_containment: Config.get([:instance, :skip_thread_containment])
    }
-    base_query
+    Activity
    |> maybe_preload_objects(opts)
    |> maybe_preload_bookmarks(opts)
    |> maybe_set_thread_muted_field(opts)
@ -918,17 +937,37 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  end
  def fetch_activities(recipients, opts \\ %{}) do
-    fetch_activities_query(recipients, opts)
+    list_memberships = Pleroma.List.memberships(opts["user"])
    fetch_activities_query(recipients ++ list_memberships, opts)
    |> Pagination.fetch_paginated(opts)
    |> Enum.reverse()
    |> maybe_update_cc(list_memberships, opts["user"])
  end
  defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
       when is_list(list_memberships) and length(list_memberships) > 0 do
    Enum.map(activities, fn
      %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
        if Enum.any?(bcc, &(&1 in list_memberships)) do
          update_in(activity.data["cc"], &[user_ap_id | &1])
        else
          activity
        end
      activity ->
        activity
    end)
  end
  defp maybe_update_cc(activities, _, _), do: activities
  def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
    from(activity in query,
      where:
        fragment("? && ?", activity.recipients, ^recipients) or
          (fragment("? && ?", activity.recipients, ^recipients_with_public) and
-             "https://www.w3.org/ns/activitystreams#Public" in activity.recipients)
+             ^Pleroma.Constants.as_public() in activity.recipients)
    )
  end
@ -973,14 +1012,15 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
    user_data = %{
      ap_id: data["id"],
      info: %{
-        "ap_enabled" => true,
+        ap_enabled: true,
-        "source_data" => data,
+        source_data: data,
-        "banner" => banner,
+        banner: banner,
-        "locked" => locked
+        locked: locked
      },
      avatar: avatar,
      name: data["name"],
      follower_address: data["followers"],
      following_address: data["following"],
      bio: data["summary"]
    }
@ -999,6 +1039,71 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
    {:ok, user_data}
  end
  def fetch_follow_information_for_user(user) do
    with {:ok, following_data} <-
           Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
         following_count when is_integer(following_count) <- following_data["totalItems"],
         {:ok, hide_follows} <- collection_private(following_data),
         {:ok, followers_data} <-
           Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
         followers_count when is_integer(followers_count) <- followers_data["totalItems"],
         {:ok, hide_followers} <- collection_private(followers_data) do
      {:ok,
       %{
         hide_follows: hide_follows,
         follower_count: followers_count,
         following_count: following_count,
         hide_followers: hide_followers
       }}
    else
      {:error, _} = e ->
        e
      e ->
        {:error, e}
    end
  end
  defp maybe_update_follow_information(data) do
    with {:enabled, true} <-
           {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
         {:ok, info} <- fetch_follow_information_for_user(data) do
      info = Map.merge(data.info, info)
      Map.put(data, :info, info)
    else
      {:enabled, false} ->
        data
      e ->
        Logger.error(
          "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
        )
        data
    end
  end
  defp collection_private(data) do
    if is_map(data["first"]) and
         data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
      {:ok, false}
    else
      with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
             Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
        {:ok, false}
      else
        {:error, {:ok, %{status: code}}} when code in [401, 403] ->
          {:ok, true}
        {:error, _} = e ->
          e
        e ->
          {:error, e}
      end
    end
  end
  def user_data_from_user_object(data) do
    with {:ok, data} <- MRF.filter(data),
         {:ok, data} <- object_to_user_data(data) do
@ -1010,7 +1115,8 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  def fetch_and_prepare_user_from_ap_id(ap_id) do
    with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
-         {:ok, data} <- user_data_from_user_object(data) do
+         {:ok, data} <- user_data_from_user_object(data),
         data <- maybe_update_follow_information(data) do
      {:ok, data}
    else
      e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
@ -10,6 +10,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
  alias Pleroma.Object.Fetcher
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.InternalFetchActor
  alias Pleroma.Web.ActivityPub.ObjectView
  alias Pleroma.Web.ActivityPub.Relay
  alias Pleroma.Web.ActivityPub.Transmogrifier
@ -31,9 +32,8 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
      conn
    else
      conn
-      |> put_status(404)
+      |> render_error(:not_found, "not found")
-      |> json(%{error: "not found"})
+      |> halt()
      |> halt
    end
  end
@ -104,43 +104,57 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
    end
  end
-  def following(conn, %{"nickname" => nickname, "page" => page}) do
+  def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
    with %User{} = user <- User.get_cached_by_nickname(nickname),
-         {:ok, user} <- User.ensure_keys_present(user) do
+         {user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user),
         {:show_follows, true} <-
           {:show_follows, (for_user && for_user == user) || !user.info.hide_follows} do
      {page, _} = Integer.parse(page)
      conn
      |> put_resp_header("content-type", "application/activity+json")
-      |> json(UserView.render("following.json", %{user: user, page: page}))
+      |> json(UserView.render("following.json", %{user: user, page: page, for: for_user}))
-    end
+    else
-  end
+      {:show_follows, _} ->
  def following(conn, %{"nickname" => nickname}) do
    with %User{} = user <- User.get_cached_by_nickname(nickname),
         {:ok, user} <- User.ensure_keys_present(user) do
        conn
        |> put_resp_header("content-type", "application/activity+json")
-      |> json(UserView.render("following.json", %{user: user}))
+        |> send_resp(403, "")
    end
  end
-  def followers(conn, %{"nickname" => nickname, "page" => page}) do
+  def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
    with %User{} = user <- User.get_cached_by_nickname(nickname),
-         {:ok, user} <- User.ensure_keys_present(user) do
+         {user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
      conn
      |> put_resp_header("content-type", "application/activity+json")
      |> json(UserView.render("following.json", %{user: user, for: for_user}))
    end
  end
  def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
    with %User{} = user <- User.get_cached_by_nickname(nickname),
         {user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user),
         {:show_followers, true} <-
           {:show_followers, (for_user && for_user == user) || !user.info.hide_followers} do
      {page, _} = Integer.parse(page)
      conn
      |> put_resp_header("content-type", "application/activity+json")
-      |> json(UserView.render("followers.json", %{user: user, page: page}))
+      |> json(UserView.render("followers.json", %{user: user, page: page, for: for_user}))
    else
      {:show_followers, _} ->
        conn
        |> put_resp_header("content-type", "application/activity+json")
        |> send_resp(403, "")
    end
  end
-  def followers(conn, %{"nickname" => nickname}) do
+  def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
    with %User{} = user <- User.get_cached_by_nickname(nickname),
-         {:ok, user} <- User.ensure_keys_present(user) do
+         {user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
      conn
      |> put_resp_header("content-type", "application/activity+json")
-      |> json(UserView.render("followers.json", %{user: user}))
+      |> json(UserView.render("followers.json", %{user: user, for: for_user}))
    end
  end
@ -190,12 +204,11 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
      Logger.info(inspect(conn.req_headers))
    end
-    json(conn, "error")
+    json(conn, dgettext("errors", "error"))
  end
-  def relay(conn, _params) do
+  defp represent_service_actor(%User{} = user, conn) do
-    with %User{} = user <- Relay.get_actor(),
+    with {:ok, user} <- User.ensure_keys_present(user) do
         {:ok, user} <- User.ensure_keys_present(user) do
      conn
      |> put_resp_header("content-type", "application/activity+json")
      |> json(UserView.render("user.json", %{user: user}))
@ -204,6 +217,18 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
    end
  end
  defp represent_service_actor(nil, _), do: {:error, :not_found}
  def relay(conn, _params) do
    Relay.get_actor()
    |> represent_service_actor(conn)
  end
  def internal_fetch(conn, _params) do
    InternalFetchActor.get_actor()
    |> represent_service_actor(conn)
  end
  def whoami(%{assigns: %{user: %User{} = user}} = conn, _params) do
    conn
    |> put_resp_header("content-type", "application/activity+json")
@ -218,9 +243,15 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
      |> put_resp_header("content-type", "application/activity+json")
      |> json(UserView.render("inbox.json", %{user: user, max_id: params["max_id"]}))
    else
      err =
        dgettext("errors", "can't read inbox of %{nickname} as %{as_nickname}",
          nickname: nickname,
          as_nickname: user.nickname
        )
      conn
      |> put_status(:forbidden)
-      |> json("can't read inbox of #{nickname} as #{user.nickname}")
+      |> json(err)
    end
  end
@ -246,7 +277,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
         {:ok, delete} <- ActivityPub.delete(object) do
      {:ok, delete}
    else
-      _ -> {:error, "Can't delete object"}
+      _ -> {:error, dgettext("errors", "Can't delete object")}
    end
  end
@ -255,12 +286,12 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
         {:ok, activity, _object} <- ActivityPub.like(user, object) do
      {:ok, activity}
    else
-      _ -> {:error, "Can't like object"}
+      _ -> {:error, dgettext("errors", "Can't like object")}
    end
  end
  def handle_user_activity(_, _) do
-    {:error, "Unhandled activity type"}
+    {:error, dgettext("errors", "Unhandled activity type")}
  end
  def update_outbox(
@ -288,22 +319,28 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
          |> json(message)
      end
    else
      err =
        dgettext("errors", "can't update outbox of %{nickname} as %{as_nickname}",
          nickname: nickname,
          as_nickname: user.nickname
        )
      conn
      |> put_status(:forbidden)
-      |> json("can't update outbox of #{nickname} as #{user.nickname}")
+      |> json(err)
    end
  end
  def errors(conn, {:error, :not_found}) do
    conn
-    |> put_status(404)
+    |> put_status(:not_found)
-    |> json("Not found")
+    |> json(dgettext("errors", "Not found"))
  end
  def errors(conn, _e) do
    conn
-    |> put_status(500)
+    |> put_status(:internal_server_error)
-    |> json("error")
+    |> json(dgettext("errors", "error"))
  end
  defp set_requester_reachable(%Plug.Conn{} = conn, _) do
@ -314,4 +351,17 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
    conn
  end
  defp ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
    {:ok, new_user} = User.ensure_keys_present(user)
    for_user =
      if new_user != user and match?(%User{}, for_user) do
        User.get_cached_by_nickname(for_user.nickname)
      else
        for_user
      end
    {new_user, for_user}
  end
 end
--- a/lib/pleroma/web/activity_pub/internal_fetch_actor.ex
+++ b/lib/pleroma/web/activity_pub/internal_fetch_actor.ex
@ -0,0 +1,20 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Pleroma.Web.ActivityPub.InternalFetchActor do
  alias Pleroma.User
  require Logger
  def init do
    # Wait for everything to settle.
    Process.sleep(1000 * 5)
    get_actor()
  end
  def get_actor do
    "#{Pleroma.Web.Endpoint.url()}/internal/fetch"
    |> User.get_or_create_service_actor_by_ap_id("internal.fetch")
  end
 end
--- a/lib/pleroma/web/activity_pub/mrf.ex
+++ b/lib/pleroma/web/activity_pub/mrf.ex
@ -25,4 +25,14 @@ defmodule Pleroma.Web.ActivityPub.MRF do
  defp get_policies(policy) when is_atom(policy), do: [policy]
  defp get_policies(policies) when is_list(policies), do: policies
  defp get_policies(_), do: []
  @spec subdomains_regex([String.t()]) :: [Regex.t()]
  def subdomains_regex(domains) when is_list(domains) do
    for domain <- domains, do: ~r(^#{String.replace(domain, "*.", "(.*\\.)*")}$)i
  end
  @spec subdomain_match?([Regex.t()], String.t()) :: boolean()
  def subdomain_match?(domains, host) do
    Enum.any?(domains, fn domain -> Regex.match?(domain, host) end)
  end
 end
--- a/Show more
+++ b/Show more
		`@ -0,0 +1,2 @@`
							`Ariadne Conill <ariadne@dereferenced.org> <nenolod@dereferenced.org>`
							`Ariadne Conill <ariadne@dereferenced.org> <nenolod@gmail.com>`