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

2019-05-01 18:40:41 +02:00 · 2019-05-01 18:40:41 +02:00 · 45f790becc
commit 45f790becc
parent 4908e0eeee d107919b3d
785 changed files with 7645 additions and 66854 deletions
--- a/.gitignore
+++ b/.gitignore
@ -3,7 +3,6 @@
 /db
 /deps
 /*.ez
 /uploads
 /test/uploads
 /.elixir_ls
 /test/fixtures/test_tmp.txt
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,112 @@
 # Changelog
 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
 - LDAP authentication
 - External OAuth provider authentication
 - A [job queue](https://git.pleroma.social/pleroma/pleroma_job_queue) for federation, emails, web push, etc.
 - [Prometheus](https://prometheus.io/) metrics
 - Support for Mastodon's remote interaction
 - Mix Tasks: `mix pleroma.database remove_embedded_objects`
 - Federation: Support for reports
 - Configuration: `safe_dm_mentions` option
 - Configuration: `link_name` option
 - Configuration: `fetch_initial_posts` option
 - Configuration: `notify_email` option
 - Configuration: Media proxy `whitelist` option
 - Pleroma API: User subscriptions
 - Pleroma API: Healthcheck endpoint
 - Admin API: Endpoints for listing/revoking invite tokens
 - Admin API: Endpoints for making users follow/unfollow each other
 - Mastodon API: [Scheduled statuses](https://docs.joinmastodon.org/api/rest/scheduled-statuses/)
 - Mastodon API: `/api/v1/notifications/destroy_multiple` (glitch-soc extension)
 - Mastodon API: `/api/v1/pleroma/accounts/:id/favourites` (API extension)
 - Mastodon API: [Reports](https://docs.joinmastodon.org/api/rest/reports/)
 - ActivityPub C2S: OAuth endpoints
 - Metadata RelMe provider
 - Emoji packs and emoji pack manager
 ### Changed
 - **Breaking:** Configuration: move from Pleroma.Mailer to Pleroma.Emails.Mailer
 - Enforcement of OAuth scopes
 - Add multiple use/time expiring invite token
 - Restyled OAuth pages to fit with Pleroma's default theme
 - Link/mention/hashtag detection is now handled by [auto_linker](https://git.pleroma.social/pleroma/auto_linker)
 - NodeInfo: Return `safe_dm_mentions` feature flag
 - Federation: Expand the audience of delete activities to all recipients of the deleted object
 - Federation: Removed `inReplyToStatusId` from objects
 - Configuration: Dedupe enabled by default
 - Configuration: Added `extra_cookie_attrs` for setting non-standard cookie attributes. Defaults to ["SameSite=Lax"] so that remote follows work.
 - Pleroma API: Support for emoji tags in `/api/pleroma/emoji` resulting in a breaking API change
 - Timelines: Messages involving people you have blocked will be excluded from the timeline in all cases instead of just repeats.
 - Mastodon API: Support for `exclude_types`, `limit` and `min_id` in `/api/v1/notifications`
 - Mastodon API: Add `languages` and `registrations` to `/api/v1/instance`
 - Mastodon API: Provide plaintext versions of cw/content in the Status entity
 - Mastodon API: Add `pleroma.conversation_id`, `pleroma.in_reply_to_account_acct` fields to the Status entity
 - Mastodon API: Add `pleroma.tags`, `pleroma.relationship{}`, `pleroma.is_moderator`, `pleroma.is_admin`, `pleroma.confirmation_pending`, `pleroma.hide_followers`, `pleroma.hide_follows`, `pleroma.hide_favorites` fields to the User entity
 - Mastodon API: Add `pleroma.show_role`, `pleroma.no_rich_text` fields to the Source subentity
 - Mastodon API: Add support for updating `no_rich_text`, `hide_followers`, `hide_follows`, `hide_favorites`, `show_role` in `PATCH /api/v1/update_credentials`
 - Mastodon API: Add `pleroma.is_seen` to the Notification entity
 - Mastodon API: Add `pleroma.local` to the Status entity
 - Mastodon API: Add `preview` parameter to `POST /api/v1/statuses`
 - Mastodon API: Add `with_muted` parameter to timeline endpoints
 - Mastodon API: Actual reblog hiding instead of a dummy
 - Mastodon API: Remove attachment limit in the Status entity
 - Deps: Updated Cowboy to 2.6
 - Deps: Updated Ecto to 3.0.7
 - Don't ship finmoji by default, they can be installed as an emoji pack
 - Mastodon API: Added support max_id & since_id for bookmark timeline endpoints.
 ### Fixed
 - Followers counter not being updated when a follower is blocked
 - Deactivated users being able to request an access token
 - Limit on request body in rich media/relme parsers being ignored resulting in a possible memory leak
 - proper Twitter Card generation instead of a dummy
 - NodeInfo: Include admins in `staffAccounts`
 - ActivityPub: Crashing when requesting empty local user's outbox
 - Federation: Handling of objects without `summary` property
 - Federation: Add a language tag to activities as required by ActivityStreams 2.0
 - Federation: Do not federate avatar/banner if set to default allowing other servers/clients to use their defaults
 - Federation: Cope with missing or explicitly nulled address lists
 - Federation: Explicitly ensure activities addressed to `as:Public` become addressed to the followers collection
 - Federation: Better cope with actors which do not declare a followers collection and use `as:Public` with these semantics
 - Federation: Follow requests from remote users who have been blocked will be automatically rejected if appropriate
 - MediaProxy: Parse name from content disposition headers even for non-whitelisted types
 - MediaProxy: S3 link encoding
 - Rich Media: Reject any data which cannot be explicitly encoded into JSON
 - Pleroma API: Importing follows from Mastodon 2.8+
 - Twitter API: Exposing default scope, `no_rich_text` of the user to anyone
 - Twitter API: Returning the `role` object in user entity despite `show_role = false`
 - Mastodon API: `/api/v1/favourites` serving only public activities
 - Mastodon API: Reblogs having `in_reply_to_id` - `null` even when they are replies
 - Mastodon API: Streaming API broadcasting wrong activity id
 - Mastodon API: 500 errors when requesting a card for a private conversation
 - Mastodon API: Handling of `reblogs` in `/api/v1/accounts/:id/follow`
 - Mastodon API: Correct `reblogged`, `favourited`, and `bookmarked` values in the reblog status JSON
 - Mastodon API: Exposing default scope of the user to anyone
 ## [0.9.9999] - 2019-04-05
 ### Security
 - Mastodon API: Fix content warnings skipping HTML sanitization
 ## [0.9.999] - 2019-03-13
 Frontend changes only.
 ### Added
 - Added floating action button for posting status on mobile
 ### Changed
 - Changed user-settings icon to a pencil
 ### Fixed
 - Keyboard shortcuts activating when typing a message
 - Gaps when scrolling down on a timeline after showing new
 ## [0.9.99] - 2019-03-08
 ### Changed
 - Update the frontend to the 0.9.99 tag
 ### Fixed
 - Sign the date header in federation to fix Mastodon federation.
 ## [0.9.9] - 2019-02-22
 This is our first stable release.
--- a/7
+++ b/7
@ -39,10 +39,3 @@ does not include the right to compile photos from Unsplash to replicate
 a similar or competing service.
 priv/static/images/city.jpg
 ---
 The files present under the priv/static/finmoji directory are copyright
 Finland <https://finland.fi/emoji/>, and are distributed under the Creative
 Commons Attribution-NonCommercial-NoDerivatives 4.0 International license, you
 should have received a copy of the license file as CC-BY-NC-ND-4.0.
--- a/README.md
+++ b/README.md
@ -1,6 +1,6 @@
 # Pleroma
-**Note**: This readme as well as complete documentation is also availible at <https://docs-develop.pleroma.social>
+**Note**: This readme as well as complete documentation is also available at <https://docs-develop.pleroma.social>
 ## About Pleroma
--- a/config/config.exs
+++ b/config/config.exs
@ -1,3 +1,41 @@
 #                                 .i;;;;i.
 #                               iYcviii;vXY:
 #                             .YXi       .i1c.
 #                            .YC.     .    in7.
 #                           .vc.   ......   ;1c.
 #                           i7,   ..        .;1;
 #                          i7,   .. ...      .Y1i
 #                         ,7v     .6MMM@;     .YX,
 #                        .7;.   ..IMMMMMM1     :t7.
 #                       .;Y.     ;$MMMMMM9.     :tc.
 #                       vY.   .. .nMMM@MMU.      ;1v.
 #                      i7i   ...  .#MM@M@C. .....:71i
 #                     it:   ....   $MMM@9;.,i;;;i,;tti
 #                    :t7.  .....   0MMMWv.,iii:::,,;St.
 #                   .nC.   .....   IMMMQ..,::::::,.,czX.
 #                  .ct:   ....... .ZMMMI..,:::::::,,:76Y.
 #                  c2:   ......,i..Y$M@t..:::::::,,..inZY
 #                 vov   ......:ii..c$MBc..,,,,,,,,,,..iI9i
 #                i9Y   ......iii:..7@MA,..,,,,,,,,,....;AA:
 #               iIS.  ......:ii::..;@MI....,............;Ez.
 #              .I9.  ......:i::::...8M1..................C0z.
 #             .z9;  ......:i::::,.. .i:...................zWX.
 #             vbv  ......,i::::,,.      ................. :AQY
 #            c6Y.  .,...,::::,,..:t0@@QY. ................ :8bi
 #           :6S. ..,,...,:::,,,..EMMMMMMI. ............... .;bZ,
 #          :6o,  .,,,,..:::,,,..i#MMMMMM#v.................  YW2.
 #         .n8i ..,,,,,,,::,,,,.. tMMMMM@C:.................. .1Wn
 #         7Uc. .:::,,,,,::,,,,..   i1t;,..................... .UEi
 #         7C...::::::::::::,,,,..        ....................  vSi.
 #         ;1;...,,::::::,.........       ..................    Yz:
 #          v97,.........                                     .voC.
 #           izAotX7777777777777777777777777777777777777777Y7n92:
 #             .;CoIIIIIUAA666666699999ZZZZZZZZZZZZZZZZZZZZ6ov.
 #
 #                          !!! ATTENTION !!!
 # DO NOT EDIT THIS FILE! THIS FILE CONTAINS THE DEFAULT VALUES FOR THE CON-
 # FIGURATION! EDIT YOUR SECRET FILE (either prod.secret.exs, dev.secret.exs).
 #
 # This file is responsible for configuring your application
 # and its dependencies with the aid of the Mix.Config module.
 #
@ -62,9 +100,9 @@
  shortcode_globs: ["/emoji/custom/**/*.png"],
  groups: [
    # Put groups that have higher priority than defaults here. Example in `docs/config/custom_emoji.md`
-    Finmoji: "/finmoji/128px/*-128.png",
+    Custom: ["/emoji/*.png", "/emoji/**/*.png"]
-    Custom: ["/emoji/*.png", "/emoji/custom/*.png"]
+  ],
-  ]
+  default_manifest: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"
 config :pleroma, :uri_schemes,
  valid_schemes: [
@ -116,7 +154,10 @@
  signing_salt: "CqaoopA2",
  render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
  pubsub: [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2],
-  secure_cookie_flag: true
+  secure_cookie_flag: true,
  extra_cookie_attrs: [
    "SameSite=Lax"
  ]
 # Configures Elixir's Logger
 config :logger, :console,
@ -160,6 +201,7 @@
 config :pleroma, :instance,
  name: "Pleroma",
  email: "example@example.com",
  notify_email: "noreply@example.com",
  description: "A Pleroma instance, an alternative fediverse server",
  limit: 5_000,
  remote_limit: 100_000,
@ -179,9 +221,9 @@
  allowed_post_formats: [
    "text/plain",
    "text/html",
-    "text/markdown"
+    "text/markdown",
    "text/bbcode"
  ],
  finmoji_enabled: true,
  mrf_transparency: true,
  autofollowed_nicknames: [],
  max_pinned_statuses: 1,
@ -189,7 +231,8 @@
  welcome_user_nickname: nil,
  welcome_message: nil,
  max_report_comment_size: 1000,
-  safe_dm_mentions: false
+  safe_dm_mentions: false,
  healthcheck: false
 config :pleroma, :markup,
  # XXX - unfortunately, inline images must be enabled by default right now, because
@ -284,7 +327,8 @@
      follow_redirect: true,
      pool: :media
    ]
-  ]
+  ],
  whitelist: []
 config :pleroma, :chat, enabled: true
@ -295,7 +339,9 @@
  ip: {0, 0, 0, 0},
  port: 9999
-config :pleroma, Pleroma.Web.Metadata, providers: [], unfurl_nsfw: false
+config :pleroma, Pleroma.Web.Metadata,
  providers: [Pleroma.Web.Metadata.Providers.RelMe],
  unfurl_nsfw: false
 config :pleroma, :suggestions,
  enabled: false,
@ -413,7 +459,7 @@
 config :pleroma, :auth, oauth_consumer_strategies: oauth_consumer_strategies
-config :pleroma, Pleroma.Mailer, adapter: Swoosh.Adapters.Sendmail
+config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Sendmail
 config :prometheus, Pleroma.Web.Endpoint.MetricsExporter, path: "/api/pleroma/app_metrics"
--- a/config/dev.exs
+++ b/config/dev.exs
@ -18,7 +18,7 @@
  watchers: [],
  secure_cookie_flag: false
-config :pleroma, Pleroma.Mailer, adapter: Swoosh.Adapters.Local
+config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Local
 # ## SSL Support
 #
--- a/config/test.exs
+++ b/config/test.exs
@ -21,7 +21,11 @@
 config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"
-config :pleroma, Pleroma.Mailer, adapter: Swoosh.Adapters.Test
+config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test
 config :pleroma, :instance,
  email: "admin@example.com",
  notify_email: "noreply@example.com"
 # Configure your database
 config :pleroma, Pleroma.Repo,
--- a/docs/api/admin_api.md
+++ b/docs/api/admin_api.md
@ -200,11 +200,64 @@ Note: Available `:permission_group` is currently moderator and admin. 404 is ret
 ## `/api/pleroma/admin/invite_token`
-### Get a account registeration invite token
+### Get an account registration invite token
 - Methods: `GET`
 - Params:
  - *optional* `invite` => [
    - *optional* `max_use` (integer)
    - *optional* `expires_at` (date string e.g. "2019-04-07")
  ]
 - Response: invite token (base64 string)
 ## `/api/pleroma/admin/invites`
 ### Get a list of generated invites
 - Methods: `GET`
 - Params: none
- Response: invite token (base64 string)
+- Response:
 ```JSON
 {
  "invites": [
    {
      "id": integer,
      "token": string,
      "used": boolean,
      "expires_at": date,
      "uses": integer,
      "max_use": integer,
      "invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)
    },
    ...
  ]
 }
 ```
 ## `/api/pleroma/admin/revoke_invite`
 ### Revoke invite by token
 - Methods: `POST`
 - Params:
  - `token`
 - Response:
 ```JSON
 {
  "id": integer,
  "token": string,
  "used": boolean,
  "expires_at": date,
  "uses": integer,
  "max_use": integer,
  "invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)
 }
 ```
 ## `/api/pleroma/admin/email_invite`
@ -213,7 +266,7 @@ Note: Available `:permission_group` is currently moderator and admin. 404 is ret
 - Methods: `POST`
 - Params:
  - `email`
-  - `name`, optionnal
+  - `name`, optional
 ## `/api/pleroma/admin/password_reset`
--- a/docs/api/differences_in_mastoapi_responses.md
+++ b/docs/api/differences_in_mastoapi_responses.md
@ -20,6 +20,9 @@ Has these additional fields under the `pleroma` object:
 - `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`
 - `spoiler_text`: a map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
 ## Attachments
@ -35,9 +38,24 @@ Has these additional fields under the `pleroma` object:
 - `tags`: Lists an array of tags for the user
 - `relationship{}`: Includes fields as documented for Mastodon API https://docs.joinmastodon.org/api/entities/#relationship
- `is_moderator`: boolean, true if user is a moderator
+- `is_moderator`: boolean, nullable,  true if user is a moderator
- `is_admin`: boolean, true if user is an admin
+- `is_admin`: boolean, nullable, true if user is an admin
 - `confirmation_pending`: boolean, true if a new user account is waiting on email confirmation to be activated
 - `hide_followers`: boolean, true when the user has follower hiding enabled
 - `hide_follows`: boolean, true when the user has follow hiding enabled
 ### Source
 Has these additional fields under the `pleroma` object:
 - `show_role`: boolean, nullable, true when the user wants his role (e.g admin, moderator) to be shown
 - `no_rich_text` - boolean, nullable, true when html tags are stripped from all statuses requested from the API
 ## Account Search
 Behavior has changed:
 - `/api/v1/accounts/search`: Does not require authentication
 ## Notifications
@ -50,3 +68,15 @@ Has these additional fields under the `pleroma` object:
 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.
 ## PATCH `/api/v1/update_credentials`
 Additional parameters can be added to the JSON body/Form data:
 - `no_rich_text` - if true, html tags are stripped from all statuses requested from the API
 - `hide_followers` - if true, user's followers will be hidden
 - `hide_follows` - if true, user's follows will be hidden
 - `hide_favorites` - if true, user's favorites timeline will be hidden
 - `show_role` - if true, user's role (e.g admin, moderator) will be exposed to anyone in the API
 - `default_scope` - the scope returned under `privacy` key in Source subentity
--- a/docs/api/pleroma_api.md
+++ b/docs/api/pleroma_api.md
@ -10,7 +10,29 @@ Request parameters can be passed via [query strings](https://en.wikipedia.org/wi
 * Authentication: not required
 * Params: none
 * Response: JSON
-* Example response: `[{"kalsarikannit_f":{"tags":["Finmoji"],"image_url":"/finmoji/128px/kalsarikannit_f-128.png"}},{"perkele":{"tags":["Finmoji"],"image_url":"/finmoji/128px/perkele-128.png"}},{"blobdab":{"tags":["SomeTag"],"image_url":"/emoji/blobdab.png"}},"happiness":{"tags":["Finmoji"],"image_url":"/finmoji/128px/happiness-128.png"}}]`
+* Example response:
 ```json
 {
  "girlpower": {
    "tags": [
      "Finmoji"
    ],
    "image_url": "/finmoji/128px/girlpower-128.png"
  },
  "education": {
    "tags": [
      "Finmoji"
    ],
    "image_url": "/finmoji/128px/education-128.png"
  },
  "finnishlove": {
    "tags": [
      "Finmoji"
    ],
    "image_url": "/finmoji/128px/finnishlove-128.png"
  }
 }
 ```
 * Note: Same data as Mastodon API’s `/api/v1/custom_emojis` but in a different format
 ## `/api/pleroma/follow_import`
@ -52,10 +74,10 @@ Request parameters can be passed via [query strings](https://en.wikipedia.org/wi
    * `confirm`
    * `captcha_solution`: optional, contains provider-specific captcha solution,
    * `captcha_token`: optional, contains provider-specific captcha token
-    * `token`: invite token required when the registerations aren't public.
+    * `token`: invite token required when the registrations aren't public.
 * Response: JSON. Returns a user object on success, otherwise returns `{"error": "error_msg"}`
 * Example response:
-```
+```json
 {
 	"background_image": null,
 	"cover_photo": "https://pleroma.soykaf.com/images/banner.png",
@ -114,5 +136,137 @@ See [Admin-API](Admin-API.md)
 * Method `POST`
 * Authentication: required
 * Params:
-    * `id`: notifications's id
+    * `id`: notification's id
 * Response: JSON. Returns `{"status": "success"}` if the reading was successful, otherwise returns `{"error": "error_msg"}`
 ## `/api/v1/pleroma/accounts/:id/subscribe`
 ### Subscribe to receive notifications for all statuses posted by a user
 * Method `POST`
 * Authentication: required
 * Params:
    * `id`: account id to subscribe to
 * Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
 * Example response:
 ```json
 {
  "id": "abcdefg",
  "following": true,
  "followed_by": false,
  "blocking": false,
  "muting": false,
  "muting_notifications": false,
  "subscribing": true,
  "requested": false,
  "domain_blocking": false,
  "showing_reblogs": true,
  "endorsed": false
 }
 ```
 ## `/api/v1/pleroma/accounts/:id/unsubscribe`
 ### Unsubscribe to stop receiving notifications from user statuses
 * Method `POST`
 * Authentication: required
 * Params:
    * `id`: account id to unsubscribe from
 * Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
 * Example response:
 ```json
 {
  "id": "abcdefg",
  "following": true,
  "followed_by": false,
  "blocking": false,
  "muting": false,
  "muting_notifications": false,
  "subscribing": false,
  "requested": false,
  "domain_blocking": false,
  "showing_reblogs": true,
  "endorsed": false
 }
 ```
 ## `/api/v1/pleroma/accounts/:id/favourites`
 ### Returns favorites timeline of any user
 * Method `GET`
 * Authentication: not required
 * Params:
    * `id`: the id of the account for whom to return results
    * `limit`: optional, the number of records to retrieve
    * `since_id`: optional, returns results that are more recent than the specified id
    * `max_id`: optional, returns results that are older than the specified id
 * Response: JSON, returns a list of Mastodon Status entities on success, otherwise returns `{"error": "error_msg"}`
 * Example response:
 ```json
 [
  {
    "account": {
      "id": "9hptFmUF3ztxYh3Svg",
      "url": "https://pleroma.example.org/users/nick2",
      "username": "nick2",
      ...
    },
    "application": {"name": "Web", "website": null},
    "bookmarked": false,
    "card": null,
    "content": "This is :moominmamma: note 0",
    "created_at": "2019-04-15T15:42:15.000Z",
    "emojis": [],
    "favourited": false,
    "favourites_count": 1,
    "id": "9hptFmVJ02khbzYJaS",
    "in_reply_to_account_id": null,
    "in_reply_to_id": null,
    "language": null,
    "media_attachments": [],
    "mentions": [],
    "muted": false,
    "pinned": false,
    "pleroma": {
      "content": {"text/plain": "This is :moominmamma: note 0"},
      "conversation_id": 13679,
      "local": true,
      "spoiler_text": {"text/plain": "2hu"}
    },
    "reblog": null,
    "reblogged": false,
    "reblogs_count": 0,
    "replies_count": 0,
    "sensitive": false,
    "spoiler_text": "2hu",
    "tags": [{"name": "2hu", "url": "/tag/2hu"}],
    "uri": "https://pleroma.example.org/objects/198ed2a1-7912-4482-b559-244a0369e984",
    "url": "https://pleroma.example.org/notice/9hptFmVJ02khbzYJaS",
    "visibility": "public"
  }
 ]
 ```
 ## `/api/pleroma/notification_settings`
 ### Updates user notification settings
 * Method `PUT`
 * Authentication: required
 * Params:
    * `followers`: BOOLEAN field, receives notifications from followers
    * `follows`: BOOLEAN field, receives notifications from people the user follows
    * `remote`: BOOLEAN field, receives notifications from people on remote instances
    * `local`: BOOLEAN field, receives notifications from people on the local instance
 * Response: JSON. Returns `{"status": "success"}` if the update was successful, otherwise returns `{"error": "error_msg"}`
 ## `/api/pleroma/healthcheck`
 ### Healthcheck endpoint with additional system data.
 * Method `GET`
 * Authentication: not required
 * Params: none
 * Response: JSON, statuses (200 - healthy, 503 unhealthy).
 * Example response:
 ```json
 {
  "pool_size": 0, # database connection pool
  "active": 0, # active processes
  "idle": 0, # idle processes
  "memory_used": 0.00, # Memory used
  "healthy": true # Instance state
 }
 ```
--- a/docs/config.md
+++ b/docs/config.md
@ -31,22 +31,22 @@ This filter replaces the filename (not the path) of an upload. For complete obfu
 * `text`: Text to replace filenames in links. If empty, `{random}.extension` will be used.
-## Pleroma.Mailer
+## 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.
 An example for Sendgrid adapter:
-```exs
+```elixir
-config :pleroma, Pleroma.Mailer,
+config :pleroma, Pleroma.Emails.Mailer,
  adapter: Swoosh.Adapters.Sendgrid,
  api_key: "YOUR_API_KEY"
 ```
 An example for SMTP adapter:
-```exs
+```elixir
-config :pleroma, Pleroma.Mailer,
+config :pleroma, Pleroma.Emails.Mailer,
  adapter: Swoosh.Adapters.SMTP,
  relay: "smtp.gmail.com",
  username: "YOUR_USERNAME@gmail.com",
@ -63,6 +63,7 @@ config :pleroma, Pleroma.Mailer,
 ## :instance
 * `name`: The instance’s name
 * `email`: Email used to reach an Administrator/Moderator of the instance
 * `notify_email`: Email used for notifications.
 * `description`: The instance’s description, can be seen in nodeinfo and ``/api/v1/instance``
 * `limit`: Posts character limit (CW/Subject included in the counter)
 * `remote_limit`: Hard character limit beyond which remote posts will be dropped.
@ -86,7 +87,6 @@ config :pleroma, Pleroma.Mailer,
 * `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)
 * `finmoji_enabled`: Whenether to enable the finmojis in the custom emojis.
 * `mrf_transparency`: Make the content of your Message Rewrite Facility settings public (via nodeinfo).
 * `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:
@ -103,12 +103,13 @@ config :pleroma, Pleroma.Mailer,
 * `welcome_user_nickname`: The nickname of the local user that sends the welcome message.
 * `max_report_comment_size`: The maximum size of the report comment (Default: `1000`)
 * `safe_dm_mentions`: If set to true, only mentions at the beginning of a post will be used to address people in direct messages. This is to prevent accidental mentioning of people when talking about them (e.g. "@friend hey i really don't like @enemy"). (Default: `false`)
 * `healthcheck`: if set to true, system data will be shown on ``/api/pleroma/healthcheck``.
 ## :logger
 * `backends`: `:console` is used to send logs to stdout, `{ExSyslogger, :ex_syslogger}` to log to syslog, and `Quack.Logger` to log to Slack
 An example to enable ONLY ExSyslogger (f/ex in ``prod.secret.exs``) with info and debug suppressed:
-```
+```elixir
 config :logger,
  backends: [{ExSyslogger, :ex_syslogger}]
@ -117,7 +118,7 @@ config :logger, :ex_syslogger,
 ```
 Another example, keeping console output and adding the pid to syslog output:
-```
+```elixir
 config :logger,
  backends: [:console, {ExSyslogger, :ex_syslogger}]
@ -129,7 +130,7 @@ config :logger, :ex_syslogger,
 See: [logger’s documentation](https://hexdocs.pm/logger/Logger.html) and [ex_syslogger’s documentation](https://hexdocs.pm/ex_syslogger/)
 An example of logging info to local syslog, but warn to a Slack channel:
-```
+```elixir
 config :logger,
  backends: [ {ExSyslogger, :ex_syslogger}, Quack.Logger ],
  level: :info
@ -155,14 +156,30 @@ Frontends can access these settings at `/api/pleroma/frontend_configurations`
 To add your own configuration for PleromaFE, use it like this:
-`config :pleroma, :frontend_configurations, pleroma_fe: %{redirectRootNoLogin: "/main/all", ...}`
+```elixir
 config :pleroma, :frontend_configurations,
  pleroma_fe: %{
    theme: "pleroma-dark",
    # ... see /priv/static/static/config.json for the available keys.
 },
  masto_fe: %{
    showInstanceSpecificPanel: true
  }
 ```
-These settings need to be complete, they will override the defaults. See `priv/static/static/config.json` for the available keys.
+These settings **need to be complete**, they will override the defaults.
 NOTE: for versions < 1.0, you need to set [`:fe`](#fe) to false, as shown a few lines below. 
 ## :fe
 __THIS IS DEPRECATED__
-If you are using this method, please change it to the `frontend_configurations` method. Please set this option to false in your config like this: `config :pleroma, :fe, false`.
+If you are using this method, please change it to the [`frontend_configurations`](#frontend_configurations) method.
 Please **set this option to false** in your config like this: 
 ```elixir
 config :pleroma, :fe, false
 ```
 This section is used to configure Pleroma-FE, unless ``:managed_config`` in ``:instance`` is set to false.
@ -204,6 +221,7 @@ This section is used to configure Pleroma-FE, unless ``:managed_config`` in ``:i
 * `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.
 * `proxy_opts`: All options defined in `Pleroma.ReverseProxy` documentation, defaults to `[max_body_length: (25*1_048_576)]`.
 * `whitelist`: List of domains to bypass the mediaproxy
 ## :gopher
 * `enabled`: Enables the gopher interface
@ -221,6 +239,8 @@ This section is used to configure Pleroma-FE, unless ``:managed_config`` in ``:i
  - `scheme` - e.g `http`, `https`
  - `port`
  - `path`
 * `extra_cookie_attrs` - a list of `Key=Value` strings to be added as non-standard cookie attributes. Defaults to `["SameSite=Lax"]`. See the [SameSite article](https://www.owasp.org/index.php/SameSite) on OWASP for more info.
 **Important note**: if you modify anything inside these lists, default `config.exs` values will be overwritten, which may result in breakage, to make sure this does not happen please copy the default value for the list from `config.exs` and modify/add only what you need
@ -270,7 +290,7 @@ their ActivityPub ID.
 An example:
-```exs
+```elixir
 config :pleroma, :mrf_user_allowlist,
  "example.org": ["https://example.org/users/admin"]
 ```
@ -299,7 +319,7 @@ the source code is here: https://github.com/koto-bank/kocaptcha. The default end
 Allows to set a token that can be used to authenticate with the admin api without using an actual user by giving it as the 'admin_token' parameter. Example:
-```exs
+```elixir
 config :pleroma, :admin_token, "somerandomtoken"
 ```
@ -317,7 +337,7 @@ Pleroma has the following queues:
 * `federator_outgoing` - Outgoing federation
 * `federator_incoming` - Incoming federation
-* `mailer` - Email sender, see [`Pleroma.Mailer`](#pleroma-mailer)
+* `mailer` - Email sender, see [`Pleroma.Emails.Mailer`](#pleroma-emails-mailer)
 * `transmogrifier` - Transmogrifier
 * `web_push` - Web push notifications
 * `scheduled_activities` - Scheduled activities, see [`Pleroma.ScheduledActivities`](#pleromascheduledactivity)
@ -340,9 +360,10 @@ This config contains two queues: `federator_incoming` and `federator_outgoing`.
 * `max_retries`: The maximum number of times a federation job is retried
 ## Pleroma.Web.Metadata
-* `providers`: a list of metadata providers to enable. Providers availible:
+* `providers`: a list of metadata providers to enable. Providers available:
  * Pleroma.Web.Metadata.Providers.OpenGraph
  * Pleroma.Web.Metadata.Providers.TwitterCard
  * Pleroma.Web.Metadata.Providers.RelMe - add links from user bio with rel=me into the `<header>` as `<link rel=me>`
 * `unfurl_nsfw`: If set to `true` nsfw attachments will be shown in previews
 ## :rich_media
@ -382,7 +403,7 @@ Configuration for the `auto_linker` library:
 Example:
-```exs
+```elixir
 config :auto_linker,
  opts: [
    scheme: true,
@ -442,6 +463,8 @@ The server should also be started with `OAUTH_CONSUMER_STRATEGIES="..." mix phx.
 Note: each strategy requires separate setup (on external provider side and Pleroma side). Below are the guidelines on setting up most popular strategies.
 Note: make sure that `"SameSite=Lax"` is set in `extra_cookie_attrs` when you have this feature enabled. OAuth consumer mode will not work with `"SameSite=Strict"`
 * For Twitter, [register an app](https://developer.twitter.com/en/apps), configure callback URL to https://<your_host>/oauth/twitter/callback
 * For Facebook, [register an app](https://developers.facebook.com/apps), configure callback URL to https://<your_host>/oauth/facebook/callback, enable Facebook Login service at https://developers.facebook.com/apps/<app_id>/fb-login/settings/
@ -453,7 +476,7 @@ Note: each strategy requires separate setup (on external provider side and Plero
 Once the app is configured on external OAuth provider side, add app's credentials and strategy-specific settings (if any — e.g. see Microsoft below) to `config/prod.secret.exs`,
 per strategy's documentation (e.g. [ueberauth_twitter](https://github.com/ueberauth/ueberauth_twitter)). Example config basing on environment variables:
-```
+```elixir
 # Twitter
 config :ueberauth, Ueberauth.Strategy.Twitter.OAuth,
  consumer_key: System.get_env("TWITTER_CONSUMER_KEY"),
@ -481,3 +504,8 @@ config :ueberauth, Ueberauth,
    microsoft: {Ueberauth.Strategy.Microsoft, [callback_params: []]}
  ]
 ```
 ## :emoji
 * `shortcode_globs`: Location of custom emoji files. `*` can be used as a wildcard. Example `["/emoji/custom/**/*.png"]`
 * `groups`: Emojis are ordered in groups (tags). This is an array of key-value pairs where the key is the groupname and the value the location or array of locations. `*` can be used as a wildcard. Example `[Custom: ["/emoji/*.png", "/emoji/custom/*.png"]]`
 * `default_manifest`: Location of the JSON-manifest. This manifest contains information about the emoji-packs you can download. Currently only one manifest can be added (no arrays).
--- a/docs/config/custom_emoji.md
+++ b/docs/config/custom_emoji.md
@ -1,15 +1,25 @@
 # Custom Emoji
 Before you add your own custom emoji, check if they are available in an existing pack.
 See `Mix.Tasks.Pleroma.Emoji` for information about emoji packs.
 To add custom emoji:
-* Add the image file(s) to `priv/static/emoji/custom`
+* Create the `STATIC-DIR/emoji/` directory if it doesn't exist
-* In case of conflicts: add the desired shortcode with the path to `config/custom_emoji.txt`, comma-separated and one per line
+  (`STATIC-DIR` is configurable, `instance/static/` by default)
-* Force recompilation (``mix clean && mix compile``)
+* Create a directory with whatever name you want (custom is a good name to show the purpose of it).
  This will create a local emoji pack.
 * Put your `.png` emoji files in that directory. In case of conflicts, you can create an `emoji.txt`
  file in that directory and specify a custom shortcode using the following format:
  `shortcode, file-path, tag1, tag2, etc`. One emoji per line. Note that if you do so,
  you'll have to list all other emojis in the pack too.
 * Either restart pleroma or connect to the iex session pleroma's running and
  run `Pleroma.Emoji.reload/0` in it.
 Example:
-image files (in `/priv/static/emoji/custom`): `happy.png` and `sad.png`
+image files (in `instance/static/emoji/custom`): `happy.png` and `sad.png`
-content of `config/custom_emoji.txt`:
+content of `emoji.txt`:
 ```
 happy, /emoji/custom/happy.png, Tag1,Tag2
 sad, /emoji/custom/sad.png, Tag1
@ -18,9 +28,14 @@ foo, /emoji/custom/foo.png
 The files should be PNG (APNG is okay with `.png` for `image/png` Content-type) and under 50kb for compatibility with mastodon.
 Default file extentions and locations for emojis are set in `config.exs`. To use different locations or file-extentions, add the `shortcode_globs` to your secrets file (`prod.secret.exs` or `dev.secret.exs`) and edit it. Note that not all fediverse-software will show emojis with other file extentions:
 ```elixir
 config :pleroma, :emoji, shortcode_globs: ["/emoji/custom/**/*.png", "/emoji/custom/**/*.gif"]
 ```
 ## Emoji tags (groups)
-Default tags are set in `config.exs`.
+Default tags are set in `config.exs`. To set your own tags, copy the structure to your secrets file (`prod.secret.exs` or `dev.secret.exs`) and edit it.
 ```elixir
 config :pleroma, :emoji,
  shortcode_globs: ["/emoji/custom/**/*.png"],
--- a/docs/installation/arch_linux_en.md
+++ b/docs/installation/arch_linux_en.md
@ -7,7 +7,6 @@ This guide will assume that you have administrative rights, either as root or a
 * `postgresql`
 * `elixir`
 * `erlang-unixodbc`
 * `git`
 * `base-devel`
@ -27,7 +26,7 @@ sudo pacman -Syu
 * Install some of the above mentioned programs:
 ```shell
-sudo pacman -S git base-devel elixir erlang-unixodbc
+sudo pacman -S git base-devel elixir
 ```
 ### Install PostgreSQL
--- a/docs/installation/gentoo_en.md
+++ b/docs/installation/gentoo_en.md
@ -0,0 +1,296 @@
 # Installing on Gentoo GNU/Linux
 ## Installation
 This guide will assume that you have administrative rights, either as root or a user with [sudo permissions](https://wiki.gentoo.org/wiki/Sudo). Lines that begin with `#` indicate that they should be run as the superuser. Lines using `$` should be run as the indicated user, e.g. `pleroma$` should be run as the `pleroma` user.
 ### Configuring your hostname (optional)
 If you would like your prompt to permanently include your host/domain, change `/etc/conf.d/hostname` to your hostname. You can reboot or use the `hostname` command to make immediate changes.
 ### Your make.conf, package.use, and USE flags
 The only specific USE flag you should need is the `uuid` flag for `dev-db/postgresql`. Add the following line to any new file in `/etc/portage/package.use`. If you would like a suggested name for the file, either `postgresql` or `pleroma` would do fine, depending on how you like to arrange your package.use flags.
 ```text
 dev-db/postgresql uuid
 ```
 You could opt to add `USE="uuid"` to `/etc/portage/make.conf` if you'd rather set this as a global USE flags, but this flags does unrelated things in other packages, so keep that in mind if you elect to do so.
 Double check your compiler flags in `/etc/portage/make.conf`. If you require any special compilation flags or would like to set up remote builds, now is the time to do so. Be sure that your CFLAGS and MAKEOPTS make sense for the platform you are using. It is not recommended to use above `-O2` or risky optimization flags for a production server.
 ### Installing a cron daemon
 Gentoo quite pointedly does not come with a cron daemon installed, and as such it is recommended you install one to automate certbot renewals and to allow other system administration tasks to be run automatically. Gentoo has [a whole wide world of cron options](https://wiki.gentoo.org/wiki/Cron) but if you just want A Cron That Works, `emerge --ask virtual/cron` will install the default cron implementation (probably cronie) which will work just fine. For the purpouses of this guide, we will be doing just that.
 ### Required ebuilds
 * `dev-db/postgresql`
 * `dev-lang/elixir`
 * `dev-vcs/git`
 #### Optional ebuilds used in this guide
 * `www-servers/nginx` (preferred, example configs for other reverse proxies can be found in the repo)
 * `app-crypt/certbot` (or any other ACME client for Let’s Encrypt certificates)
 * `app-crypt/certbot-nginx` (nginx certbot plugin that allows use of the all-powerful `--nginx` flag on certbot)
 ### Prepare the system
 * First ensure that you have the latest copy of the portage ebuilds if you have not synced them yet:
 ```shell
 # emaint sync -a
 ```
 * Emerge all required the required and suggested software in one go:
 ```shell
 # emerge --ask dev-db/postgresql dev-lang/elixir dev-vcs/git www-servers/nginx app-crypt/certbot app-crypt/certbot-nginx
 ```
 If you would not like to install the optional packages, remove them from this line. 
 If you're running this from a low-powered virtual machine, it should work though it will take some time. There were no issues on a VPS with a single core and 1GB of RAM; if you are using an even more limited device and run into issues, you can try creating a swapfile or use a more powerful machine running Gentoo to [cross build](https://wiki.gentoo.org/wiki/Cross_build_environment). If you have a wait ahead of you, now would be a good time to take a break, strech a bit, refresh your beverage of choice and/or get a snack, and reply to Arch users' posts with "I use Gentoo btw" as we do.
 ### Install PostgreSQL
 [Gentoo  Wiki article](https://wiki.gentoo.org/wiki/PostgreSQL) as well as [PostgreSQL QuickStart](https://wiki.gentoo.org/wiki/PostgreSQL/QuickStart) might be worth a quick glance, as the way Gentoo handles postgres is slightly unusual, with built in capability to have two different databases running for testing and live or whatever other purpouse. While it is still straightforward to install, it does mean that the version numbers used in this guide might change for future updates, so keep an eye out for the output you get from `emerge` to ensure you are using the correct ones.
 * Install postgresql if you have not done so already:
 ```shell
 # emerge --ask dev-db/postgresql
 ```
 Ensure that `/etc/conf.d/postgresql-11` has the encoding you want (it defaults to UTF8 which is probably what you want) and make any adjustments to the data directory if you find it necessary. Be sure to adjust the number at the end depending on what version of postgres you actually installed.
 * Initialize the database cluster
 The output from emerging postgresql should give you a command for initializing the postgres database. The default slot should be indicated in this command, ensure that it matches the command below.
 ```shell
 # emerge --config dev-db/postgresql:11
 ```
 * Start postgres and enable the system service
 ```shell
 # /etc/init.d/postgresql-11 start
 # rc-update add postgresql-11 default
 ```
 ### A note on licenses, the AGPL, and deployment procedures
 If you do not plan to make any modifications to your Pleroma instance, cloning directly from the main repo will get you what you need. However, if you plan on doing any contributions to upstream development, making changes or modifications to your instance, making custom themes, or want to play around--and let's be honest here, if you're using Gentoo that is most likely you--you will save yourself a lot of headache later if you take the time right now to fork the Pleroma repo and use that in the following section.
 Not only does this make it much easier to deploy changes you make, as you can commit and pull from upstream and all that good stuff from the comfort of your local machine then simply `git pull` on your instance server when you're ready to deploy, it also ensures you are compliant with the Affero General Public Licence that Pleroma is licenced under, which stipulates that all network services provided with modified AGPL code must publish their changes on a publicly available internet service and for free. It also makes it much easier to ask for help from and provide help to your fellow Pleroma admins if your public repo always reflects what you are running because it is part of your deployment procedure.
 ### Install PleromaBE
 * Add a new system user for the Pleroma service and set up default directories:
 Remove `,wheel` if you do not want this user to be able to use `sudo`, however note that being able to `sudo` as the `pleroma` user will make finishing the insallation and common maintenence tasks somewhat easier:
 ```shell
 # useradd -m -G users,wheel -s /bin/bash pleroma
 ```
 Optional: If you are using sudo, review your sudo setup to ensure it works for you. The `/etc/sudoers` file has a lot of options and examples to help you, and [the Gentoo sudo guide](https://wiki.gentoo.org/wiki/Sudo) has more information. Finishing this installation will be somewhat easier if you have a way to sudo from the `pleroma` user, but it might be best to not allow that user to sudo during normal operation, and as such there will be a reminder at the end of this guide to double check if you would like to lock down the `pleroma` user after initial setup.
 **Note**: To execute a single command as the Pleroma system user, use `sudo -Hu pleroma command`. You can also switch to a shell by using `sudo -Hu pleroma $SHELL`. If you don't have or want `sudo` or would like to use the system as the `pleroma` user for instance maintenance tasks, you can simply use `su - pleroma` to switch to the `pleroma` user.
 * Git clone the PleromaBE repository and make the Pleroma user the owner of the directory:
 It is highly recommended you use your own fork for the `https://path/to/repo` part below, however if you foolishly decide to forego using your own fork, the primary repo `https://git.pleroma.social/pleroma/pleroma` will work here.
 ```shell
 pleroma$ cd ~
 pleroma$ git clone https://path/to/repo
 ```
 * Change to the new directory:
 ```shell
 pleroma$ cd ~/pleroma
 ```
 * Install the dependencies for Pleroma and answer with `yes` if it asks you to install `Hex`:
 ```shell
 pleroma$ mix deps.get
 ```
 * Generate the configuration:
 ```shell
 pleroma$ mix pleroma.instance gen
 ```
  * Answer with `yes` if it asks you to install `rebar3`.
  * This part precompiles some parts of Pleroma, so it might take a few moments
  * After that it will ask you a few questions about your instance and generates a configuration file in `config/generated_config.exs`.
  * Spend some time with `generated_config.exs` to ensure that everything is in order. If you plan on using an S3-compatible service to store your local media, that can be done here. You will likely mostly be using `prod.secret.exs` for a production instance, however if you would like to set up a development environment, make a copy to `dev.secret.exs` and adjust settings as needed as well.
 ```shell
 pleroma$ mv config/generated_config.exs config/prod.secret.exs
 ```
 * The previous command creates also the file `config/setup_db.psql`, with which you can create the database. Ensure that it is using the correct database name on the `CREATE DATABASE` and the `\c` lines, then run the postgres script:
 ```shell
 pleroma$ sudo -Hu postgres psql -f config/setup_db.psql
 ```
 * Now run the database migration:
 ```shell
 pleroma$ MIX_ENV=prod mix ecto.migrate
 ```
 * Now you can start Pleroma already
 ```shell
 pleroma$ MIX_ENV=prod mix phx.server
 ```
 It probably won't work over the public internet quite yet, however, as we still need to set up a web servere to proxy to the pleroma application, as well as configure SSL.
 ### Finalize installation
 Assuming you want to open your newly installed federated social network to, well, the federation, you should run nginx or some other webserver/proxy in front of Pleroma. It is also a good idea to set up Pleroma to run as a system service.
 #### Nginx
 * Install nginx, if not already done:
 ```shell
 # emerge --ask www-servers/nginx
 ```
 * Create directories for available and enabled sites:
 ```shell
 # mkdir -p /etc/nginx/sites-{available,enabled}
 ```
 * Append the following line at the end of the `http` block in `/etc/nginx/nginx.conf`:
 ```Nginx
 include sites-enabled/*;
 ```
 * Setup your SSL cert, using your method of choice or certbot. If using certbot, install it if you haven't already:
 ```shell
 # emerge --ask app-crypt/certbot app-crypt/certbot-nginx
 ```
 and then set it up:
 ```shell
 # mkdir -p /var/lib/letsencrypt/
 # certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
 ```
 If that doesn't work the first time, add `--dry-run` to further attempts to avoid being ratelimited as you identify the issue, and do not remove it until the dry run succeeds. If that doesn’t work, make sure, that nginx is not already running. If it still doesn’t work, try setting up nginx first (change ssl “on” to “off” and try again). Often the answer to issues with certbot is to use the `--nginx` flag once you have nginx up and running.
 If you are using any additional subdomains, such as for a media proxy, you can re-run the same command with the subdomain in question. When it comes time to renew later, you will not need to run multiple times for each domain, one renew will handle it.
 ---
 * Copy the example nginx configuration and activate it:
 ```shell
 # cp /home/pleroma/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/
 # ln -s /etc/nginx/sites-available/pleroma.nginx /etc/nginx/sites-enabled/pleroma.nginx
 ```
 * Take some time to ensure that your nginx config is correct
 Replace all instances of `example.tld` with your instance's public URL. If for whatever reason you made changes to the port that your pleroma app runs on, be sure that is reflected in your configuration.
 Pay special attention to the line that begins with `ssl_ecdh_curve`. It is stongly advised to comment that line out so that OpenSSL will use its full capabilities, and it is also possible you are running OpenSSL 1.0.2 necessitating that you do this.
 * Enable and start nginx:
 ```shell
 # rc-update add nginx default
 # /etc/init.d/nginx start
 ```
 If you are using certbot, it is HIGHLY recommend you set up a cron job that renews your certificate, and that you install the suggested `certbot-nginx` plugin. If you don't do these things, you only have yourself to blame when your instance breaks suddenly because you forgot about it.
 First, ensure that the command you will be installing into your crontab works.
 ```shell
 # /usr/bin/certbot renew --nginx
 ```
 Assuming not much time has passed since you got certbot working a few steps ago, you should get a message for all domains you installed certificates for saying `Cert not yet due for renewal`. 
 Now, run crontab as a superuser with `crontab -e` or `sudo crontab -e` as appropriate, and add the following line to your cron:
 ```cron
 0 0 1 * * /usr/bin/certbot renew --nginx
 ```
 This will run certbot on the first of the month at midnight. If you'd rather run more frequently, it's not a bad idea, feel free to go for it.
 #### Other webserver/proxies
 If you would like to use other webservers or proxies, there are example configurations for some popular alternatives in `/home/pleroma/pleroma/installation/`. You can, of course, check out [the Gentoo wiki](https://wiki.gentoo.org) for more information on installing and configuring said alternatives.
 #### Create the uploads folder
 Even if you are using S3, Pleroma needs someplace to store media posted on your instance. If you are using the `/home/pleroma/pleroma` root folder suggested by this guide, simply:
 ```shell
 pleroma$ mkdir -p ~/pleroma/uploads
 ```
 #### init.d service
 * Copy example service file
 ```shell
 # cp /home/pleroma/pleroma/installation/init.d/pleroma /etc/init.d/
 ```
 * Be sure to take a look at this service file and make sure that all paths fit your installation
 * Enable and start `pleroma`:
 ```shell
 # rc-update add pleroma default
 # /etc/init.d/pleroma start
 ```
 #### Create your first user
 If your instance is up and running, you can create your first user with administrative rights with the following task:
 ```shell
 pleroma$ MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
 ```
 #### Privilege cleanup
 If you opted to allow sudo for the `pleroma` user but would like to remove the ability for greater security, now might be a good time to edit `/etc/sudoers` and/or change the groups the `pleroma` user belongs to. Be sure to restart the pleroma service afterwards to ensure it picks up on the changes.
 #### Further reading
 * [Admin tasks](Admin tasks)
 * [Backup your instance](Backup-your-instance)
 * [Configuration tips](General tips for customizing pleroma fe)
 * [Hardening your instance](Hardening-your-instance)
 * [How to activate mediaproxy](How-to-activate-mediaproxy)
 * [Small Pleroma-FE customizations](Small customizations)
 * [Updating your instance](Updating-your-instance)
 ## Questions
 Questions about the installation or didn’t it work as it should be, ask in [#pleroma:matrix.org](https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org) or IRC Channel **#pleroma** on **Freenode**.
--- a/installation/download-mastofe-build.sh
+++ b/installation/download-mastofe-build.sh
@ -0,0 +1,45 @@
 #!/bin/sh
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 project_id="74"
 project_branch="rebase/glitch-soc"
 static_dir="instance/static"
 # For bundling:
 # project_branch="pleroma"
 # static_dir="priv/static"
 if [[ ! -d "${static_dir}" ]]
 then
 	echo "Error: ${static_dir} directory is missing, are you sure you are running this script at the root of pleroma’s repository?"
 	exit 1
 fi
 last_modified="$(curl -s -I 'https://git.pleroma.social/api/v4/projects/'${project_id}'/jobs/artifacts/'${project_branch}'/download?job=build' | grep '^Last-Modified:' | cut -d: -f2-)"
 echo "branch:${project_branch}"
 echo "Last-Modified:${last_modified}"
 artifact="mastofe.zip"
 if [[ -e mastofe.timestamp ]] && [[ "${last_modified}" != "" ]]
 then
 	if [[ "$(cat mastofe.timestamp)" == "${last_modified}" ]]
 	then
 		echo "MastoFE is up-to-date, exiting…"
 		exit 0
 	fi
 fi
 curl -c - "https://git.pleroma.social/api/v4/projects/${project_id}/jobs/artifacts/${project_branch}/download?job=build" -o "${artifact}" || exit
 # TODO: Update the emoji as well
 rm -fr "${static_dir}/sw.js" "${static_dir}/packs" || exit
 unzip -q "${artifact}" || exit
 cp public/assets/sw.js "${static_dir}/sw.js" || exit
 cp -r public/packs "${static_dir}/packs" || exit
 echo "${last_modified}" > mastofe.timestamp
 rm -fr public
 rm -i "${artifact}"
--- a/installation/pleroma.nginx
+++ b/installation/pleroma.nginx
@ -37,7 +37,7 @@ server {
    listen [::]:443 ssl http2;
    ssl_session_timeout 5m;
-    ssl_trusted_certificate   /etc/letsencrypt/live/example.tld/fullchain.pem;
+    ssl_trusted_certificate   /etc/letsencrypt/live/example.tld/chain.pem;
    ssl_certificate           /etc/letsencrypt/live/example.tld/fullchain.pem;
    ssl_certificate_key       /etc/letsencrypt/live/example.tld/privkey.pem;
--- a/installation/pleroma.supervisord
+++ b/installation/pleroma.supervisord
@ -0,0 +1,21 @@
 ; Assumes pleroma is installed in /home/pleroma/pleroma and running as the pleroma user
 ; Also assumes mix is in /usr/bin, this might differ on BSDs or niche Linux distros
 ; Logs into /home/pleroma/logs
 [program:pleroma]
 command=/usr/bin/mix phx.server
 directory=/home/pleroma/pleroma
 autostart=true
 autorestart=true
 user=pleroma
 environment =
  MIX_ENV=prod,
  HOME=/home/pleroma,
  USER=pleroma,
  PATH="/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/home/pleroma/bin:%(ENV_PATH)s",
  PWD=/home/pleroma/pleroma
 stdout_logfile=/home/pleroma/logs/stdout.log
 stdout_logfile_maxbytes=50MB
 stdout_logfile_backups=10
 stderr_logfile=/home/pleroma/logs/stderr.log
 stderr_logfile_maxbytes=50MB
 stderr_logfile_backups=10
--- a/lib/healthcheck.ex
+++ b/lib/healthcheck.ex
@ -0,0 +1,60 @@
 defmodule Pleroma.Healthcheck do
  @moduledoc """
  Module collects metrics about app and assign healthy status.
  """
  alias Pleroma.Healthcheck
  alias Pleroma.Repo
  defstruct pool_size: 0,
            active: 0,
            idle: 0,
            memory_used: 0,
            healthy: true
  @type t :: %__MODULE__{
          pool_size: non_neg_integer(),
          active: non_neg_integer(),
          idle: non_neg_integer(),
          memory_used: number(),
          healthy: boolean()
        }
  @spec system_info() :: t()
  def system_info do
    %Healthcheck{
      memory_used: Float.round(:erlang.memory(:total) / 1024 / 1024, 2)
    }
    |> assign_db_info()
    |> check_health()
  end
  defp assign_db_info(healthcheck) do
    database = Application.get_env(:pleroma, Repo)[:database]
    query =
      "select state, count(pid) from pg_stat_activity where datname = '#{database}' group by state;"
    result = Repo.query!(query)
    pool_size = Application.get_env(:pleroma, Repo)[:pool_size]
    db_info =
      Enum.reduce(result.rows, %{active: 0, idle: 0}, fn [state, cnt], states ->
        if state == "active" do
          Map.put(states, :active, states.active + cnt)
        else
          Map.put(states, :idle, states.idle + cnt)
        end
      end)
      |> Map.put(:pool_size, pool_size)
    Map.merge(healthcheck, db_info)
  end
  @spec check_health(Healthcheck.t()) :: Healthcheck.t()
  def check_health(%{pool_size: pool_size, active: active} = check)
      when active >= pool_size do
    %{check | healthy: false}
  end
  def check_health(check), do: check
 end
--- a/lib/mix/tasks/pleroma/database.ex
+++ b/lib/mix/tasks/pleroma/database.ex
@ -0,0 +1,51 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Mix.Tasks.Pleroma.Database do
  alias Mix.Tasks.Pleroma.Common
  require Logger
  use Mix.Task
  @shortdoc "A collection of database related tasks"
  @moduledoc """
   A collection of database related tasks
   ## Replace embedded objects with their references
   Replaces embedded objects with references to them in the `objects` table. Only needs to be ran once. The reason why this is not a migration is because it could significantly increase the database size after being ran, however after this `VACUUM FULL` will be able to reclaim about 20% (really depends on what is in the database, your mileage may vary) of the db size before the migration.
       mix pleroma.database remove_embedded_objects
    Options:
    - `--vacuum` - run `VACUUM FULL` after the embedded objects are replaced with their references
  """
  def run(["remove_embedded_objects" | args]) do
    {options, [], []} =
      OptionParser.parse(
        args,
        strict: [
          vacuum: :boolean
        ]
      )
    Common.start_pleroma()
    Logger.info("Removing embedded objects")
    Pleroma.Repo.query!(
      "update activities set data = jsonb_set(data, '{object}'::text[], data->'object'->'id') where data->'object'->>'id' is not null;",
      [],
      timeout: :infinity
    )
    if Keyword.get(options, :vacuum) do
      Logger.info("Runnning VACUUM FULL")
      Pleroma.Repo.query!(
        "vacuum full;",
        [],
        timeout: :infinity
      )
    end
  end
 end
--- a/lib/mix/tasks/pleroma/emoji.ex
+++ b/lib/mix/tasks/pleroma/emoji.ex
@ -0,0 +1,293 @@
 # Pleroma: A lightweight social networking server
 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 defmodule Mix.Tasks.Pleroma.Emoji do
  use Mix.Task
  @shortdoc "Manages emoji packs"
  @moduledoc """
  Manages emoji packs
  ## ls-packs
      mix pleroma.emoji ls-packs [OPTION...]
  Lists the emoji packs and metadata specified in the manifest.
  ### Options
  - `-m, --manifest PATH/URL` - path to a custom manifest, it can
    either be an URL starting with `http`, in that case the
    manifest will be fetched from that address, or a local path
  ## get-packs
      mix pleroma.emoji get-packs [OPTION...] PACKS
  Fetches, verifies and installs the specified PACKS from the
  manifest into the `STATIC-DIR/emoji/PACK-NAME`
  ### Options
  - `-m, --manifest PATH/URL` - same as ls-packs
  ## gen-pack
      mix pleroma.emoji gen-pack PACK-URL
  Creates a new manifest entry and a file list from the specified
  remote pack file. Currently, only .zip archives are recognized
  as remote pack files and packs are therefore assumed to be zip
  archives. This command is intended to run interactively and will
  first ask you some basic questions about the pack, then download
  the remote file and generate an SHA256 checksum for it, then
  generate an emoji file list for you.
  The manifest entry will either be written to a newly created
  `index.json` file or appended to the existing one, *replacing*
  the old pack with the same name if it was in the file previously.
  The file list will be written to the file specified previously,
  *replacing* that file. You _should_ check that the file list doesn't
  contain anything you don't need in the pack, that is, anything that is
  not an emoji (the whole pack is downloaded, but only emoji files
  are extracted).
  """
  @default_manifest Pleroma.Config.get!([:emoji, :default_manifest])
  def run(["ls-packs" | args]) do
    Application.ensure_all_started(:hackney)
    {options, [], []} = parse_global_opts(args)
    manifest =
      fetch_manifest(if options[:manifest], do: options[:manifest], else: @default_manifest)
    Enum.each(manifest, fn {name, info} ->
      to_print = [
        {"Name", name},
        {"Homepage", info["homepage"]},
        {"Description", info["description"]},
        {"License", info["license"]},
        {"Source", info["src"]}
      ]
      for {param, value} <- to_print do
        IO.puts(IO.ANSI.format([:bright, param, :normal, ": ", value]))
      end
      # A newline
      IO.puts("")
    end)
  end
  def run(["get-packs" | args]) do
    Application.ensure_all_started(:hackney)
    {options, pack_names, []} = parse_global_opts(args)
    manifest_url = if options[:manifest], do: options[:manifest], else: @default_manifest
    manifest = fetch_manifest(manifest_url)
    for pack_name <- pack_names do
      if Map.has_key?(manifest, pack_name) do
        pack = manifest[pack_name]
        src_url = pack["src"]
        IO.puts(
          IO.ANSI.format([
            "Downloading ",
            :bright,
            pack_name,
            :normal,
            " from ",
            :underline,
            src_url
          ])
        )
        binary_archive = Tesla.get!(src_url).body
        archive_sha = :crypto.hash(:sha256, binary_archive) |> Base.encode16()
        sha_status_text = ["SHA256 of ", :bright, pack_name, :normal, " source file is ", :bright]
        if archive_sha == String.upcase(pack["src_sha256"]) do
          IO.puts(IO.ANSI.format(sha_status_text ++ [:green, "OK"]))
        else
          IO.puts(IO.ANSI.format(sha_status_text ++ [:red, "BAD"]))
          raise "Bad SHA256 for #{pack_name}"
        end
        # The url specified in files should be in the same directory
        files_url = Path.join(Path.dirname(manifest_url), pack["files"])
        IO.puts(
          IO.ANSI.format([
            "Fetching the file list for ",
            :bright,
            pack_name,
            :normal,
            " from ",
            :underline,
            files_url
          ])
        )
        files = Tesla.get!(files_url).body |> Poison.decode!()
        IO.puts(IO.ANSI.format(["Unpacking ", :bright, pack_name]))
        pack_path =
          Path.join([
            Pleroma.Config.get!([:instance, :static_dir]),
            "emoji",
            pack_name
          ])
        files_to_unzip =
          Enum.map(
            files,
            fn {_, f} -> to_charlist(f) end
          )
        {:ok, _} =
          :zip.unzip(binary_archive,
            cwd: pack_path,
            file_list: files_to_unzip
          )
        IO.puts(IO.ANSI.format(["Writing emoji.txt for ", :bright, pack_name]))
        emoji_txt_str =
          Enum.map(
            files,
            fn {shortcode, path} ->
              emojo_path = Path.join("/emoji/#{pack_name}", path)
              "#{shortcode}, #{emojo_path}"
            end
          )
          |> Enum.join("\n")
        File.write!(Path.join(pack_path, "emoji.txt"), emoji_txt_str)
      else
        IO.puts(IO.ANSI.format([:bright, :red, "No pack named \"#{pack_name}\" found"]))
      end
    end
  end
  def run(["gen-pack", src]) do
    Application.ensure_all_started(:hackney)
    proposed_name = Path.basename(src) |> Path.rootname()
    name = String.trim(IO.gets("Pack name [#{proposed_name}]: "))
    # If there's no name, use the default one
    name = if String.length(name) > 0, do: name, else: proposed_name
    license = String.trim(IO.gets("License: "))
    homepage = String.trim(IO.gets("Homepage: "))
    description = String.trim(IO.gets("Description: "))
    proposed_files_name = "#{name}.json"
    files_name = String.trim(IO.gets("Save file list to [#{proposed_files_name}]: "))
    files_name = if String.length(files_name) > 0, do: files_name, else: proposed_files_name
    default_exts = [".png", ".gif"]
    default_exts_str = Enum.join(default_exts, " ")
    exts =
      String.trim(
        IO.gets("Emoji file extensions (separated with spaces) [#{default_exts_str}]: ")
      )
    exts =
      if String.length(exts) > 0 do
        String.split(exts, " ")
        |> Enum.filter(fn e -> e |> String.trim() |> String.length() > 0 end)
      else
        default_exts
      end
    IO.puts("Downloading the pack and generating SHA256")
    binary_archive = Tesla.get!(src).body
    archive_sha = :crypto.hash(:sha256, binary_archive) |> Base.encode16()
    IO.puts("SHA256 is #{archive_sha}")
    pack_json = %{
      name => %{
        license: license,
        homepage: homepage,
        description: description,
        src: src,
        src_sha256: archive_sha,
        files: files_name
      }
    }
    tmp_pack_dir = Path.join(System.tmp_dir!(), "emoji-pack-#{name}")
    {:ok, _} =
      :zip.unzip(
        binary_archive,
        cwd: tmp_pack_dir
      )
    emoji_map = Pleroma.Emoji.make_shortcode_to_file_map(tmp_pack_dir, exts)
    File.write!(files_name, Poison.encode!(emoji_map, pretty: true))
    IO.puts("""
    #{files_name} has been created and contains the list of all found emojis in the pack.
    Please review the files in the remove those not needed.
    """)
    if File.exists?("index.json") do
      existing_data = File.read!("index.json") |> Poison.decode!()
      File.write!(
        "index.json",
        Poison.encode!(
          Map.merge(
            existing_data,
            pack_json
          ),
          pretty: true
        )
      )
      IO.puts("index.json file has been update with the #{name} pack")
    else
      File.write!("index.json", Poison.encode!(pack_json, pretty: true))
      IO.puts("index.json has been created with the #{name} pack")
    end
  end
  defp fetch_manifest(from) do
    Poison.decode!(
      if String.starts_with?(from, "http") do
        Tesla.get!(from).body
      else
        File.read!(from)
      end
    )
  end
  defp parse_global_opts(args) do
    OptionParser.parse(
      args,
      strict: [
        manifest: :string
      ],
      aliases: [
        m: :manifest
      ]
    )
  end
 end
--- a/lib/mix/tasks/pleroma/instance.ex
+++ b/lib/mix/tasks/pleroma/instance.ex
@ -24,10 +24,12 @@ defmodule Mix.Tasks.Pleroma.Instance do
  - `--domain DOMAIN` - the domain of your instance
  - `--instance-name INSTANCE_NAME` - the name of your instance
  - `--admin-email ADMIN_EMAIL` - the email address of the instance admin
  - `--notify-email NOTIFY_EMAIL` - email address for notifications
  - `--dbhost HOSTNAME` - the hostname of the PostgreSQL database to use
  - `--dbname DBNAME` - the name of the database to use
  - `--dbuser DBUSER` - the user (aka role) to use for the database connection
  - `--dbpass DBPASS` - the password to use for the database connection
  - `--indexable Y/N` - Allow/disallow indexing site by search engines
  """
  def run(["gen" | rest]) do
@ -41,10 +43,12 @@ def run(["gen" | rest]) do
          domain: :string,
          instance_name: :string,
          admin_email: :string,
          notify_email: :string,
          dbhost: :string,
          dbname: :string,
          dbuser: :string,
-          dbpass: :string
+          dbpass: :string,
          indexable: :string
        ],
        aliases: [
          o: :output,
@ -61,7 +65,7 @@ def run(["gen" | rest]) do
    will_overwrite = Enum.filter(paths, &File.exists?/1)
    proceed? = Enum.empty?(will_overwrite) or Keyword.get(options, :force, false)
-    unless not proceed? do
+    if proceed? do
      [domain, port | _] =
        String.split(
          Common.get_option(
@ -81,6 +85,14 @@ def run(["gen" | rest]) do
      email = Common.get_option(options, :admin_email, "What is your admin email address?")
      notify_email =
        Common.get_option(
          options,
          :notify_email,
          "What email address do you want to use for sending email notifications?",
          email
        )
      indexable =
        Common.get_option(
          options,
@ -122,6 +134,7 @@ def run(["gen" | rest]) do
          domain: domain,
          port: port,
          email: email,
          notify_email: notify_email,
          name: name,
          dbhost: dbhost,
          dbname: dbname,
--- a/lib/mix/tasks/pleroma/sample_config.eex
+++ b/lib/mix/tasks/pleroma/sample_config.eex
@ -13,6 +13,7 @@ config :pleroma, Pleroma.Web.Endpoint,
 config :pleroma, :instance,
  name: "<%= name %>",
  email: "<%= email %>",
  notify_email: "<%= notify_email %>",
  limit: 5000,
  registrations_open: true,
  dedupe_media: false
@ -75,4 +76,3 @@ config :web_push_encryption, :vapid_details,
 #  storage_url: "https://swift-endpoint.prodider.com/v1/AUTH_<tenant>/<container>",
 #  object_url: "https://cdn-endpoint.provider.com/<container>"
 #
--- a/lib/mix/tasks/pleroma/user.ex
+++ b/lib/mix/tasks/pleroma/user.ex
@ -7,6 +7,7 @@ defmodule Mix.Tasks.Pleroma.User do
  import Ecto.Changeset
  alias Mix.Tasks.Pleroma.Common
  alias Pleroma.User
  alias Pleroma.UserInviteToken
  @shortdoc "Manages Pleroma users"
  @moduledoc """
@ -26,7 +27,19 @@ defmodule Mix.Tasks.Pleroma.User do
  ## Generate an invite link.
-      mix pleroma.user invite
+      mix pleroma.user invite [OPTION...]
    Options:
    - `--expires_at DATE` - last day on which token is active (e.g. "2019-04-05")
    - `--max_use NUMBER` - maximum numbers of token uses
  ## List generated invites
      mix pleroma.user invites
  ## Revoke invite
      mix pleroma.user revoke_invite TOKEN OR TOKEN_ID
  ## Delete the user's account.
@ -113,7 +126,7 @@ def run(["new", nickname, email | rest]) do
    proceed? = assume_yes? or Mix.shell().yes?("Continue?")
-    unless not proceed? do
+    if proceed? do
      Common.start_pleroma()
      params = %{
@ -149,7 +162,7 @@ def run(["new", nickname, email | rest]) do
  def run(["rm", nickname]) do
    Common.start_pleroma()
-    with %User{local: true} = user <- User.get_by_nickname(nickname) do
+    with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
      User.delete(user)
      Mix.shell().info("User #{nickname} deleted.")
    else
@ -161,7 +174,7 @@ def run(["rm", nickname]) do
  def run(["toggle_activated", nickname]) do
    Common.start_pleroma()
-    with %User{} = user <- User.get_by_nickname(nickname) do
+    with %User{} = user <- User.get_cached_by_nickname(nickname) do
      {:ok, user} = User.deactivate(user, !user.info.deactivated)
      Mix.shell().info(
@ -176,7 +189,7 @@ def run(["toggle_activated", nickname]) do
  def run(["reset_password", nickname]) do
    Common.start_pleroma()
-    with %User{local: true} = user <- User.get_by_nickname(nickname),
+    with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
         {:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
      Mix.shell().info("Generated password reset token for #{user.nickname}")
@ -198,14 +211,14 @@ def run(["reset_password", nickname]) do
  def run(["unsubscribe", nickname]) do
    Common.start_pleroma()
-    with %User{} = user <- User.get_by_nickname(nickname) do
+    with %User{} = user <- User.get_cached_by_nickname(nickname) do
      Mix.shell().info("Deactivating #{user.nickname}")
      User.deactivate(user)
      {:ok, friends} = User.get_friends(user)
      Enum.each(friends, fn friend ->
-        user = User.get_by_id(user.id)
+        user = User.get_cached_by_id(user.id)
        Mix.shell().info("Unsubscribing #{friend.nickname} from #{user.nickname}")
        User.unfollow(user, friend)
@ -213,7 +226,7 @@ def run(["unsubscribe", nickname]) do
      :timer.sleep(500)
-      user = User.get_by_id(user.id)
+      user = User.get_cached_by_id(user.id)
      if Enum.empty?(user.following) do
        Mix.shell().info("Successfully unsubscribed all followers from #{user.nickname}")
@ -237,7 +250,7 @@ def run(["set", nickname | rest]) do
        ]
      )
-    with %User{local: true} = user <- User.get_by_nickname(nickname) do
+    with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
      user =
        case Keyword.get(options, :moderator) do
          nil -> user
@ -264,7 +277,7 @@ def run(["set", nickname | rest]) do
  def run(["tag", nickname | tags]) do
    Common.start_pleroma()
-    with %User{} = user <- User.get_by_nickname(nickname) do
+    with %User{} = user <- User.get_cached_by_nickname(nickname) do
      user = user |> User.tag(tags)
      Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
@ -277,7 +290,7 @@ def run(["tag", nickname | tags]) do
  def run(["untag", nickname | tags]) do
    Common.start_pleroma()
-    with %User{} = user <- User.get_by_nickname(nickname) do
+    with %User{} = user <- User.get_cached_by_nickname(nickname) do
      user = user |> User.untag(tags)
      Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
@ -287,30 +300,86 @@ def run(["untag", nickname | tags]) do
    end
  end
-  def run(["invite"]) do
+  def run(["invite" | rest]) do
    {options, [], []} =
      OptionParser.parse(rest,
        strict: [
          expires_at: :string,
          max_use: :integer
        ]
      )
    options =
      options
      |> Keyword.update(:expires_at, {:ok, nil}, fn
        nil -> {:ok, nil}
        val -> Date.from_iso8601(val)
      end)
      |> Enum.into(%{})
    Common.start_pleroma()
-    with {:ok, token} <- Pleroma.UserInviteToken.create_token() do
+    with {:ok, val} <- options[:expires_at],
-      Mix.shell().info("Generated user invite token")
+         options = Map.put(options, :expires_at, val),
         {:ok, invite} <- UserInviteToken.create_invite(options) do
      Mix.shell().info(
        "Generated user invite token " <> String.replace(invite.invite_type, "_", " ")
      )
      url =
        Pleroma.Web.Router.Helpers.redirect_url(
          Pleroma.Web.Endpoint,
          :registration_page,
-          token.token
+          invite.token
        )
      IO.puts(url)
    else
-      _ ->
+      error ->
-        Mix.shell().error("Could not create invite token.")
+        Mix.shell().error("Could not create invite token: #{inspect(error)}")
    end
  end
  def run(["invites"]) do
    Common.start_pleroma()
    Mix.shell().info("Invites list:")
    UserInviteToken.list_invites()
    |> Enum.each(fn invite ->
      expire_info =
        with expires_at when not is_nil(expires_at) <- invite.expires_at do
          " | Expires at: #{Date.to_string(expires_at)}"
        end
      using_info =
        with max_use when not is_nil(max_use) <- invite.max_use do
          " | Max use: #{max_use}    Left use: #{max_use - invite.uses}"
        end
      Mix.shell().info(
        "ID: #{invite.id} | Token: #{invite.token} | Token type: #{invite.invite_type} | Used: #{
          invite.used
        }#{expire_info}#{using_info}"
      )
    end)
  end
  def run(["revoke_invite", token]) do
    Common.start_pleroma()
    with {:ok, invite} <- UserInviteToken.find_by_token(token),
         {:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
      Mix.shell().info("Invite for token #{token} was revoked.")
    else
      _ -> Mix.shell().error("No invite found with token #{token}")
    end
  end
  def run(["delete_activities", nickname]) do
    Common.start_pleroma()
-    with %User{local: true} = user <- User.get_by_nickname(nickname) do
+    with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
      User.delete_user_activities(user)
      Mix.shell().info("User #{nickname} statuses deleted.")
    else
--- a/lib/pleroma/PasswordResetToken.ex
+++ b/lib/pleroma/PasswordResetToken.ex
@ -39,7 +39,7 @@ def used_changeset(struct) do
  def reset_password(token, data) do
    with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
-         %User{} = user <- User.get_by_id(token.user_id),
+         %User{} = user <- User.get_cached_by_id(token.user_id),
         {:ok, _user} <- User.reset_password(user, data),
         {:ok, token} <- Repo.update(used_changeset(token)) do
      {:ok, token}
--- a/lib/pleroma/activity.ex
+++ b/lib/pleroma/activity.ex
@ -10,6 +10,7 @@ defmodule Pleroma.Activity do
  alias Pleroma.Object
  alias Pleroma.Repo
  import Ecto.Changeset
  import Ecto.Query
  @type t :: %__MODULE__{}
@ -79,6 +80,13 @@ def get_by_ap_id(ap_id) do
    )
  end
  def change(struct, params \\ %{}) do
    struct
    |> cast(params, [:data])
    |> validate_required([:data])
    |> unique_constraint(:ap_id, name: :activities_unique_apid_index)
  end
  def get_by_ap_id_with_object(ap_id) do
    Repo.one(
      from(
@ -196,28 +204,35 @@ def create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
  def create_by_object_ap_id_with_object(_), do: nil
-  def get_create_by_object_ap_id_with_object(ap_id) do
+  def get_create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
    ap_id
    |> create_by_object_ap_id_with_object()
    |> Repo.one()
  end
  def get_create_by_object_ap_id_with_object(_), do: nil
  defp get_in_reply_to_activity_from_object(%Object{data: %{"inReplyTo" => ap_id}}) do
    get_create_by_object_ap_id_with_object(ap_id)
  end
  defp get_in_reply_to_activity_from_object(_), do: nil
  def get_in_reply_to_activity(%Activity{data: %{"object" => object}}) do
    get_in_reply_to_activity_from_object(Object.normalize(object))
  end
  def normalize(obj) when is_map(obj), do: get_by_ap_id_with_object(obj["id"])
  def normalize(ap_id) when is_binary(ap_id), do: get_by_ap_id_with_object(ap_id)
  def normalize(_), do: nil
  def get_in_reply_to_activity(%Activity{data: %{"object" => %{"inReplyTo" => ap_id}}}) do
    get_create_by_object_ap_id(ap_id)
  end
  def get_in_reply_to_activity(_), do: nil
  def delete_by_ap_id(id) when is_binary(id) do
    by_object_ap_id(id)
    |> select([u], u)
    |> Repo.delete_all()
    |> elem(1)
    |> Enum.find(fn
      %{data: %{"type" => "Create", "object" => ap_id}} when is_binary(ap_id) -> ap_id == id
      %{data: %{"type" => "Create", "object" => %{"id" => ap_id}}} -> ap_id == id
      _ -> nil
    end)
@ -245,50 +260,4 @@ def all_by_actor_and_id(actor, status_ids) do
    |> where([s], s.actor == ^actor)
    |> Repo.all()
  end
  def increase_replies_count(id) do
    Activity
    |> where(id: ^id)
    |> update([a],
      set: [
        data:
          fragment(
            """
            jsonb_set(?, '{object, repliesCount}',
              (coalesce((?->'object'->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
            """,
            a.data,
            a.data
          )
      ]
    )
    |> Repo.update_all([])
    |> case do
      {1, [activity]} -> activity
      _ -> {:error, "Not found"}
    end
  end
  def decrease_replies_count(id) do
    Activity
    |> where(id: ^id)
    |> update([a],
      set: [
        data:
          fragment(
            """
            jsonb_set(?, '{object, repliesCount}',
              (greatest(0, (?->'object'->>'repliesCount')::int - 1))::varchar::jsonb, true)
            """,
            a.data,
            a.data
          )
      ]
    )
    |> Repo.update_all([])
    |> case do
      {1, [activity]} -> activity
      _ -> {:error, "Not found"}
    end
  end
 end
--- a/lib/pleroma/bookmark.ex
+++ b/lib/pleroma/bookmark.ex
@ -0,0 +1,60 @@
 defmodule Pleroma.Bookmark do
  use Ecto.Schema
  import Ecto.Changeset
  import Ecto.Query
  alias Pleroma.Activity
  alias Pleroma.Bookmark
  alias Pleroma.FlakeId
  alias Pleroma.Repo
  alias Pleroma.User
  @type t :: %__MODULE__{}
  schema "bookmarks" do
    belongs_to(:user, User, type: FlakeId)
    belongs_to(:activity, Activity, type: FlakeId)
    timestamps()
  end
  @spec create(FlakeId.t(), FlakeId.t()) :: {:ok, Bookmark.t()} | {:error, Changeset.t()}
  def create(user_id, activity_id) do
    attrs = %{
      user_id: user_id,
      activity_id: activity_id
    }
    %Bookmark{}
    |> cast(attrs, [:user_id, :activity_id])
    |> validate_required([:user_id, :activity_id])
    |> unique_constraint(:activity_id, name: :bookmarks_user_id_activity_id_index)
    |> Repo.insert()
  end
  @spec for_user_query(FlakeId.t()) :: Ecto.Query.t()
  def for_user_query(user_id) do
    Bookmark
    |> where(user_id: ^user_id)
    |> join(:inner, [b], activity in assoc(b, :activity))
    |> preload([b, a], activity: a)
  end
  def get(user_id, activity_id) do
    Bookmark
    |> where(user_id: ^user_id)
    |> where(activity_id: ^activity_id)
    |> Repo.one()
  end
  @spec destroy(FlakeId.t(), FlakeId.t()) :: {:ok, Bookmark.t()} | {:error, Changeset.t()}
  def destroy(user_id, activity_id) do
    from(b in Bookmark,
      where: b.user_id == ^user_id,
      where: b.activity_id == ^activity_id
    )
    |> Repo.one()
    |> Repo.delete()
  end
 end
--- a/lib/pleroma/emails/admin_email.ex
+++ b/lib/pleroma/emails/admin_email.ex
@ -2,7 +2,7 @@
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
-defmodule Pleroma.AdminEmail do
+defmodule Pleroma.Emails.AdminEmail do
  @moduledoc "Admin emails"
  import Swoosh.Email
@ -11,7 +11,10 @@ defmodule Pleroma.AdminEmail do
  defp instance_config, do: Pleroma.Config.get(:instance)
  defp instance_name, do: instance_config()[:name]
-  defp instance_email, do: instance_config()[:email]
+
  defp instance_notify_email do
    Keyword.get(instance_config(), :notify_email, instance_config()[:email])
  end
  defp user_url(user) do
    Helpers.o_status_url(Pleroma.Web.Endpoint, :feed_redirect, user.nickname)
@ -59,7 +62,7 @@ def report(to, reporter, account, statuses, comment) do
    new()
    |> to({to.name, to.email})
-    |> from({instance_name(), instance_email()})
+    |> from({instance_name(), instance_notify_email()})
    |> reply_to({reporter.name, reporter.email})
    |> subject("#{instance_name()} Report")
    |> html_body(html_body)
--- a/lib/pleroma/emails/mailer.ex
+++ b/lib/pleroma/emails/mailer.ex
@ -2,7 +2,7 @@
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
-defmodule Pleroma.Mailer do
+defmodule Pleroma.Emails.Mailer do
  use Swoosh.Mailer, otp_app: :pleroma
  def deliver_async(email, config \\ []) do
--- a/lib/pleroma/emails/user_email.ex
+++ b/lib/pleroma/emails/user_email.ex
@ -2,7 +2,7 @@
 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
-defmodule Pleroma.UserEmail do
+defmodule Pleroma.Emails.UserEmail do
  @moduledoc "User emails"
  import Swoosh.Email
@ -15,7 +15,8 @@ defp instance_config, do: Pleroma.Config.get(:instance)
  defp instance_name, do: instance_config()[:name]
  defp sender do
-    {instance_name(), instance_config()[:email]}
+    email = Keyword.get(instance_config(), :notify_email, instance_config()[:email])
    {instance_name(), email}
  end
  defp recipient(email, nil), do: email
--- a/lib/pleroma/emoji.ex
+++ b/lib/pleroma/emoji.ex
@ -6,7 +6,7 @@ defmodule Pleroma.Emoji do
  @moduledoc """
  The emojis are loaded from:
-    * the built-in Finmojis (if enabled in configuration),
+    * emoji packs in INSTANCE-DIR/emoji
    * the files: `config/emoji.txt` and `config/custom_emoji.txt`
    * glob paths, nested folder is used as tag name for grouping e.g. priv/static/emoji/custom/nested_folder
@ -14,6 +14,8 @@ defmodule Pleroma.Emoji do
  """
  use GenServer
  require Logger
  @type pattern :: Regex.t() | module() | String.t()
  @type patterns :: pattern() | [pattern()]
  @type group_patterns :: keyword(patterns())
@ -79,95 +81,94 @@ def code_change(_old_vsn, state, _extra) do
  end
  defp load do
-    finmoji_enabled = Keyword.get(Application.get_env(:pleroma, :instance), :finmoji_enabled)
+    emoji_dir_path =
      Path.join(
        Pleroma.Config.get!([:instance, :static_dir]),
        "emoji"
      )
    case File.ls(emoji_dir_path) do
      {:error, :enoent} ->
        # The custom emoji directory doesn't exist,
        # don't do anything
        nil
      {:error, e} ->
        # There was some other error
        Logger.error("Could not access the custom emoji directory #{emoji_dir_path}: #{e}")
      {:ok, packs} ->
        # Print the packs we've found
        Logger.info("Found emoji packs: #{Enum.join(packs, ", ")}")
        emojis =
          Enum.flat_map(
            packs,
            fn pack -> load_pack(Path.join(emoji_dir_path, pack)) end
          )
        true = :ets.insert(@ets, emojis)
    end
    # Compat thing for old custom emoji handling & default emoji,
    # it should run even if there are no emoji packs
    shortcode_globs = Application.get_env(:pleroma, :emoji)[:shortcode_globs] || []
    emojis =
-      (load_finmoji(finmoji_enabled) ++
+      (load_from_file("config/emoji.txt") ++
         load_from_file("config/emoji.txt") ++
         load_from_file("config/custom_emoji.txt") ++
         load_from_globs(shortcode_globs))
      |> Enum.reject(fn value -> value == nil end)
    true = :ets.insert(@ets, emojis)
    :ok
  end
-  @finmoji [
+  defp load_pack(pack_dir) do
-    "a_trusted_friend",
+    pack_name = Path.basename(pack_dir)
    "alandislands",
    "association",
    "auroraborealis",
    "baby_in_a_box",
    "bear",
    "black_gold",
    "christmasparty",
    "crosscountryskiing",
    "cupofcoffee",
    "education",
    "fashionista_finns",
    "finnishlove",
    "flag",
    "forest",
    "four_seasons_of_bbq",
    "girlpower",
    "handshake",
    "happiness",
    "headbanger",
    "icebreaker",
    "iceman",
    "joulutorttu",
    "kaamos",
    "kalsarikannit_f",
    "kalsarikannit_m",
    "karjalanpiirakka",
    "kicksled",
    "kokko",
    "lavatanssit",
    "losthopes_f",
    "losthopes_m",
    "mattinykanen",
    "meanwhileinfinland",
    "moominmamma",
    "nordicfamily",
    "out_of_office",
    "peacemaker",
    "perkele",
    "pesapallo",
    "polarbear",
    "pusa_hispida_saimensis",
    "reindeer",
    "sami",
    "sauna_f",
    "sauna_m",
    "sauna_whisk",
    "sisu",
    "stuck",
    "suomimainittu",
    "superfood",
    "swan",
    "the_cap",
    "the_conductor",
    "the_king",
    "the_voice",
    "theoriginalsanta",
    "tomoffinland",
    "torillatavataan",
    "unbreakable",
    "waiting",
    "white_nights",
    "woollysocks"
  ]
-  defp load_finmoji(true) do
+    emoji_txt = Path.join(pack_dir, "emoji.txt")
-    Enum.map(@finmoji, fn finmoji ->
+
-      file_name = "/finmoji/128px/#{finmoji}-128.png"
+    if File.exists?(emoji_txt) do
-      group = match_extra(@groups, file_name)
+      load_from_file(emoji_txt)
-      {finmoji, file_name, to_string(group)}
+    else
      Logger.info(
        "No emoji.txt found for pack \"#{pack_name}\", assuming all .png files are emoji"
      )
      make_shortcode_to_file_map(pack_dir, [".png"])
      |> Enum.map(fn {shortcode, rel_file} ->
        filename = Path.join("/emoji/#{pack_name}", rel_file)
        {shortcode, filename, [to_string(match_extra(@groups, filename))]}
      end)
    end
  end
-  defp load_finmoji(_), do: []
+  def make_shortcode_to_file_map(pack_dir, exts) do
    find_all_emoji(pack_dir, exts)
    |> Enum.map(&Path.relative_to(&1, pack_dir))
    |> Enum.map(fn f -> {f |> Path.basename() |> Path.rootname(), f} end)
    |> Enum.into(%{})
  end
  def find_all_emoji(dir, exts) do
    Enum.reduce(
      File.ls!(dir),
      [],
      fn f, acc ->
        filepath = Path.join(dir, f)
        if File.dir?(filepath) do
          acc ++ find_all_emoji(filepath, exts)
        else
          acc ++ [filepath]
        end
      end
    )
    |> Enum.filter(fn f -> Path.extname(f) in exts end)
  end
  defp load_from_file(file) do
    if File.exists?(file) do
@ -182,11 +183,11 @@ defp load_from_file_stream(stream) do
    |> Stream.map(&String.trim/1)
    |> Stream.map(fn line ->
      case String.split(line, ~r/,\s*/) do
        [name, file, tags] ->
          {name, file, tags}
        [name, file] ->
-          {name, file, to_string(match_extra(@groups, file))}
+          {name, file, [to_string(match_extra(@groups, file))]}
        [name, file | tags] ->
          {name, file, tags}
        _ ->
          nil
@ -209,7 +210,7 @@ defp load_from_globs(globs) do
      tag = match_extra(@groups, Path.join("/", Path.relative_to(path, static_path)))
      shortcode = Path.basename(path, Path.extname(path))
      external_path = Path.join("/", Path.relative_to(path, static_path))
-      {shortcode, external_path, to_string(tag)}
+      {shortcode, external_path, [to_string(tag)]}
    end)
  end
--- a/lib/pleroma/formatter.ex
+++ b/lib/pleroma/formatter.ex
@ -9,20 +9,31 @@ defmodule Pleroma.Formatter do
  alias Pleroma.Web.MediaProxy
  @safe_mention_regex ~r/^(\s*(?<mentions>@.+?\s+)+)(?<rest>.*)/
  @link_regex ~r"((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\(\)\*\+,;=.]+)|[0-9a-z+\-\.]+:[0-9a-z$-_.+!*'(),]+"ui
  @markdown_characters_regex ~r/(`|\*|_|{|}|[|]|\(|\)|#|\+|-|\.|!)/
  @link_regex ~r{((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\(\)\*\+,;=.]+)|[0-9a-z+\-\.]+:[0-9a-z$-_.+!*'(),]+}ui
  # credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
  @auto_linker_config hashtag: true,
                      hashtag_handler: &Pleroma.Formatter.hashtag_handler/4,
                      mention: true,
                      mention_handler: &Pleroma.Formatter.mention_handler/4
  def escape_mention_handler("@" <> nickname = mention, buffer, _, _) do
    case User.get_cached_by_nickname(nickname) do
      %User{} ->
        # escape markdown characters with `\\`
        # (we don't want something like @user__name to be parsed by markdown)
        String.replace(mention, @markdown_characters_regex, "\\\\\\1")
      _ ->
        buffer
    end
  end
  def mention_handler("@" <> nickname, buffer, opts, acc) do
    case User.get_cached_by_nickname(nickname) do
      %User{id: id} = user ->
        ap_id = get_ap_id(user)
-        nickname_text = get_nickname_text(nickname, opts) |> maybe_escape(opts)
+        nickname_text = get_nickname_text(nickname, opts)
        link =
          "<span class='h-card'><a data-user='#{id}' class='u-url mention' href='#{ap_id}'>@<span>#{
@ -70,6 +81,25 @@ def linkify(text, options \\ []) do
    end
  end
  @doc """
  Escapes a special characters in mention names.
  """
  def mentions_escape(text, options \\ []) do
    options =
      Keyword.merge(options,
        mention: true,
        url: false,
        mention_handler: &Pleroma.Formatter.escape_mention_handler/4
      )
    if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
      %{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
      AutoLinker.link(mentions, options) <> AutoLinker.link(rest, options)
    else
      AutoLinker.link(text, options)
    end
  end
  def emojify(text) do
    emojify(text, Emoji.get_all())
  end
@ -140,10 +170,4 @@ defp get_ap_id(%User{ap_id: ap_id}), do: ap_id
  defp get_nickname_text(nickname, %{mentions_format: :full}), do: User.full_nickname(nickname)
  defp get_nickname_text(nickname, _), do: User.local_nickname(nickname)
  defp maybe_escape(str, %{mentions_escape: true}) do
    String.replace(str, @markdown_characters_regex, "\\\\\\1")
  end
  defp maybe_escape(str, _), do: str
 end
--- a/lib/pleroma/gopher/server.ex
+++ b/lib/pleroma/gopher/server.ex
@ -38,6 +38,7 @@ def init([ip, port]) do
 defmodule Pleroma.Gopher.Server.ProtocolHandler do
  alias Pleroma.Activity
  alias Pleroma.HTML
  alias Pleroma.Object
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.Visibility
@ -75,14 +76,14 @@ def render_activities(activities) do
    |> Enum.map(fn activity ->
      user = User.get_cached_by_ap_id(activity.data["actor"])
-      object = activity.data["object"]
+      object = Object.normalize(activity)
      like_count = object["like_count"] || 0
      announcement_count = object["announcement_count"] || 0
      link("Post ##{activity.id} by #{user.nickname}", "/notices/#{activity.id}") <>
        info("#{like_count} likes, #{announcement_count} repeats") <>
        "i\tfake\t(NULL)\t0\r\n" <>
-        info(HTML.strip_tags(String.replace(activity.data["object"]["content"], "<br>", "\r")))
+        info(HTML.strip_tags(String.replace(object["content"], "<br>", "\r")))
    end)
    |> Enum.join("i\tfake\t(NULL)\t0\r\n")
  end
--- a/lib/pleroma/html.ex
+++ b/lib/pleroma/html.ex
@ -28,11 +28,18 @@ def filter_tags(html, scrubber), do: Scrubber.scrub(html, scrubber)
  def filter_tags(html), do: filter_tags(html, nil)
  def strip_tags(html), do: Scrubber.scrub(html, Scrubber.StripTags)
-  def get_cached_scrubbed_html_for_activity(content, scrubbers, activity, key \\ "") do
+  def get_cached_scrubbed_html_for_activity(
        content,
        scrubbers,
        activity,
        key \\ "",
        callback \\ fn x -> x end
      ) do
    key = "#{key}#{generate_scrubber_signature(scrubbers)}|#{activity.id}"
    Cachex.fetch!(:scrubber_cache, key, fn _key ->
-      ensure_scrubbed_html(content, scrubbers, activity.data["object"]["fake"] || false)
+      object = Pleroma.Object.normalize(activity)
      ensure_scrubbed_html(content, scrubbers, object.data["fake"] || false, callback)
    end)
  end
@ -41,24 +48,27 @@ def get_cached_stripped_html_for_activity(content, activity, key) do
      content,
      HtmlSanitizeEx.Scrubber.StripTags,
      activity,
-      key
+      key,
      &HtmlEntities.decode/1
    )
  end
  def ensure_scrubbed_html(
        content,
        scrubbers,
-        false = _fake
+        fake,
        callback
      ) do
-    {:commit, filter_tags(content, scrubbers)}
+    content =
-  end
+      content
      |> filter_tags(scrubbers)
      |> callback.()
-  def ensure_scrubbed_html(
+    if fake do
-        content,
+      {:ignore, content}
-        scrubbers,
+    else
-        true = _fake
+      {:commit, content}
-      ) do
+    end
    {:ignore, filter_tags(content, scrubbers)}
  end
  defp generate_scrubber_signature(scrubber) when is_atom(scrubber) do
@ -105,7 +115,14 @@ defmodule Pleroma.HTML.Scrubber.TwitterText do
  # links
  Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)
-  Meta.allow_tag_with_these_attributes("a", ["name", "title", "class"])
+
  Meta.allow_tag_with_this_attribute_values("a", "class", [
    "hashtag",
    "u-url",
    "mention",
    "u-url mention",
    "mention u-url"
  ])
  Meta.allow_tag_with_this_attribute_values("a", "rel", [
    "tag",
@ -114,12 +131,15 @@ defmodule Pleroma.HTML.Scrubber.TwitterText do
    "noreferrer"
  ])
  Meta.allow_tag_with_these_attributes("a", ["name", "title"])
  # paragraphs and linebreaks
  Meta.allow_tag_with_these_attributes("br", [])
  Meta.allow_tag_with_these_attributes("p", [])
  # microformats
-  Meta.allow_tag_with_these_attributes("span", ["class"])
+  Meta.allow_tag_with_this_attribute_values("span", "class", ["h-card"])
  Meta.allow_tag_with_these_attributes("span", [])
  # allow inline images for custom emoji
  @allow_inline_images Keyword.get(@markup, :allow_inline_images)
@ -154,7 +174,14 @@ defmodule Pleroma.HTML.Scrubber.Default do
  Meta.strip_comments()
  Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)
-  Meta.allow_tag_with_these_attributes("a", ["name", "title", "class"])
+
  Meta.allow_tag_with_this_attribute_values("a", "class", [
    "hashtag",
    "u-url",
    "mention",
    "u-url mention",
    "mention u-url"
  ])
  Meta.allow_tag_with_this_attribute_values("a", "rel", [
    "tag",
@ -163,6 +190,8 @@ defmodule Pleroma.HTML.Scrubber.Default do
    "noreferrer"
  ])
  Meta.allow_tag_with_these_attributes("a", ["name", "title"])
  Meta.allow_tag_with_these_attributes("abbr", ["title"])
  Meta.allow_tag_with_these_attributes("b", [])
@ -176,11 +205,13 @@ defmodule Pleroma.HTML.Scrubber.Default do
  Meta.allow_tag_with_these_attributes("ol", [])
  Meta.allow_tag_with_these_attributes("p", [])
  Meta.allow_tag_with_these_attributes("pre", [])
  Meta.allow_tag_with_these_attributes("span", ["class"])
  Meta.allow_tag_with_these_attributes("strong", [])
  Meta.allow_tag_with_these_attributes("u", [])
  Meta.allow_tag_with_these_attributes("ul", [])
  Meta.allow_tag_with_this_attribute_values("span", "class", ["h-card"])
  Meta.allow_tag_with_these_attributes("span", [])
  @allow_inline_images Keyword.get(@markup, :allow_inline_images)
  if @allow_inline_images do
--- a/lib/pleroma/list.ex
+++ b/lib/pleroma/list.ex
@ -80,7 +80,7 @@ def get_lists_from_activity(%Activity{actor: ap_id}) do
  # Get lists to which the account belongs.
  def get_lists_account_belongs(%User{} = owner, account_id) do
-    user = User.get_by_id(account_id)
+    user = User.get_cached_by_id(account_id)
    query =
      from(
--- a/lib/pleroma/notification.ex
+++ b/lib/pleroma/notification.ex
@ -98,6 +98,14 @@ def clear(user) do
    |> Repo.delete_all()
  end
  def destroy_multiple(%{id: user_id} = _user, ids) do
    from(n in Notification,
      where: n.id in ^ids,
      where: n.user_id == ^user_id
    )
    |> Repo.delete_all()
  end
  def dismiss(%{id: user_id} = _user, id) do
    notification = Repo.get(Notification, id)
@ -122,13 +130,7 @@ def create_notifications(_), do: {:ok, []}
  # TODO move to sql, too.
  def create_notification(%Activity{} = activity, %User{} = user) do
-    unless User.blocks?(user, %{ap_id: activity.data["actor"]}) or
+    unless skip?(activity, user) do
             CommonAPI.thread_muted?(user, activity) or user.ap_id == activity.data["actor"] or
             (activity.data["type"] == "Follow" and
                Enum.any?(Notification.for_user(user), fn notif ->
                  notif.activity.data["type"] == "Follow" and
                    notif.activity.data["actor"] == activity.data["actor"]
                end)) do
      notification = %Notification{user_id: user.id, activity: activity}
      {:ok, notification} = Repo.insert(notification)
      Pleroma.Web.Streamer.stream("user", notification)
@ -148,10 +150,65 @@ def get_notified_from_activity(
      []
      |> Utils.maybe_notify_to_recipients(activity)
      |> Utils.maybe_notify_mentioned_recipients(activity)
      |> Utils.maybe_notify_subscribers(activity)
      |> Enum.uniq()
    User.get_users_from_set(recipients, local_only)
  end
  def get_notified_from_activity(_, _local_only), do: []
  def skip?(activity, user) do
    [:self, :blocked, :local, :muted, :followers, :follows, :recently_followed]
    |> Enum.any?(&skip?(&1, activity, user))
  end
  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?(:local, %{local: true}, %{info: %{notification_settings: %{"local" => false}}}),
    do: true
  def skip?(:local, %{local: false}, %{info: %{notification_settings: %{"remote" => false}}}),
    do: true
  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,
        %{info: %{notification_settings: %{"followers" => false}}} = user
      ) do
    actor = activity.data["actor"]
    follower = User.get_cached_by_ap_id(actor)
    User.following?(follower, user)
  end
  def skip?(:follows, activity, %{info: %{notification_settings: %{"follows" => false}}} = user) do
    actor = activity.data["actor"]
    followed = User.get_cached_by_ap_id(actor)
    User.following?(user, followed)
  end
  def skip?(:recently_followed, %{data: %{"type" => "Follow"}} = activity, user) do
    actor = activity.data["actor"]
    Notification.for_user(user)
    |> Enum.any?(fn
      %{activity: %{data: %{"type" => "Follow", "actor" => ^actor}}} -> true
      _ -> false
    end)
  end
  def skip?(_, _, _), do: false
 end
--- a/lib/pleroma/object.ex
+++ b/lib/pleroma/object.ex
@ -7,6 +7,7 @@ defmodule Pleroma.Object do
  alias Pleroma.Activity
  alias Pleroma.Object
  alias Pleroma.Object.Fetcher
  alias Pleroma.ObjectTombstone
  alias Pleroma.Repo
  alias Pleroma.User
@ -40,41 +41,44 @@ def get_by_ap_id(ap_id) do
    Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
  end
  def normalize(_, fetch_remote \\ true)
  # 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(%Activity{object: %Object{} = object}), do: object
+  def normalize(%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
  # preloaded.
-  def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}) do
+  def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, fetch_remote) do
    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)
+    normalize(ap_id, fetch_remote)
  end
-  def normalize(%Activity{data: %{"object" => ap_id}}) do
+  def normalize(%Activity{data: %{"object" => ap_id}}, fetch_remote) do
    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)
+    normalize(ap_id, fetch_remote)
  end
  # Old way, try fetching the object through cache.
-  def normalize(%{"id" => ap_id}), do: normalize(ap_id)
+  def normalize(%{"id" => ap_id}, fetch_remote), do: normalize(ap_id, fetch_remote)
-  def normalize(ap_id) 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(_), do: nil
+  def normalize(ap_id, true) when is_binary(ap_id), do: Fetcher.fetch_object_from_id!(ap_id)
  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
@ -0,0 +1,61 @@
 defmodule Pleroma.Object.Containment do
  @moduledoc """
  # Object Containment
  This module contains some useful functions for containing objects to specific
  origins and determining those origins.  They previously lived in the
  ActivityPub `Transmogrifier` module.
  Object containment is an important step in validating remote objects to prevent
  spoofing, therefore removal of object containment functions is NOT recommended.
  """
  def get_actor(%{"actor" => actor}) when is_binary(actor) do
    actor
  end
  def get_actor(%{"actor" => actor}) when is_list(actor) do
    if is_binary(Enum.at(actor, 0)) do
      Enum.at(actor, 0)
    else
      Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
      |> Map.get("id")
    end
  end
  def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
    id
  end
  def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
    get_actor(%{"actor" => actor})
  end
  @doc """
  Checks that an imported AP object's actor matches the domain it came from.
  """
  def contain_origin(_id, %{"actor" => nil}), do: :error
  def contain_origin(id, %{"actor" => _actor} = params) do
    id_uri = URI.parse(id)
    actor_uri = URI.parse(get_actor(params))
    if id_uri.host == actor_uri.host do
      :ok
    else
      :error
    end
  end
  def contain_origin_from_id(_id, %{"id" => nil}), do: :error
  def contain_origin_from_id(id, %{"id" => other_id} = _params) do
    id_uri = URI.parse(id)
    other_uri = URI.parse(other_id)
    if id_uri.host == other_uri.host do
      :ok
    else
      :error
    end
  end
 end
--- a/lib/pleroma/object/fetcher.ex
+++ b/lib/pleroma/object/fetcher.ex
@ -0,0 +1,75 @@
 defmodule Pleroma.Object.Fetcher do
  alias Pleroma.Object
  alias Pleroma.Object.Containment
  alias Pleroma.Web.ActivityPub.Transmogrifier
  alias Pleroma.Web.OStatus
  require Logger
  @httpoison Application.get_env(:pleroma, :httpoison)
  # TODO:
  # This will create a Create activity, which we need internally at the moment.
  def fetch_object_from_id(id) 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),
           nil <- Object.normalize(data, false),
           params <- %{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
             "actor" => data["actor"] || data["attributedTo"],
             "object" => data
           },
           :ok <- Containment.contain_origin(id, params),
           {:ok, activity} <- Transmogrifier.handle_incoming(params) do
        {:ok, Object.normalize(activity, false)}
      else
        {:error, {:reject, nil}} ->
          {:reject, nil}
        object = %Object{} ->
          {:ok, object}
        _e ->
          Logger.info("Couldn't get object via AP, trying out OStatus fetching...")
          case OStatus.fetch_activity_from_url(id) do
            {:ok, [activity | _]} -> {:ok, Object.normalize(activity, false)}
            e -> e
          end
      end
    end
  end
  def fetch_object_from_id!(id) do
    with {:ok, object} <- fetch_object_from_id(id) do
      object
    else
      _e ->
        nil
    end
  end
  def fetch_and_contain_remote_object_from_id(id) do
    Logger.info("Fetching object #{id} via AP")
    with true <- String.starts_with?(id, "http"),
         {:ok, %{body: body, status: code}} when code in 200..299 <-
           @httpoison.get(
             id,
             [{:Accept, "application/activity+json"}]
           ),
         {:ok, data} <- Jason.decode(body),
         :ok <- Containment.contain_origin_from_id(id, data) do
      {:ok, data}
    else
      e ->
        {:error, e}
    end
  end
 end
--- a/lib/pleroma/pagination.ex
+++ b/lib/pleroma/pagination.ex
@ -36,6 +36,12 @@ defp cast_params(params) do
      limit: :integer
    }
    params =
      Enum.reduce(params, %{}, fn
        {key, _value}, acc when is_atom(key) -> Map.drop(acc, [key])
        {key, value}, acc -> Map.put(acc, key, value)
      end)
    changeset = cast({%{}, param_types}, params, Map.keys(param_types))
    changeset.changes
  end
--- a/lib/pleroma/user.ex
+++ b/lib/pleroma/user.ex
@ -10,6 +10,7 @@ defmodule Pleroma.User do
  alias Comeonin.Pbkdf2
  alias Pleroma.Activity
  alias Pleroma.Bookmark
  alias Pleroma.Formatter
  alias Pleroma.Notification
  alias Pleroma.Object
@ -53,8 +54,8 @@ defmodule Pleroma.User do
    field(:search_rank, :float, virtual: true)
    field(:search_type, :integer, virtual: true)
    field(:tags, {:array, :string}, default: [])
    field(:bookmarks, {:array, :string}, default: [])
    field(:last_refreshed_at, :naive_datetime_usec)
    has_many(:bookmarks, Bookmark)
    has_many(:notifications, Notification)
    has_many(:registrations, Registration)
    embeds_one(:info, Pleroma.User.Info)
@ -269,6 +270,7 @@ defp autofollow_users(user) do
  def register(%Ecto.Changeset{} = changeset) do
    with {:ok, user} <- Repo.insert(changeset),
         {:ok, user} <- autofollow_users(user),
         {:ok, user} <- set_cache(user),
         {:ok, _} <- Pleroma.User.WelcomeMessage.post_welcome_message_to_user(user),
         {:ok, _} <- try_send_confirmation_email(user) do
      {:ok, user}
@ -279,8 +281,10 @@ def try_send_confirmation_email(%User{} = user) do
    if user.info.confirmation_pending &&
         Pleroma.Config.get([:instance, :account_activation_required]) do
      user
-      |> Pleroma.UserEmail.account_confirmation_email()
+      |> Pleroma.Emails.UserEmail.account_confirmation_email()
-      |> Pleroma.Mailer.deliver_async()
+      |> Pleroma.Emails.Mailer.deliver_async()
      {:ok, :enqueued}
    else
      {:ok, :noop}
    end
@ -419,7 +423,7 @@ def follow_import(%User{} = follower, followed_identifiers)
    Enum.map(
      followed_identifiers,
      fn followed_identifier ->
-        with %User{} = followed <- get_or_fetch(followed_identifier),
+        with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
             {:ok, follower} <- maybe_direct_follow(follower, followed),
             {:ok, _} <- ActivityPub.follow(follower, followed) do
          followed
@ -451,10 +455,13 @@ def get_by_guessed_nickname(ap_id) do
    name = List.last(String.split(ap_id, "/"))
    nickname = "#{name}@#{domain}"
-    get_by_nickname(nickname)
+    get_cached_by_nickname(nickname)
  end
-  def set_cache(user) do
+  def set_cache({:ok, user}), do: set_cache(user)
  def set_cache({:error, err}), do: {:error, err}
  def set_cache(%User{} = user) do
    Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
    Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
    Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
@ -500,7 +507,15 @@ def get_cached_by_id(id) do
  def get_cached_by_nickname(nickname) do
    key = "nickname:#{nickname}"
-    Cachex.fetch!(:user_cache, key, fn _ -> get_or_fetch_by_nickname(nickname) end)
+
    Cachex.fetch!(:user_cache, key, fn ->
      user_result = get_or_fetch_by_nickname(nickname)
      case user_result do
        {:ok, user} -> {:commit, user}
        {:error, _error} -> {:ignore, nil}
      end
    end)
  end
  def get_cached_by_nickname_or_id(nickname_or_id) do
@ -536,18 +551,19 @@ def fetch_by_nickname(nickname) do
  def get_or_fetch_by_nickname(nickname) do
    with %User{} = user <- get_by_nickname(nickname) do
-      user
+      {:ok, user}
    else
      _e ->
        with [_nick, _domain] <- String.split(nickname, "@"),
             {:ok, user} <- fetch_by_nickname(nickname) do
          if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
            # TODO turn into job
            {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
          end
-          user
+          {:ok, user}
        else
-          _e -> nil
+          _e -> {:error, "not found " <> nickname}
        end
    end
  end
@ -894,7 +910,7 @@ def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_i
    Enum.map(
      blocked_identifiers,
      fn blocked_identifier ->
-        with %User{} = blocked <- get_or_fetch(blocked_identifier),
+        with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
             {:ok, blocker} <- block(blocker, blocked),
             {:ok, _} <- ActivityPub.block(blocker, blocked) do
          blocked
@ -931,6 +947,38 @@ def unmute(muter, %{ap_id: ap_id}) do
    update_and_set_cache(cng)
  end
  def subscribe(subscriber, %{ap_id: ap_id}) do
    deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
    with %User{} = subscribed <- get_cached_by_ap_id(ap_id) do
      blocked = blocks?(subscribed, subscriber) and deny_follow_blocked
      if blocked do
        {:error, "Could not subscribe: #{subscribed.nickname} is blocking you"}
      else
        info_cng =
          subscribed.info
          |> User.Info.add_to_subscribers(subscriber.ap_id)
        change(subscribed)
        |> put_embed(:info, info_cng)
        |> update_and_set_cache()
      end
    end
  end
  def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
    with %User{} = user <- get_cached_by_ap_id(ap_id) do
      info_cng =
        user.info
        |> User.Info.remove_from_subscribers(unsubscriber.ap_id)
      change(user)
      |> put_embed(:info, info_cng)
      |> update_and_set_cache()
    end
  end
  def block(blocker, %User{ap_id: ap_id} = blocked) do
    # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
    blocker =
@ -941,10 +989,20 @@ def block(blocker, %User{ap_id: ap_id} = blocked) do
        blocker
      end
    blocker =
      if subscribed_to?(blocked, blocker) do
        {:ok, blocker} = unsubscribe(blocked, blocker)
        blocker
      else
        blocker
      end
    if following?(blocked, blocker) do
      unfollow(blocked, blocker)
    end
    {:ok, blocker} = update_follower_count(blocker)
    info_cng =
      blocker.info
      |> User.Info.add_to_block(ap_id)
@ -958,7 +1016,7 @@ def block(blocker, %User{ap_id: ap_id} = blocked) do
  # helper to handle the block given only an actor's AP id
  def block(blocker, %{ap_id: ap_id}) do
-    block(blocker, User.get_by_ap_id(ap_id))
+    block(blocker, get_cached_by_ap_id(ap_id))
  end
  def unblock(blocker, %{ap_id: ap_id}) do
@ -987,12 +1045,21 @@ def blocks?(user, %{ap_id: ap_id}) do
      end)
  end
  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)
    end
  end
  def muted_users(user),
    do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))
  def blocked_users(user),
    do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))
  def subscribers(user),
    do: Repo.all(from(u in User, where: u.ap_id in ^user.info.subscribers))
  def block_domain(user, domain) do
    info_cng =
      user.info
@ -1090,6 +1157,14 @@ def deactivate(%User{} = user, status \\ true) do
    update_and_set_cache(cng)
  end
  def update_notification_settings(%User{} = user, settings \\ %{}) do
    info_changeset = User.Info.update_notification_settings(user.info, settings)
    change(user)
    |> put_embed(:info, info_changeset)
    |> update_and_set_cache()
  end
  def delete(%User{} = user) do
    {:ok, user} = User.deactivate(user)
@ -1135,41 +1210,41 @@ def fetch_by_ap_id(ap_id) do
    case ap_try do
      {:ok, user} ->
-        user
+        {:ok, user}
      _ ->
        case OStatus.make_user(ap_id) do
-          {:ok, user} -> user
+          {:ok, user} -> {:ok, user}
          _ -> {:error, "Could not fetch by AP id"}
        end
    end
  end
  def get_or_fetch_by_ap_id(ap_id) do
-    user = get_by_ap_id(ap_id)
+    user = get_cached_by_ap_id(ap_id)
    if !is_nil(user) and !User.needs_update?(user) do
-      user
+      {:ok, user}
    else
      # Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
      should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])
-      user = fetch_by_ap_id(ap_id)
+      resp = fetch_by_ap_id(ap_id)
      if should_fetch_initial do
-        with %User{} = user do
+        with {:ok, %User{} = user} = resp do
          {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
        end
      end
-      user
+      resp
    end
  end
  def get_or_create_instance_user do
    relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
-    if user = get_by_ap_id(relay_uri) do
+    if user = get_cached_by_ap_id(relay_uri) do
      user
    else
      changes =
@ -1204,7 +1279,7 @@ def public_key_from_info(%{magic_key: magic_key}) do
  end
  def get_public_key_for_ap_id(ap_id) do
-    with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
+    with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
         {:ok, public_key} <- public_key_from_info(user.info) do
      {:ok, public_key}
    else
@ -1216,13 +1291,11 @@ defp blank?(""), do: nil
  defp blank?(n), do: n
  def insert_or_update_user(data) do
    data =
    data
    |> Map.put(:name, blank?(data[:name]) || data[:nickname])
-
+    |> remote_user_creation()
-    cs = User.remote_user_creation(data)
+    |> Repo.insert(on_conflict: :replace_all, conflict_target: :nickname)
-
+    |> set_cache()
    Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
  end
  def ap_enabled?(%User{local: true}), do: true
@ -1238,8 +1311,8 @@ def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
  # this is because we have synchronous follow APIs and need to simulate them
  # with an async handshake
  def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
-    with %User{} = a <- User.get_by_id(a.id),
+    with %User{} = a <- User.get_cached_by_id(a.id),
-         %User{} = b <- User.get_by_id(b.id) do
+         %User{} = b <- User.get_cached_by_id(b.id) do
      {:ok, a, b}
    else
      _e ->
@ -1249,8 +1322,8 @@ def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
  def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
    with :ok <- :timer.sleep(timeout),
-         %User{} = a <- User.get_by_id(a.id),
+         %User{} = a <- User.get_cached_by_id(a.id),
-         %User{} = b <- User.get_by_id(b.id) do
+         %User{} = b <- User.get_cached_by_id(b.id) do
      {:ok, a, b}
    else
      _e ->
@ -1289,7 +1362,7 @@ def tag(user_identifiers, tags) when is_list(user_identifiers) do
  end
  def tag(nickname, tags) when is_binary(nickname),
-    do: tag(User.get_by_nickname(nickname), tags)
+    do: tag(get_by_nickname(nickname), tags)
  def tag(%User{} = user, tags),
    do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
@ -1301,7 +1374,7 @@ def untag(user_identifiers, tags) when is_list(user_identifiers) do
  end
  def untag(nickname, tags) when is_binary(nickname),
-    do: untag(User.get_by_nickname(nickname), tags)
+    do: untag(get_by_nickname(nickname), tags)
  def untag(%User{} = user, tags),
    do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
@ -1315,22 +1388,6 @@ defp update_tags(%User{} = user, new_tags) do
    updated_user
  end
  def bookmark(%User{} = user, status_id) do
    bookmarks = Enum.uniq(user.bookmarks ++ [status_id])
    update_bookmarks(user, bookmarks)
  end
  def unbookmark(%User{} = user, status_id) do
    bookmarks = Enum.uniq(user.bookmarks -- [status_id])
    update_bookmarks(user, bookmarks)
  end
  def update_bookmarks(%User{} = user, bookmarks) do
    user
    |> change(%{bookmarks: bookmarks})
    |> update_and_set_cache
  end
  defp normalize_tags(tags) do
    [tags]
    |> List.flatten()
--- a/lib/pleroma/user/info.ex
+++ b/lib/pleroma/user/info.ex
@ -22,6 +22,7 @@ defmodule Pleroma.User.Info do
    field(:domain_blocks, {:array, :string}, default: [])
    field(:mutes, {:array, :string}, default: [])
    field(:muted_reblogs, {:array, :string}, default: [])
    field(:subscribers, {:array, :string}, default: [])
    field(:deactivated, :boolean, default: false)
    field(:no_rich_text, :boolean, default: false)
    field(:ap_enabled, :boolean, default: false)
@ -37,9 +38,14 @@ defmodule Pleroma.User.Info do
    field(:salmon, :string, default: nil)
    field(:hide_followers, :boolean, default: false)
    field(:hide_follows, :boolean, default: false)
    field(:hide_favorites, :boolean, default: true)
    field(:pinned_activities, {:array, :string}, default: [])
    field(:flavour, :string, default: nil)
    field(:notification_settings, :map,
      default: %{"remote" => true, "local" => true, "followers" => true, "follows" => true}
    )
    # Found in the wild
    # ap_id -> Where is this used?
    # bio -> Where is this used?
@ -57,6 +63,19 @@ def set_activation_status(info, deactivated) do
    |> validate_required([:deactivated])
  end
  def update_notification_settings(info, settings) do
    notification_settings =
      info.notification_settings
      |> Map.merge(settings)
      |> Map.take(["remote", "local", "followers", "follows"])
    params = %{notification_settings: notification_settings}
    info
    |> cast(params, [:notification_settings])
    |> validate_required([:notification_settings])
  end
  def add_to_note_count(info, number) do
    set_note_count(info, info.note_count + number)
  end
@ -93,6 +112,14 @@ def set_blocks(info, blocks) do
    |> validate_required([:blocks])
  end
  def set_subscribers(info, subscribers) do
    params = %{subscribers: subscribers}
    info
    |> cast(params, [:subscribers])
    |> validate_required([:subscribers])
  end
  def add_to_mutes(info, muted) do
    set_mutes(info, Enum.uniq([muted | info.mutes]))
  end
@ -109,6 +136,14 @@ def remove_from_block(info, blocked) do
    set_blocks(info, List.delete(info.blocks, blocked))
  end
  def add_to_subscribers(info, subscribed) do
    set_subscribers(info, Enum.uniq([subscribed | info.subscribers]))
  end
  def remove_from_subscribers(info, subscribed) do
    set_subscribers(info, List.delete(info.subscribers, subscribed))
  end
  def set_domain_blocks(info, domain_blocks) do
    params = %{domain_blocks: domain_blocks}
@ -168,6 +203,7 @@ def profile_update(info, params) do
      :banner,
      :hide_follows,
      :hide_followers,
      :hide_favorites,
      :background,
      :show_role
    ])
@ -191,14 +227,6 @@ def confirmation_changeset(info, params) do
    cast(info, params, [:confirmation_pending, :confirmation_token])
  end
  def mastodon_profile_update(info, params) do
    info
    |> cast(params, [
      :locked,
      :banner
    ])
  end
  def mastodon_settings_update(info, settings) do
    params = %{settings: settings}
--- a/lib/pleroma/user_invite_token.ex
+++ b/lib/pleroma/user_invite_token.ex
@ -6,40 +6,119 @@ defmodule Pleroma.UserInviteToken do
  use Ecto.Schema
  import Ecto.Changeset
-
+  import Ecto.Query
  alias Pleroma.Repo
  alias Pleroma.UserInviteToken
  @type t :: %__MODULE__{}
  @type token :: String.t()
  schema "user_invite_tokens" do
    field(:token, :string)
    field(:used, :boolean, default: false)
    field(:max_use, :integer)
    field(:expires_at, :date)
    field(:uses, :integer, default: 0)
    field(:invite_type, :string)
    timestamps()
  end
-  def create_token do
+  @spec create_invite(map()) :: UserInviteToken.t()
-    token = :crypto.strong_rand_bytes(32) |> Base.url_encode64()
+  def create_invite(params \\ %{}) do
    %UserInviteToken{}
    |> cast(params, [:max_use, :expires_at])
    |> add_token()
    |> assign_type()
    |> Repo.insert()
  end
-    token = %UserInviteToken{
+  defp add_token(changeset) do
-      used: false,
+    token = :crypto.strong_rand_bytes(32) |> Base.url_encode64()
-      token: token
+    put_change(changeset, :token, token)
  end
  defp assign_type(%{changes: %{max_use: _max_use, expires_at: _expires_at}} = changeset) do
    put_change(changeset, :invite_type, "reusable_date_limited")
  end
  defp assign_type(%{changes: %{expires_at: _expires_at}} = changeset) do
    put_change(changeset, :invite_type, "date_limited")
  end
  defp assign_type(%{changes: %{max_use: _max_use}} = changeset) do
    put_change(changeset, :invite_type, "reusable")
  end
  defp assign_type(changeset), do: put_change(changeset, :invite_type, "one_time")
  @spec list_invites() :: [UserInviteToken.t()]
  def list_invites do
    query = from(u in UserInviteToken, order_by: u.id)
    Repo.all(query)
  end
  @spec update_invite!(UserInviteToken.t(), map()) :: UserInviteToken.t() | no_return()
  def update_invite!(invite, changes) do
    change(invite, changes) |> Repo.update!()
  end
  @spec update_invite(UserInviteToken.t(), map()) ::
          {:ok, UserInviteToken.t()} | {:error, Changeset.t()}
  def update_invite(invite, changes) do
    change(invite, changes) |> Repo.update()
  end
  @spec find_by_token!(token()) :: UserInviteToken.t() | no_return()
  def find_by_token!(token), do: Repo.get_by!(UserInviteToken, token: token)
  @spec find_by_token(token()) :: {:ok, UserInviteToken.t()} | nil
  def find_by_token(token) do
    with invite <- Repo.get_by(UserInviteToken, token: token) do
      {:ok, invite}
    end
  end
  @spec valid_invite?(UserInviteToken.t()) :: boolean()
  def valid_invite?(%{invite_type: "one_time"} = invite) do
    not invite.used
  end
  def valid_invite?(%{invite_type: "date_limited"} = invite) do
    not_overdue_date?(invite) and not invite.used
  end
  def valid_invite?(%{invite_type: "reusable"} = invite) do
    invite.uses < invite.max_use and not invite.used
  end
  def valid_invite?(%{invite_type: "reusable_date_limited"} = invite) do
    not_overdue_date?(invite) and invite.uses < invite.max_use and not invite.used
  end
  defp not_overdue_date?(%{expires_at: expires_at}) do
    Date.compare(Date.utc_today(), expires_at) in [:lt, :eq]
  end
  @spec update_usage!(UserInviteToken.t()) :: nil | UserInviteToken.t() | no_return()
  def update_usage!(%{invite_type: "date_limited"}), do: nil
  def update_usage!(%{invite_type: "one_time"} = invite),
    do: update_invite!(invite, %{used: true})
  def update_usage!(%{invite_type: invite_type} = invite)
      when invite_type == "reusable" or invite_type == "reusable_date_limited" do
    changes = %{
      uses: invite.uses + 1
    }
-    Repo.insert(token)
+    changes =
-  end
+      if changes.uses >= invite.max_use do
-
+        Map.put(changes, :used, true)
  def used_changeset(struct) do
    struct
    |> cast(%{}, [])
    |> put_change(:used, true)
  end
  def mark_as_used(token) do
    with %{used: false} = token <- Repo.get_by(UserInviteToken, %{token: token}),
         {:ok, token} <- Repo.update(used_changeset(token)) do
      {:ok, token}
      else
-      _e -> {:error, token}
+        changes
      end
    update_invite!(invite, changes)
  end
 end
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@ -8,13 +8,14 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
  alias Pleroma.Instances
  alias Pleroma.Notification
  alias Pleroma.Object
  alias Pleroma.Object.Fetcher
  alias Pleroma.Pagination
  alias Pleroma.Repo
  alias Pleroma.Upload
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.MRF
  alias Pleroma.Web.ActivityPub.Transmogrifier
  alias Pleroma.Web.Federator
  alias Pleroma.Web.OStatus
  alias Pleroma.Web.WebFinger
  import Ecto.Query
@ -91,12 +92,10 @@ def decrease_note_count_if_public(actor, object) do
  end
  def increase_replies_count_if_reply(%{
-        "object" =>
+        "object" => %{"inReplyTo" => reply_ap_id} = object,
          %{"inReplyTo" => reply_ap_id, "inReplyToStatusId" => reply_status_id} = object,
        "type" => "Create"
      }) do
    if is_public?(object) do
      Activity.increase_replies_count(reply_status_id)
      Object.increase_replies_count(reply_ap_id)
    end
  end
@ -104,10 +103,9 @@ def increase_replies_count_if_reply(%{
  def increase_replies_count_if_reply(_create_data), do: :noop
  def decrease_replies_count_if_reply(%Object{
-        data: %{"inReplyTo" => reply_ap_id, "inReplyToStatusId" => reply_status_id} = object
+        data: %{"inReplyTo" => reply_ap_id} = object
      }) do
    if is_public?(object) do
      Activity.decrease_replies_count(reply_status_id)
      Object.decrease_replies_count(reply_ap_id)
    end
  end
@ -122,7 +120,7 @@ def insert(map, local \\ true, fake \\ false) when is_map(map) do
         {:ok, map} <- MRF.filter(map),
         {recipients, _, _} = get_recipients(map),
         {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
-         {:ok, object} <- insert_full_object(map) do
+         {:ok, map, object} <- insert_full_object(map) do
      {:ok, activity} =
        Repo.insert(%Activity{
          data: map,
@ -183,12 +181,14 @@ def stream_out(activity) do
        end
        if activity.data["type"] in ["Create"] do
-          activity.data["object"]
+          object = Object.normalize(activity)
          object.data
          |> Map.get("tag", [])
          |> Enum.filter(fn tag -> is_bitstring(tag) end)
          |> Enum.each(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)
-          if activity.data["object"]["attachment"] != [] do
+          if object.data["attachment"] != [] do
            Pleroma.Web.Streamer.stream("public:media", activity)
            if activity.local do
@ -200,7 +200,7 @@ def stream_out(activity) do
        if !Enum.member?(activity.data["cc"] || [], public) &&
             !Enum.member?(
               activity.data["to"],
-               User.get_by_ap_id(activity.data["actor"]).follower_address
+               User.get_cached_by_ap_id(activity.data["actor"]).follower_address
             ),
           do: Pleroma.Web.Streamer.stream("direct", activity)
      end
@ -451,8 +451,8 @@ def flag(
         :ok <- maybe_federate(activity) do
      Enum.each(User.all_superusers(), fn superuser ->
        superuser
-        |> Pleroma.AdminEmail.report(actor, account, statuses, content)
+        |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
-        |> Pleroma.Mailer.deliver_async()
+        |> Pleroma.Emails.Mailer.deliver_async()
      end)
      {:ok, activity}
@ -504,7 +504,7 @@ def fetch_public_activities(opts \\ %{}) do
    q
    |> restrict_unlisted()
-    |> Repo.all()
+    |> Pagination.fetch_paginated(opts)
    |> Enum.reverse()
  end
@ -583,37 +583,49 @@ defp restrict_since(query, %{"since_id" => since_id}) do
  defp restrict_since(query, _), do: query
  defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
    raise "Can't use the child object without preloading!"
  end
  defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
       when is_list(tag_reject) and tag_reject != [] do
    from(
-      activity in query,
+      [_activity, object] in query,
-      where: fragment(~s(\(not \(? #> '{"object","tag"}'\) \\?| ?\)), activity.data, ^tag_reject)
+      where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
    )
  end
  defp restrict_tag_reject(query, _), do: query
  defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
    raise "Can't use the child object without preloading!"
  end
  defp restrict_tag_all(query, %{"tag_all" => tag_all})
       when is_list(tag_all) and tag_all != [] do
    from(
-      activity in query,
+      [_activity, object] in query,
-      where: fragment(~s(\(? #> '{"object","tag"}'\) \\?& ?), activity.data, ^tag_all)
+      where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
    )
  end
  defp restrict_tag_all(query, _), do: query
  defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
    raise "Can't use the child object without preloading!"
  end
  defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
    from(
-      activity in query,
+      [_activity, object] in query,
-      where: fragment(~s(\(? #> '{"object","tag"}'\) \\?| ?), activity.data, ^tag)
+      where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
    )
  end
  defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
    from(
-      activity in query,
+      [_activity, object] in query,
-      where: fragment(~s(? <@ (? #> '{"object","tag"}'\)), ^tag, activity.data)
+      where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
    )
  end
@ -647,26 +659,12 @@ defp restrict_recipients(query, recipients, user) do
    )
  end
  defp restrict_limit(query, %{"limit" => limit}) do
    from(activity in query, limit: ^limit)
  end
  defp restrict_limit(query, _), do: query
  defp restrict_local(query, %{"local_only" => true}) do
    from(activity in query, where: activity.local == true)
  end
  defp restrict_local(query, _), do: query
  defp restrict_max(query, %{"max_id" => ""}), do: query
  defp restrict_max(query, %{"max_id" => max_id}) do
    from(activity in query, where: activity.id < ^max_id)
  end
  defp restrict_max(query, _), do: query
  defp restrict_actor(query, %{"actor_id" => actor_id}) do
    from(activity in query, where: activity.actor == ^actor_id)
  end
@ -692,10 +690,14 @@ defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
  defp restrict_favorited_by(query, _), do: query
  defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
    raise "Can't use the child object without preloading!"
  end
  defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
    from(
-      activity in query,
+      [_activity, object] in query,
-      where: fragment(~s(not (? #> '{"object","attachment"}' = ?\)), activity.data, ^[])
+      where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
    )
  end
@ -737,7 +739,14 @@ defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
    from(
      activity in query,
      where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
-      where: fragment("not (?->'to' \\?| ?)", activity.data, ^blocks),
+      where: fragment("not (? && ?)", activity.recipients, ^blocks),
      where:
        fragment(
          "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
          activity.data,
          activity.data,
          ^blocks
        ),
      where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks)
    )
  end
@ -787,12 +796,7 @@ defp maybe_preload_objects(query, _) do
  end
  def fetch_activities_query(recipients, opts \\ %{}) do
-    base_query =
+    base_query = from(activity in Activity)
      from(
        activity in Activity,
        limit: 20,
        order_by: [fragment("? desc nulls last", activity.id)]
      )
    base_query
    |> maybe_preload_objects(opts)
@ -802,8 +806,6 @@ def fetch_activities_query(recipients, opts \\ %{}) do
    |> restrict_tag_all(opts)
    |> restrict_since(opts)
    |> restrict_local(opts)
    |> restrict_limit(opts)
    |> restrict_max(opts)
    |> restrict_actor(opts)
    |> restrict_type(opts)
    |> restrict_favorited_by(opts)
@ -819,14 +821,14 @@ def fetch_activities_query(recipients, opts \\ %{}) do
  def fetch_activities(recipients, opts \\ %{}) do
    fetch_activities_query(recipients, opts)
-    |> Repo.all()
+    |> Pagination.fetch_paginated(opts)
    |> Enum.reverse()
  end
  def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
    fetch_activities_query([], opts)
    |> restrict_to_cc(recipients_to, recipients_cc)
-    |> Repo.all()
+    |> Pagination.fetch_paginated(opts)
    |> Enum.reverse()
  end
@ -891,7 +893,7 @@ def user_data_from_user_object(data) do
  end
  def fetch_and_prepare_user_from_ap_id(ap_id) do
-    with {:ok, data} <- fetch_and_contain_remote_object_from_id(ap_id) do
+    with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id) do
      user_data_from_user_object(data)
    else
      e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
@ -899,7 +901,7 @@ def fetch_and_prepare_user_from_ap_id(ap_id) do
  end
  def make_user_from_ap_id(ap_id) do
-    if _user = User.get_by_ap_id(ap_id) do
+    if _user = User.get_cached_by_ap_id(ap_id) do
      Transmogrifier.upgrade_user_from_ap_id(ap_id)
    else
      with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
@ -1001,60 +1003,6 @@ def publish_one(%{inbox: inbox, json: json, actor: actor, id: id} = params) do
    end
  end
  # TODO:
  # This will create a Create activity, which we need internally at the moment.
  def fetch_object_from_id(id) do
    if object = Object.get_cached_by_ap_id(id) do
      {:ok, object}
    else
      with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
           nil <- Object.normalize(data),
           params <- %{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
             "actor" => data["actor"] || data["attributedTo"],
             "object" => data
           },
           :ok <- Transmogrifier.contain_origin(id, params),
           {:ok, activity} <- Transmogrifier.handle_incoming(params) do
        {:ok, Object.normalize(activity)}
      else
        {:error, {:reject, nil}} ->
          {:reject, nil}
        object = %Object{} ->
          {:ok, object}
        _e ->
          Logger.info("Couldn't get object via AP, trying out OStatus fetching...")
          case OStatus.fetch_activity_from_url(id) do
            {:ok, [activity | _]} -> {:ok, Object.normalize(activity)}
            e -> e
          end
      end
    end
  end
  def fetch_and_contain_remote_object_from_id(id) do
    Logger.info("Fetching object #{id} via AP")
    with true <- String.starts_with?(id, "http"),
         {:ok, %{body: body, status: code}} when code in 200..299 <-
           @httpoison.get(
             id,
             [{:Accept, "application/activity+json"}]
           ),
         {:ok, data} <- Jason.decode(body),
         :ok <- Transmogrifier.contain_origin_from_id(id, data) do
      {:ok, data}
    else
      e ->
        {:error, e}
    end
  end
  # filter out broken threads
  def contain_broken_threads(%Activity{} = activity, %User{} = user) do
    entire_thread_visible_for_user?(activity, user)
--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
@ -7,6 +7,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
  alias Pleroma.Activity
  alias Pleroma.Object
  alias Pleroma.Object.Fetcher
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.ObjectView
@ -153,9 +154,10 @@ def outbox(conn, %{"nickname" => nickname} = params) do
  end
  def inbox(%{assigns: %{valid_signature: true}} = conn, %{"nickname" => nickname} = params) do
-    with %User{} = user <- User.get_cached_by_nickname(nickname),
+    with %User{} = recipient <- User.get_cached_by_nickname(nickname),
-         true <- Utils.recipient_in_message(user.ap_id, params),
+         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(params["actor"]),
-         params <- Utils.maybe_splice_recipient(user.ap_id, params) do
+         true <- Utils.recipient_in_message(recipient, actor, params),
         params <- Utils.maybe_splice_recipient(recipient.ap_id, params) do
      Federator.incoming_ap_doc(params)
      json(conn, "ok")
    end
@ -172,7 +174,7 @@ def inbox(conn, %{"type" => "Create"} = params) do
      "Signature missing or not from author, relayed Create message, fetching object from source"
    )
-    ActivityPub.fetch_object_from_id(params["object"]["id"])
+    Fetcher.fetch_object_from_id(params["object"]["id"])
    json(conn, "ok")
  end
--- a/lib/pleroma/web/activity_pub/relay.ex
+++ b/lib/pleroma/web/activity_pub/relay.ex
@ -15,7 +15,7 @@ def get_actor do
  def follow(target_instance) do
    with %User{} = local_user <- get_actor(),
-         %User{} = target_user <- User.get_or_fetch_by_ap_id(target_instance),
+         {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_instance),
         {:ok, activity} <- ActivityPub.follow(local_user, target_user) do
      Logger.info("relay: followed instance: #{target_instance}; id=#{activity.data["id"]}")
      {:ok, activity}
@ -28,7 +28,7 @@ def follow(target_instance) do
  def unfollow(target_instance) do
    with %User{} = local_user <- get_actor(),
-         %User{} = target_user <- User.get_or_fetch_by_ap_id(target_instance),
+         {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_instance),
         {:ok, activity} <- ActivityPub.unfollow(local_user, target_user) do
      Logger.info("relay: unfollowed instance: #{target_instance}: id=#{activity.data["id"]}")
      {:ok, activity}
--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
@ -8,8 +8,10 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do
  """
  alias Pleroma.Activity
  alias Pleroma.Object
  alias Pleroma.Object.Containment
  alias Pleroma.Repo
  alias Pleroma.User
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.Utils
  alias Pleroma.Web.ActivityPub.Visibility
@ -18,56 +20,6 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do
  require Logger
  def get_actor(%{"actor" => actor}) when is_binary(actor) do
    actor
  end
  def get_actor(%{"actor" => actor}) when is_list(actor) do
    if is_binary(Enum.at(actor, 0)) do
      Enum.at(actor, 0)
    else
      Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
      |> Map.get("id")
    end
  end
  def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
    id
  end
  def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
    get_actor(%{"actor" => actor})
  end
  @doc """
  Checks that an imported AP object's actor matches the domain it came from.
  """
  def contain_origin(_id, %{"actor" => nil}), do: :error
  def contain_origin(id, %{"actor" => _actor} = params) do
    id_uri = URI.parse(id)
    actor_uri = URI.parse(get_actor(params))
    if id_uri.host == actor_uri.host do
      :ok
    else
      :error
    end
  end
  def contain_origin_from_id(_id, %{"id" => nil}), do: :error
  def contain_origin_from_id(id, %{"id" => other_id} = _params) do
    id_uri = URI.parse(id)
    other_uri = URI.parse(other_id)
    if id_uri.host == other_uri.host do
      :ok
    else
      :error
    end
  end
  @doc """
  Modifies an incoming AP object (mastodon format) to our internal format.
  """
@ -83,6 +35,22 @@ def fix_object(object) do
    |> fix_content_map
    |> fix_likes
    |> fix_addressing
    |> fix_summary
  end
  def fix_summary(%{"summary" => nil} = object) do
    object
    |> Map.put("summary", "")
  end
  def fix_summary(%{"summary" => _} = object) do
    # summary is present, nothing to do
    object
  end
  def fix_summary(object) do
    object
    |> Map.put("summary", "")
  end
  def fix_addressing_list(map, field) do
@ -158,7 +126,7 @@ def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collec
  def fix_implicit_addressing(object, _), do: object
  def fix_addressing(object) do
-    %User{} = user = User.get_or_fetch_by_ap_id(object["actor"])
+    {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
    followers_collection = User.ap_followers(user)
    object
@ -172,7 +140,7 @@ def fix_addressing(object) do
  def fix_actor(%{"attributedTo" => actor} = object) do
    object
-    |> Map.put("actor", get_actor(%{"actor" => actor}))
+    |> Map.put("actor", Containment.get_actor(%{"actor" => actor}))
  end
  # Check for standardisation
@ -207,14 +175,13 @@ def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
          ""
      end
-    case fetch_obj_helper(in_reply_to_id) do
+    case get_obj_helper(in_reply_to_id) do
      {:ok, replied_object} ->
-        with %Activity{} = activity <-
+        with %Activity{} = _activity <-
               Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
          object
          |> Map.put("inReplyTo", replied_object.data["id"])
          |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
          |> Map.put("inReplyToStatusId", activity.id)
          |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
          |> Map.put("context", replied_object.data["context"] || object["conversation"])
        else
@ -433,14 +400,14 @@ def handle_incoming(%{"id" => id}) when not (is_binary(id) and length(id) > 8),
  # - emoji
  def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
      when objtype in ["Article", "Note", "Video", "Page"] do
-    actor = get_actor(data)
+    actor = Containment.get_actor(data)
    data =
      Map.put(data, "actor", actor)
      |> fix_addressing
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
-         %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
+         {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
      object = fix_object(data["object"])
      params = %{
@ -469,30 +436,56 @@ def handle_incoming(
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
      ) do
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
-         %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
+         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
-      if not User.locked?(followed) do
+      with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
           {:user_blocked, false} <-
             {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
           {:user_locked, false} <- {:user_locked, User.locked?(followed)},
           {:follow, {:ok, follower}} <- {:follow, User.follow(follower, followed)} do
        ActivityPub.accept(%{
          to: [follower.ap_id],
          actor: followed,
          object: data,
          local: true
        })
      else
        {:user_blocked, true} ->
          {:ok, _} = Utils.update_follow_state(activity, "reject")
-        User.follow(follower, followed)
+          ActivityPub.reject(%{
            to: [follower.ap_id],
            actor: followed,
            object: data,
            local: true
          })
        {:follow, {:error, _}} ->
          {:ok, _} = Utils.update_follow_state(activity, "reject")
          ActivityPub.reject(%{
            to: [follower.ap_id],
            actor: followed,
            object: data,
            local: true
          })
        {:user_locked, true} ->
          :noop
      end
      {:ok, activity}
    else
-      _e -> :error
+      _e ->
        :error
    end
  end
  def handle_incoming(
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data
      ) do
-    with actor <- get_actor(data),
+    with actor <- Containment.get_actor(data),
-         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
+         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
@ -517,8 +510,8 @@ def handle_incoming(
  def handle_incoming(
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data
      ) do
-    with actor <- get_actor(data),
+    with actor <- Containment.get_actor(data),
-         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
+         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
@ -541,9 +534,9 @@ def handle_incoming(
  def handle_incoming(
        %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data
      ) do
-    with actor <- get_actor(data),
+    with actor <- Containment.get_actor(data),
-         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
+         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
-         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+         {:ok, object} <- get_obj_helper(object_id),
         {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
      {:ok, activity}
    else
@ -554,9 +547,9 @@ def handle_incoming(
  def handle_incoming(
        %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data
      ) do
-    with actor <- get_actor(data),
+    with actor <- Containment.get_actor(data),
-         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
+         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
-         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+         {:ok, object} <- get_obj_helper(object_id),
         public <- Visibility.is_public?(data),
         {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
      {:ok, activity}
@ -570,7 +563,7 @@ def handle_incoming(
          data
      )
      when object_type in ["Person", "Application", "Service", "Organization"] do
-    with %User{ap_id: ^actor_id} = actor <- User.get_by_ap_id(object["id"]) do
+    with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
      {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
      banner = new_user_data[:info]["banner"]
@ -609,10 +602,10 @@ def handle_incoming(
      ) do
    object_id = Utils.get_ap_id(object_id)
-    with actor <- get_actor(data),
+    with actor <- Containment.get_actor(data),
-         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
+         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
-         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+         {:ok, object} <- get_obj_helper(object_id),
-         :ok <- contain_origin(actor.ap_id, object.data),
+         :ok <- Containment.contain_origin(actor.ap_id, object.data),
         {:ok, activity} <- ActivityPub.delete(object, false) do
      {:ok, activity}
    else
@ -628,9 +621,9 @@ def handle_incoming(
          "id" => id
        } = data
      ) do
-    with actor <- get_actor(data),
+    with actor <- Containment.get_actor(data),
-         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
+         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
-         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+         {:ok, object} <- get_obj_helper(object_id),
         {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
      {:ok, activity}
    else
@ -647,7 +640,7 @@ def handle_incoming(
        } = _data
      ) do
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
-         %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
+         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
      User.unfollow(follower, followed)
      {:ok, activity}
@ -666,7 +659,7 @@ def handle_incoming(
      ) do
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
         %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
-         %User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
+         {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
         {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
      User.unblock(blocker, blocked)
      {:ok, activity}
@ -680,7 +673,7 @@ def handle_incoming(
      ) do
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
         %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
-         %User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
+         {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
         {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
      User.unfollow(blocker, blocked)
      User.block(blocker, blocked)
@ -698,9 +691,9 @@ def handle_incoming(
          "id" => id
        } = data
      ) do
-    with actor <- get_actor(data),
+    with actor <- Containment.get_actor(data),
-         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
+         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
-         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+         {:ok, object} <- get_obj_helper(object_id),
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
@ -710,9 +703,6 @@ def handle_incoming(
  def handle_incoming(_), do: :error
  def fetch_obj_helper(id) when is_bitstring(id), do: ActivityPub.fetch_object_from_id(id)
  def fetch_obj_helper(obj) when is_map(obj), do: ActivityPub.fetch_object_from_id(obj["id"])
  def get_obj_helper(id) do
    if object = Object.normalize(id), do: {:ok, object}, else: nil
  end
@ -749,9 +739,9 @@ def prepare_object(object) do
  #  internal -> Mastodon
  #  """
-  def prepare_outgoing(%{"type" => "Create", "object" => object} = data) do
+  def prepare_outgoing(%{"type" => "Create", "object" => object_id} = data) do
    object =
-      object
+      Object.normalize(object_id).data
      |> prepare_object
    data =
@ -812,7 +802,7 @@ def prepare_outgoing(%{"type" => _type} = data) do
  def maybe_fix_object_url(data) do
    if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
-      case fetch_obj_helper(data["object"]) do
+      case get_obj_helper(data["object"]) do
        {:ok, relative_object} ->
          if relative_object.data["external_url"] do
            _data =
@ -1000,7 +990,7 @@ def perform(:user_upgrade, user) do
  end
  def upgrade_user_from_ap_id(ap_id) do
-    with %User{local: false} = user <- User.get_by_ap_id(ap_id),
+    with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
         {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
         already_ap <- User.ap_enabled?(user),
         {:ok, user} <- user |> User.upgrade_changeset(data) |> User.update_and_set_cache() do
--- a/lib/pleroma/web/activity_pub/utils.ex
+++ b/lib/pleroma/web/activity_pub/utils.ex
@ -52,7 +52,7 @@ defp recipient_in_collection(ap_id, coll) when is_binary(coll), do: ap_id == col
  defp recipient_in_collection(ap_id, coll) when is_list(coll), do: ap_id in coll
  defp recipient_in_collection(_, _), do: false
-  def recipient_in_message(ap_id, params) do
+  def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params) do
    cond do
      recipient_in_collection(ap_id, params["to"]) ->
        true
@ -71,6 +71,11 @@ def recipient_in_message(ap_id, params) do
      !params["to"] && !params["cc"] && !params["bto"] && !params["bcc"] ->
        true
      # if the message is sent from somebody the user is following, then assume it
      # is addressed to the recipient
      User.following?(recipient, actor) ->
        true
      true ->
        false
    end
@ -229,14 +234,18 @@ def lazy_put_object_defaults(map, activity, _fake) do
  @doc """
  Inserts a full object if it is contained in an activity.
  """
-  def insert_full_object(%{"object" => %{"type" => type} = object_data})
+  def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
      when is_map(object_data) and type in @supported_object_types do
    with {:ok, object} <- Object.create(object_data) do
-      {:ok, object}
+      map =
        map
        |> Map.put("object", object.data["id"])
      {:ok, map, object}
    end
  end
-  def insert_full_object(_), do: {:ok, nil}
+  def insert_full_object(map), do: {:ok, map, nil}
  def update_object_in_activities(%{data: %{"id" => id}} = object) do
    # TODO
--- a/lib/pleroma/web/activity_pub/visibility.ex
+++ b/lib/pleroma/web/activity_pub/visibility.ex
@ -41,16 +41,21 @@ def visible_for_user?(activity, user) do
  # guard
  def entire_thread_visible_for_user?(nil, _user), do: false
-  # child
+  # XXX: Probably even more inefficient than the previous implementation intended to be a placeholder untill https://git.pleroma.social/pleroma/pleroma/merge_requests/971 is in develop
  # credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
  def entire_thread_visible_for_user?(
-        %Activity{data: %{"object" => %{"inReplyTo" => parent_id}}} = tail,
+        %Activity{} = tail,
        # %Activity{data: %{"object" => %{"inReplyTo" => parent_id}}} = tail,
        user
-      )
+      ) do
-      when is_binary(parent_id) do
+    case Object.normalize(tail) do
      %{data: %{"inReplyTo" => parent_id}} when is_binary(parent_id) ->
        parent = Activity.get_in_reply_to_activity(tail)
        visible_for_user?(tail, user) && entire_thread_visible_for_user?(parent, user)
  end
-  # root
+      _ ->
-  def entire_thread_visible_for_user?(tail, user), do: visible_for_user?(tail, user)
+        visible_for_user?(tail, user)
    end
  end
 end
--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
@ -5,6 +5,7 @@
 defmodule Pleroma.Web.AdminAPI.AdminAPIController do
  use Pleroma.Web, :controller
  alias Pleroma.User
  alias Pleroma.UserInviteToken
  alias Pleroma.Web.ActivityPub.Relay
  alias Pleroma.Web.AdminAPI.AccountView
  alias Pleroma.Web.AdminAPI.Search
@ -18,7 +19,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do
  action_fallback(:errors)
  def user_delete(conn, %{"nickname" => nickname}) do
-    User.get_by_nickname(nickname)
+    User.get_cached_by_nickname(nickname)
    |> User.delete()
    conn
@ -26,8 +27,8 @@ def user_delete(conn, %{"nickname" => nickname}) do
  end
  def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
-    with %User{} = follower <- User.get_by_nickname(follower_nick),
+    with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
-         %User{} = followed <- User.get_by_nickname(followed_nick) do
+         %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
      User.follow(follower, followed)
    end
@ -36,8 +37,8 @@ def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick
  end
  def user_unfollow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
-    with %User{} = follower <- User.get_by_nickname(follower_nick),
+    with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
-         %User{} = followed <- User.get_by_nickname(followed_nick) do
+         %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
      User.unfollow(follower, followed)
    end
@ -66,7 +67,7 @@ def user_create(
  end
  def user_show(conn, %{"nickname" => nickname}) do
-    with %User{} = user <- User.get_by_nickname(nickname) do
+    with %User{} = user <- User.get_cached_by_nickname(nickname) do
      conn
      |> json(AccountView.render("show.json", %{user: user}))
    else
@ -75,7 +76,7 @@ def user_show(conn, %{"nickname" => nickname}) do
  end
  def user_toggle_activation(conn, %{"nickname" => nickname}) do
-    user = User.get_by_nickname(nickname)
+    user = User.get_cached_by_nickname(nickname)
    {:ok, updated_user} = User.deactivate(user, !user.info.deactivated)
@ -130,7 +131,7 @@ defp maybe_parse_filters(filters) do
  def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
      when permission_group in ["moderator", "admin"] do
-    user = User.get_by_nickname(nickname)
+    user = User.get_cached_by_nickname(nickname)
    info =
      %{}
@ -155,7 +156,7 @@ def right_add(conn, _) do
  end
  def right_get(conn, %{"nickname" => nickname}) do
-    user = User.get_by_nickname(nickname)
+    user = User.get_cached_by_nickname(nickname)
    conn
    |> json(%{
@ -177,7 +178,7 @@ def right_delete(
      |> put_status(403)
      |> json(%{error: "You can't revoke your own admin status."})
    else
-      user = User.get_by_nickname(nickname)
+      user = User.get_cached_by_nickname(nickname)
      info =
        %{}
@ -203,7 +204,7 @@ def right_delete(conn, _) do
  def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
    with {:ok, status} <- Ecto.Type.cast(:boolean, status),
-         %User{} = user <- User.get_by_nickname(nickname),
+         %User{} = user <- User.get_cached_by_nickname(nickname),
         {:ok, _} <- User.deactivate(user, !status),
         do: json_response(conn, :no_content, "")
  end
@ -235,25 +236,48 @@ def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params)
    with true <-
           Pleroma.Config.get([:instance, :invites_enabled]) &&
             !Pleroma.Config.get([:instance, :registrations_open]),
-         {:ok, invite_token} <- Pleroma.UserInviteToken.create_token(),
+         {:ok, invite_token} <- UserInviteToken.create_invite(),
         email <-
-           Pleroma.UserEmail.user_invitation_email(user, invite_token, email, params["name"]),
+           Pleroma.Emails.UserEmail.user_invitation_email(
-         {:ok, _} <- Pleroma.Mailer.deliver(email) do
+             user,
             invite_token,
             email,
             params["name"]
           ),
         {:ok, _} <- Pleroma.Emails.Mailer.deliver(email) do
      json_response(conn, :no_content, "")
    end
  end
  @doc "Get a account registeration invite token (base64 string)"
-  def get_invite_token(conn, _params) do
+  def get_invite_token(conn, params) do
-    {:ok, token} = Pleroma.UserInviteToken.create_token()
+    options = params["invite"] || %{}
    {:ok, invite} = UserInviteToken.create_invite(options)
    conn
-    |> json(token.token)
+    |> json(invite.token)
  end
  @doc "Get list of created invites"
  def invites(conn, _params) do
    invites = UserInviteToken.list_invites()
    conn
    |> json(AccountView.render("invites.json", %{invites: invites}))
  end
  @doc "Revokes invite by token"
  def revoke_invite(conn, %{"token" => token}) do
    invite = UserInviteToken.find_by_token!(token)
    {:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true})
    conn
    |> json(AccountView.render("invite.json", %{invite: updated_invite}))
  end
  @doc "Get a password reset token (base64 string) for given nickname"
  def get_password_reset(conn, %{"nickname" => nickname}) do
-    (%User{local: true} = user) = User.get_by_nickname(nickname)
+    (%User{local: true} = user) = User.get_cached_by_nickname(nickname)
    {:ok, token} = Pleroma.PasswordResetToken.create_token(user)
    conn
--- a/lib/pleroma/web/admin_api/views/account_view.ex
+++ b/lib/pleroma/web/admin_api/views/account_view.ex
@ -26,4 +26,22 @@ def render("show.json", %{user: user}) do
      "tags" => user.tags || []
    }
  end
  def render("invite.json", %{invite: invite}) do
    %{
      "id" => invite.id,
      "token" => invite.token,
      "used" => invite.used,
      "expires_at" => invite.expires_at,
      "uses" => invite.uses,
      "max_use" => invite.max_use,
      "invite_type" => invite.invite_type
    }
  end
  def render("invites.json", %{invites: invites}) do
    %{
      invites: render_many(invites, AccountView, "invite.json", as: :invite)
    }
  end
 end
--- a/lib/pleroma/web/auth/authenticator.ex
+++ b/lib/pleroma/web/auth/authenticator.ex
@ -13,21 +13,21 @@ def implementation do
    )
  end
-  @callback get_user(Plug.Conn.t(), Map.t()) :: {:ok, User.t()} | {:error, any()}
+  @callback get_user(Plug.Conn.t()) :: {:ok, User.t()} | {:error, any()}
-  def get_user(plug, params), do: implementation().get_user(plug, params)
+  def get_user(plug), do: implementation().get_user(plug)
-  @callback create_from_registration(Plug.Conn.t(), Map.t(), Registration.t()) ::
+  @callback create_from_registration(Plug.Conn.t(), Registration.t()) ::
              {:ok, User.t()} | {:error, any()}
-  def create_from_registration(plug, params, registration),
+  def create_from_registration(plug, registration),
-    do: implementation().create_from_registration(plug, params, registration)
+    do: implementation().create_from_registration(plug, registration)
-  @callback get_registration(Plug.Conn.t(), Map.t()) ::
+  @callback get_registration(Plug.Conn.t()) ::
              {:ok, Registration.t()} | {:error, any()}
-  def get_registration(plug, params),
+  def get_registration(plug), do: implementation().get_registration(plug)
    do: implementation().get_registration(plug, params)
  @callback handle_error(Plug.Conn.t(), any()) :: any()
-  def handle_error(plug, error), do: implementation().handle_error(plug, error)
+  def handle_error(plug, error),
    do: implementation().handle_error(plug, error)
  @callback auth_template() :: String.t() | nil
  def auth_template do
@ -42,4 +42,30 @@ def oauth_consumer_template do
    implementation().oauth_consumer_template() ||
      Pleroma.Config.get([:auth, :oauth_consumer_template], "consumer.html")
  end
  @doc "Gets user by nickname or email for auth."
  @spec fetch_user(String.t()) :: User.t() | nil
  def fetch_user(name) do
    User.get_by_nickname_or_email(name)
  end
  # Gets name and password from conn
  #
  @spec fetch_credentials(Plug.Conn.t() | map()) ::
          {:ok, {name :: any, password :: any}} | {:error, :invalid_credentials}
  def fetch_credentials(%Plug.Conn{params: params} = _),
    do: fetch_credentials(params)
  def fetch_credentials(params) do
    case params do
      %{"authorization" => %{"name" => name, "password" => password}} ->
        {:ok, {name, password}}
      %{"grant_type" => "password", "username" => name, "password" => password} ->
        {:ok, {name, password}}
      _ ->
        {:error, :invalid_credentials}
    end
  end
 end
--- a/lib/pleroma/web/auth/ldap_authenticator.ex
+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
@ -7,51 +7,38 @@ defmodule Pleroma.Web.Auth.LDAPAuthenticator do
  require Logger
  import Pleroma.Web.Auth.Authenticator,
    only: [fetch_credentials: 1, fetch_user: 1]
  @behaviour Pleroma.Web.Auth.Authenticator
  @base Pleroma.Web.Auth.PleromaAuthenticator
  @connection_timeout 10_000
  @search_timeout 10_000
-  defdelegate get_registration(conn, params), to: @base
+  defdelegate get_registration(conn), to: @base
  defdelegate create_from_registration(conn, registration), to: @base
  defdelegate handle_error(conn, error), to: @base
  defdelegate auth_template, to: @base
  defdelegate oauth_consumer_template, to: @base
-  defdelegate create_from_registration(conn, params, registration), to: @base
+  def get_user(%Plug.Conn{} = conn) do
-
+    with {:ldap, true} <- {:ldap, Pleroma.Config.get([:ldap, :enabled])},
-  def get_user(%Plug.Conn{} = conn, params) do
+         {:ok, {name, password}} <- fetch_credentials(conn),
-    if Pleroma.Config.get([:ldap, :enabled]) do
+         %User{} = user <- ldap_user(name, password) do
      {name, password} =
        case params do
          %{"authorization" => %{"name" => name, "password" => password}} ->
            {name, password}
          %{"grant_type" => "password", "username" => name, "password" => password} ->
            {name, password}
        end
      case ldap_user(name, password) do
        %User{} = user ->
      {:ok, user}
-
+    else
      {:error, {:ldap_connection_error, _}} ->
        # When LDAP is unavailable, try default authenticator
-          @base.get_user(conn, params)
+        @base.get_user(conn)
      {:ldap, _} ->
        @base.get_user(conn)
      error ->
        error
    end
    else
      # Fall back to default authenticator
      @base.get_user(conn, params)
  end
  end
  def handle_error(%Plug.Conn{} = _conn, error) do
    error
  end
  def auth_template, do: nil
  def oauth_consumer_template, do: nil
  defp ldap_user(name, password) do
    ldap = Pleroma.Config.get(:ldap, [])
@ -100,7 +87,7 @@ defp bind_user(connection, ldap, name, password) do
    case :eldap.simple_bind(connection, "#{uid}=#{name},#{base}", password) do
      :ok ->
-        case User.get_by_nickname_or_email(name) do
+        case fetch_user(name) do
          %User{} = user ->
            user
--- a/lib/pleroma/web/auth/pleroma_authenticator.ex
+++ b/lib/pleroma/web/auth/pleroma_authenticator.ex
@ -8,19 +8,14 @@ defmodule Pleroma.Web.Auth.PleromaAuthenticator do
  alias Pleroma.Repo
  alias Pleroma.User
  import Pleroma.Web.Auth.Authenticator,
    only: [fetch_credentials: 1, fetch_user: 1]
  @behaviour Pleroma.Web.Auth.Authenticator
-  def get_user(%Plug.Conn{} = _conn, params) do
+  def get_user(%Plug.Conn{} = conn) do
-    {name, password} =
+    with {:ok, {name, password}} <- fetch_credentials(conn),
-      case params do
+         {_, %User{} = user} <- {:user, fetch_user(name)},
        %{"authorization" => %{"name" => name, "password" => password}} ->
          {name, password}
        %{"grant_type" => "password", "username" => name, "password" => password} ->
          {name, password}
      end
    with {_, %User{} = user} <- {:user, User.get_by_nickname_or_email(name)},
         {_, true} <- {:checkpw, Pbkdf2.checkpw(password, user.password_hash)} do
      {:ok, user}
    else
@ -29,10 +24,9 @@ def get_user(%Plug.Conn{} = _conn, params) do
    end
  end
-  def get_registration(
+  def get_registration(%Plug.Conn{
-        %Plug.Conn{assigns: %{ueberauth_auth: %{provider: provider, uid: uid} = auth}},
+        assigns: %{ueberauth_auth: %{provider: provider, uid: uid} = auth}
-        _params
+      }) do
      ) do
    registration = Registration.get_by_provider_uid(provider, uid)
    if registration do
@ -40,7 +34,8 @@ def get_registration(
    else
      info = auth.info
-      Registration.changeset(%Registration{}, %{
+      %Registration{}
      |> Registration.changeset(%{
        provider: to_string(provider),
        uid: to_string(uid),
        info: %{
@ -54,13 +49,16 @@ def get_registration(
    end
  end
-  def get_registration(%Plug.Conn{} = _conn, _params), do: {:error, :missing_credentials}
+  def get_registration(%Plug.Conn{} = _conn), do: {:error, :missing_credentials}
-  def create_from_registration(_conn, params, registration) do
+  def create_from_registration(
-    nickname = value([params["nickname"], Registration.nickname(registration)])
+        %Plug.Conn{params: %{"authorization" => registration_attrs}},
-    email = value([params["email"], Registration.email(registration)])
+        registration
-    name = value([params["name"], Registration.name(registration)]) || nickname
+      ) do
-    bio = value([params["bio"], Registration.description(registration)])
+    nickname = value([registration_attrs["nickname"], Registration.nickname(registration)])
    email = value([registration_attrs["email"], Registration.email(registration)])
    name = value([registration_attrs["name"], Registration.name(registration)]) || nickname
    bio = value([registration_attrs["bio"], Registration.description(registration)])
    random_password = :crypto.strong_rand_bytes(64) |> Base.encode64()
--- a/lib/pleroma/web/channels/user_socket.ex
+++ b/lib/pleroma/web/channels/user_socket.ex
@ -24,7 +24,7 @@ defmodule Pleroma.Web.UserSocket do
  def connect(%{"token" => token}, socket) do
    with true <- Pleroma.Config.get([:chat, :enabled]),
         {:ok, user_id} <- Phoenix.Token.verify(socket, "user socket", token, max_age: 84_600),
-         %User{} = user <- Pleroma.User.get_by_id(user_id) do
+         %User{} = user <- Pleroma.User.get_cached_by_id(user_id) do
      {:ok, assign(socket, :user_name, user.nickname)}
    else
      _e -> :error
--- a/lib/pleroma/web/common_api/common_api.ex
+++ b/lib/pleroma/web/common_api/common_api.ex
@ -4,6 +4,7 @@
 defmodule Pleroma.Web.CommonAPI do
  alias Pleroma.Activity
  alias Pleroma.Bookmark
  alias Pleroma.Formatter
  alias Pleroma.Object
  alias Pleroma.ThreadMute
@ -125,7 +126,10 @@ def get_visibility(%{"in_reply_to_status_id" => status_id}) when not is_nil(stat
        "public"
      in_reply_to ->
-        Pleroma.Web.MastodonAPI.StatusView.get_visibility(in_reply_to.data["object"])
+        # XXX: these heuristics should be moved out of MastodonAPI.
        with %Object{} = object <- Object.normalize(in_reply_to) do
          Pleroma.Web.MastodonAPI.StatusView.get_visibility(object)
        end
    end
  end
@ -214,8 +218,10 @@ def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
    with %Activity{
           actor: ^user_ap_id,
           data: %{
-             "type" => "Create",
+             "type" => "Create"
-             "object" => %{
+           },
           object: %Object{
             data: %{
               "to" => object_to,
               "type" => "Note"
             }
@ -277,9 +283,18 @@ def thread_muted?(user, activity) do
    end
  end
  def bookmarked?(user, activity) do
    with %Bookmark{} <- Bookmark.get(user.id, activity.id) do
      true
    else
      _ ->
        false
    end
  end
  def report(user, data) do
    with {:account_id, %{"account_id" => account_id}} <- {:account_id, data},
-         {:account, %User{} = account} <- {:account, User.get_by_id(account_id)},
+         {:account, %User{} = account} <- {:account, User.get_cached_by_id(account_id)},
         {:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
         {:ok, statuses} <- get_report_statuses(account, data),
         {:ok, activity} <-
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@ -12,6 +12,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do
  alias Pleroma.Repo
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.Utils
  alias Pleroma.Web.ActivityPub.Visibility
  alias Pleroma.Web.Endpoint
  alias Pleroma.Web.MediaProxy
@ -181,6 +182,18 @@ def format_input(text, "text/plain", options) do
        end).()
  end
  @doc """
  Formatting text as BBCode.
  """
  def format_input(text, "text/bbcode", options) do
    text
    |> String.replace(~r/\r/, "")
    |> Formatter.html_escape("text/plain")
    |> BBCode.to_html()
    |> (fn {:ok, html} -> html end).()
    |> Formatter.linkify(options)
  end
  @doc """
  Formatting text to html.
  """
@ -194,11 +207,10 @@ def format_input(text, "text/html", options) do
  Formatting text to markdown.
  """
  def format_input(text, "text/markdown", options) do
    options = Keyword.put(options, :mentions_escape, true)
    text
    |> Formatter.mentions_escape(options)
    |> Earmark.as_html!()
    |> Formatter.linkify(options)
    |> (fn {text, mentions, tags} -> {Earmark.as_html!(text), mentions, tags} end).()
    |> Formatter.html_escape("text/html")
  end
@ -208,7 +220,7 @@ def make_note_data(
        context,
        content_html,
        attachments,
-        inReplyTo,
+        in_reply_to,
        tags,
        cw \\ nil,
        cc \\ []
@ -225,10 +237,11 @@ def make_note_data(
      "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
    }
-    if inReplyTo do
+    if in_reply_to do
      in_reply_to_object = Object.normalize(in_reply_to)
      object
-      |> Map.put("inReplyTo", inReplyTo.data["object"]["id"])
+      |> Map.put("inReplyTo", in_reply_to_object.data["id"])
      |> Map.put("inReplyToStatusId", inReplyTo.id)
    else
      object
    end
@ -283,7 +296,7 @@ defp shortname(name) do
  end
  def confirm_current_password(user, password) do
-    with %User{local: true} = db_user <- User.get_by_id(user.id),
+    with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
         true <- Pbkdf2.checkpw(password, db_user.password_hash) do
      {:ok, db_user}
    else
@ -335,6 +348,24 @@ def maybe_notify_mentioned_recipients(
  def maybe_notify_mentioned_recipients(recipients, _), do: recipients
  def maybe_notify_subscribers(
        recipients,
        %Activity{data: %{"actor" => actor, "type" => type}} = activity
      )
      when type == "Create" do
    with %User{} = user <- User.get_cached_by_ap_id(actor) do
      subscriber_ids =
        user
        |> User.subscribers()
        |> Enum.filter(&Visibility.visible_for_user?(activity, &1))
        |> Enum.map(& &1.ap_id)
      recipients ++ subscriber_ids
    end
  end
  def maybe_notify_subscribers(recipients, _), do: recipients
  def maybe_extract_mentions(%{"tag" => tag}) do
    tag
    |> Enum.filter(fn x -> is_map(x) end)
--- a/lib/pleroma/web/endpoint.ex
+++ b/lib/pleroma/web/endpoint.ex
@ -58,14 +58,9 @@ defmodule Pleroma.Web.Endpoint do
      do: "__Host-pleroma_key",
      else: "pleroma_key"
-  same_site =
+  extra =
-    if Pleroma.Config.oauth_consumer_enabled?() do
+    Pleroma.Config.get([__MODULE__, :extra_cookie_attrs])
-      # Note: "SameSite=Strict" prevents sign in with external OAuth provider
+    |> Enum.join(";")
      #   (there would be no cookies during callback request from OAuth provider)
      "SameSite=Lax"
    else
      "SameSite=Strict"
    end
  # The session will be stored in the cookie and signed,
  # this means its contents can be read but not tampered with.
@ -77,7 +72,7 @@ defmodule Pleroma.Web.Endpoint do
    signing_salt: {Pleroma.Config, :get, [[__MODULE__, :signing_salt], "CqaoopA2"]},
    http_only: true,
    secure: secure_cookies,
-    extra: same_site
+    extra: extra
  )
  # Note: the plug and its configuration is compile-time this can't be upstreamed yet
--- a/lib/pleroma/web/federator/federator.ex
+++ b/lib/pleroma/web/federator/federator.ex
@ -4,6 +4,7 @@
 defmodule Pleroma.Web.Federator do
  alias Pleroma.Activity
  alias Pleroma.Object.Containment
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.Relay
@ -136,7 +137,7 @@ def perform(:incoming_ap_doc, params) do
    # actor shouldn't be acting on objects outside their own AP server.
    with {:ok, _user} <- ap_enabled_actor(params["actor"]),
         nil <- Activity.normalize(params["id"]),
-         :ok <- Transmogrifier.contain_origin_from_id(params["actor"], params),
+         :ok <- Containment.contain_origin_from_id(params["actor"], params),
         {:ok, activity} <- Transmogrifier.handle_incoming(params) do
      {:ok, activity}
    else
@ -185,7 +186,7 @@ def perform(type, _) do
  end
  def ap_enabled_actor(id) do
-    user = User.get_by_ap_id(id)
+    user = User.get_cached_by_ap_id(id)
    if User.ap_enabled?(user) do
      {:ok, user}
--- a/lib/pleroma/web/mastodon_api/mastodon_api.ex
+++ b/lib/pleroma/web/mastodon_api/mastodon_api.ex
@ -7,6 +7,31 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
  alias Pleroma.Pagination
  alias Pleroma.ScheduledActivity
  alias Pleroma.User
  alias Pleroma.Web.CommonAPI
  def follow(follower, followed, params \\ %{}) do
    options = cast_params(params)
    reblogs = options[:reblogs]
    result =
      if not User.following?(follower, followed) do
        CommonAPI.follow(follower, followed)
      else
        {:ok, follower, followed, nil}
      end
    with {:ok, follower, followed, _} <- result do
      reblogs
      |> case do
        false -> CommonAPI.hide_reblogs(follower, followed)
        _ -> CommonAPI.show_reblogs(follower, followed)
      end
      |> case do
        {:ok, follower} -> {:ok, follower}
        _ -> {:ok, follower}
      end
    end
  end
  def get_followers(user, params \\ %{}) do
    user
@ -37,7 +62,8 @@ def get_scheduled_activities(user, params \\ %{}) do
  defp cast_params(params) do
    param_types = %{
-      exclude_types: {:array, :string}
+      exclude_types: {:array, :string},
      reblogs: :boolean
    }
    changeset = cast({%{}, param_types}, params, Map.keys(param_types))
--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
@ -4,14 +4,16 @@
 defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
  use Pleroma.Web, :controller
  alias Ecto.Changeset
  alias Pleroma.Activity
  alias Pleroma.Bookmark
  alias Pleroma.Config
  alias Pleroma.Conversation.Participation
  alias Pleroma.Filter
  alias Pleroma.Notification
  alias Pleroma.Object
  alias Pleroma.Object.Fetcher
  alias Pleroma.Pagination
  alias Pleroma.Repo
  alias Pleroma.ScheduledActivity
  alias Pleroma.Stats
@ -36,7 +38,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
  alias Pleroma.Web.OAuth.Authorization
  alias Pleroma.Web.OAuth.Token
-  import Pleroma.Web.ControllerHelper, only: [oauth_scopes: 2]
+  alias Pleroma.Web.ControllerHelper
  import Ecto.Query
  require Logger
@ -47,7 +49,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
  action_fallback(:errors)
  def create_app(conn, params) do
-    scopes = oauth_scopes(params, ["read"])
+    scopes = ControllerHelper.oauth_scopes(params, ["read"])
    app_attrs =
      params
@ -97,8 +99,13 @@ def update_credentials(%{assigns: %{user: user}} = conn, params) do
      end)
    info_params =
-      %{}
+      [:no_rich_text, :locked, :hide_followers, :hide_follows, :hide_favorites, :show_role]
-      |> add_if_present(params, "locked", :locked, fn value -> {:ok, value == "true"} end)
+      |> Enum.reduce(%{}, fn key, acc ->
        add_if_present(acc, params, to_string(key), key, fn value ->
          {:ok, ControllerHelper.truthy_param?(value)}
        end)
      end)
      |> add_if_present(params, "default_scope", :default_scope)
      |> add_if_present(params, "header", :banner, fn value ->
        with %Plug.Upload{} <- value,
             {:ok, object} <- ActivityPub.upload(value, type: :banner) do
@ -108,7 +115,7 @@ def update_credentials(%{assigns: %{user: user}} = conn, params) do
        end
      end)
-    info_cng = User.Info.mastodon_profile_update(user.info, info_params)
+    info_cng = User.Info.profile_update(user.info, info_params)
    with changeset <- User.update_changeset(user, user_params),
         changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
@ -191,7 +198,7 @@ defp mastodonized_emoji do
        "static_url" => url,
        "visible_in_picker" => true,
        "url" => url,
-        "tags" => String.split(tags, ",")
+        "tags" => tags
      }
    end)
  end
@ -204,15 +211,29 @@ def custom_emojis(conn, _params) do
  defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
    params =
      conn.params
-      |> Map.drop(["since_id", "max_id"])
+      |> Map.drop(["since_id", "max_id", "min_id"])
      |> Map.merge(params)
    last = List.last(activities)
    first = List.first(activities)
    if last do
-      min = last.id
+      max_id = last.id
-      max = first.id
+
      limit =
        params
        |> Map.get("limit", "20")
        |> String.to_integer()
      min_id =
        if length(activities) <= limit do
          activities
          |> List.first()
          |> Map.get(:id)
        else
          activities
          |> Enum.at(limit * -1)
          |> Map.get(:id)
        end
      {next_url, prev_url} =
        if param do
@ -221,13 +242,13 @@ defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
              Pleroma.Web.Endpoint,
              method,
              param,
-              Map.merge(params, %{max_id: min})
+              Map.merge(params, %{max_id: max_id})
            ),
            mastodon_api_url(
              Pleroma.Web.Endpoint,
              method,
              param,
-              Map.merge(params, %{since_id: max})
+              Map.merge(params, %{min_id: min_id})
            )
          }
        else
@ -235,12 +256,12 @@ defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
            mastodon_api_url(
              Pleroma.Web.Endpoint,
              method,
-              Map.merge(params, %{max_id: min})
+              Map.merge(params, %{max_id: max_id})
            ),
            mastodon_api_url(
              Pleroma.Web.Endpoint,
              method,
-              Map.merge(params, %{since_id: max})
+              Map.merge(params, %{min_id: min_id})
            )
          }
        end
@ -266,6 +287,8 @@ def home_timeline(%{assigns: %{user: user}} = conn, params) do
      |> ActivityPub.contain_timeline(user)
      |> Enum.reverse()
    user = Repo.preload(user, bookmarks: :activity)
    conn
    |> add_link_headers(:home_timeline, activities)
    |> put_view(StatusView)
@ -284,6 +307,8 @@ def public_timeline(%{assigns: %{user: user}} = conn, params) do
      |> ActivityPub.fetch_public_activities()
      |> Enum.reverse()
    user = Repo.preload(user, bookmarks: :activity)
    conn
    |> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
    |> put_view(StatusView)
@ -291,7 +316,8 @@ def public_timeline(%{assigns: %{user: user}} = conn, params) do
  end
  def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
-    with %User{} = user <- User.get_by_id(params["id"]) do
+    with %User{} = user <- User.get_cached_by_id(params["id"]),
         reading_user <- Repo.preload(reading_user, :bookmarks) do
      activities = ActivityPub.fetch_user_activities(user, reading_user, params)
      conn
@ -316,7 +342,9 @@ def dm_timeline(%{assigns: %{user: user}} = conn, params) do
    activities =
      [user.ap_id]
      |> ActivityPub.fetch_activities_query(params)
-      |> Repo.all()
+      |> Pagination.fetch_paginated(params)
    user = Repo.preload(user, bookmarks: :activity)
    conn
    |> add_link_headers(:dm_timeline, activities)
@ -325,8 +353,10 @@ def dm_timeline(%{assigns: %{user: user}} = conn, params) do
  end
  def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    with %Activity{} = activity <- Activity.get_by_id(id),
+    with %Activity{} = activity <- Activity.get_by_id_with_object(id),
         true <- Visibility.visible_for_user?(activity, user) do
      user = Repo.preload(user, bookmarks: :activity)
      conn
      |> put_view(StatusView)
      |> try_render("status.json", %{activity: activity, for: user})
@ -474,7 +504,10 @@ def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
  end
  def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
-    with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
+    with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user),
         %Activity{} = announce <- Activity.normalize(announce.data) do
      user = Repo.preload(user, bookmarks: :activity)
      conn
      |> put_view(StatusView)
      |> try_render("status.json", %{activity: announce, for: user, as: :activity})
@ -483,7 +516,9 @@ def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
  def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
    with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
-         %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
+         %Activity{} = activity <- Activity.get_create_by_object_ap_id_with_object(id) do
      user = Repo.preload(user, bookmarks: :activity)
      conn
      |> put_view(StatusView)
      |> try_render("status.json", %{activity: activity, for: user, as: :activity})
@ -530,10 +565,12 @@ def unpin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
  end
  def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    with %Activity{} = activity <- Activity.get_by_id(id),
+    with %Activity{} = activity <- Activity.get_by_id_with_object(id),
-         %User{} = user <- User.get_by_nickname(user.nickname),
+         %User{} = user <- User.get_cached_by_nickname(user.nickname),
         true <- Visibility.visible_for_user?(activity, user),
-         {:ok, user} <- User.bookmark(user, activity.data["object"]["id"]) do
+         {:ok, _bookmark} <- Bookmark.create(user.id, activity.id) do
      user = Repo.preload(user, bookmarks: :activity)
      conn
      |> put_view(StatusView)
      |> try_render("status.json", %{activity: activity, for: user, as: :activity})
@ -541,10 +578,12 @@ def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
  end
  def unbookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    with %Activity{} = activity <- Activity.get_by_id(id),
+    with %Activity{} = activity <- Activity.get_by_id_with_object(id),
-         %User{} = user <- User.get_by_nickname(user.nickname),
+         %User{} = user <- User.get_cached_by_nickname(user.nickname),
         true <- Visibility.visible_for_user?(activity, user),
-         {:ok, user} <- User.unbookmark(user, activity.data["object"]["id"]) do
+         {:ok, _bookmark} <- Bookmark.destroy(user.id, activity.id) do
      user = Repo.preload(user, bookmarks: :activity)
      conn
      |> put_view(StatusView)
      |> try_render("status.json", %{activity: activity, for: user, as: :activity})
@ -614,6 +653,11 @@ def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _para
    end
  end
  def destroy_multiple(%{assigns: %{user: user}} = conn, %{"ids" => ids} = _params) do
    Notification.destroy_multiple(user, ids)
    json(conn, %{})
  end
  def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    id = List.wrap(id)
    q = from(u in User, where: u.id in ^id)
@ -663,7 +707,8 @@ def upload(%{assigns: %{user: user}} = conn, %{"file" => file} = data) do
  end
  def favourited_by(conn, %{"id" => id}) do
-    with %Activity{data: %{"object" => %{"likes" => likes}}} <- Activity.get_by_id(id) do
+    with %Activity{data: %{"object" => object}} <- Repo.get(Activity, id),
         %Object{data: %{"likes" => likes}} <- Object.normalize(object) do
      q = from(u in User, where: u.ap_id in ^likes)
      users = Repo.all(q)
@ -676,7 +721,8 @@ def favourited_by(conn, %{"id" => id}) do
  end
  def reblogged_by(conn, %{"id" => id}) do
-    with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Activity.get_by_id(id) do
+    with %Activity{data: %{"object" => object}} <- Repo.get(Activity, id),
         %Object{data: %{"announcements" => announces}} <- Object.normalize(object) do
      q = from(u in User, where: u.ap_id in ^announces)
      users = Repo.all(q)
@ -727,7 +773,7 @@ def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
  end
  def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
-    with %User{} = user <- User.get_by_id(id),
+    with %User{} = user <- User.get_cached_by_id(id),
         followers <- MastodonAPI.get_followers(user, params) do
      followers =
        cond do
@ -744,7 +790,7 @@ def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
  end
  def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
-    with %User{} = user <- User.get_by_id(id),
+    with %User{} = user <- User.get_cached_by_id(id),
         followers <- MastodonAPI.get_friends(user, params) do
      followers =
        cond do
@ -769,7 +815,7 @@ def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
  end
  def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
-    with %User{} = follower <- User.get_by_id(id),
+    with %User{} = follower <- User.get_cached_by_id(id),
         {:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
      conn
      |> put_view(AccountView)
@ -783,7 +829,7 @@ def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}
  end
  def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
-    with %User{} = follower <- User.get_by_id(id),
+    with %User{} = follower <- User.get_cached_by_id(id),
         {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
      conn
      |> put_view(AccountView)
@ -797,25 +843,15 @@ def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) d
  end
  def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
-    with %User{} = followed <- User.get_by_id(id),
+    with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
-         false <- User.following?(follower, followed),
+         {_, true} <- {:followed, follower.id != followed.id},
-         {:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
+         {:ok, follower} <- MastodonAPI.follow(follower, followed, conn.params) do
      conn
      |> put_view(AccountView)
      |> render("relationship.json", %{user: follower, target: followed})
    else
-      true ->
+      {:followed, _} ->
-        followed = User.get_cached_by_id(id)
+        {:error, :not_found}
        {:ok, follower} =
          case conn.params["reblogs"] do
            true -> CommonAPI.show_reblogs(follower, followed)
            false -> CommonAPI.hide_reblogs(follower, followed)
          end
        conn
        |> put_view(AccountView)
        |> render("relationship.json", %{user: follower, target: followed})
      {:error, message} ->
        conn
@ -825,12 +861,16 @@ def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
  end
  def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
-    with %User{} = followed <- User.get_by_nickname(uri),
+    with {_, %User{} = followed} <- {:followed, User.get_cached_by_nickname(uri)},
         {_, true} <- {:followed, follower.id != followed.id},
         {:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
      conn
      |> put_view(AccountView)
      |> render("account.json", %{user: followed, for: follower})
    else
      {:followed, _} ->
        {:error, :not_found}
      {:error, message} ->
        conn
        |> put_resp_content_type("application/json")
@ -839,16 +879,23 @@ def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
  end
  def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
-    with %User{} = followed <- User.get_by_id(id),
+    with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
         {_, true} <- {:followed, follower.id != followed.id},
         {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
      conn
      |> put_view(AccountView)
      |> render("relationship.json", %{user: follower, target: followed})
    else
      {:followed, _} ->
        {:error, :not_found}
      error ->
        error
    end
  end
  def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
-    with %User{} = muted <- User.get_by_id(id),
+    with %User{} = muted <- User.get_cached_by_id(id),
         {:ok, muter} <- User.mute(muter, muted) do
      conn
      |> put_view(AccountView)
@ -862,7 +909,7 @@ def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
  end
  def unmute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
-    with %User{} = muted <- User.get_by_id(id),
+    with %User{} = muted <- User.get_cached_by_id(id),
         {:ok, muter} <- User.unmute(muter, muted) do
      conn
      |> put_view(AccountView)
@ -883,7 +930,7 @@ def mutes(%{assigns: %{user: user}} = conn, _) do
  end
  def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
-    with %User{} = blocked <- User.get_by_id(id),
+    with %User{} = blocked <- User.get_cached_by_id(id),
         {:ok, blocker} <- User.block(blocker, blocked),
         {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
      conn
@ -898,7 +945,7 @@ def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
  end
  def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
-    with %User{} = blocked <- User.get_by_id(id),
+    with %User{} = blocked <- User.get_cached_by_id(id),
         {:ok, blocker} <- User.unblock(blocker, blocked),
         {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
      conn
@ -933,10 +980,38 @@ def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) d
    json(conn, %{})
  end
  def subscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    with %User{} = subscription_target <- User.get_cached_by_id(id),
         {:ok, subscription_target} = User.subscribe(user, subscription_target) do
      conn
      |> put_view(AccountView)
      |> render("relationship.json", %{user: user, target: subscription_target})
    else
      {:error, message} ->
        conn
        |> put_resp_content_type("application/json")
        |> send_resp(403, Jason.encode!(%{"error" => message}))
    end
  end
  def unsubscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    with %User{} = subscription_target <- User.get_cached_by_id(id),
         {:ok, subscription_target} = User.unsubscribe(user, subscription_target) do
      conn
      |> put_view(AccountView)
      |> render("relationship.json", %{user: user, target: subscription_target})
    else
      {:error, message} ->
        conn
        |> put_resp_content_type("application/json")
        |> send_resp(403, Jason.encode!(%{"error" => message}))
    end
  end
  def status_search(user, query) do
    fetched =
      if Regex.match?(~r/https?:/, query) do
-        with {:ok, object} <- ActivityPub.fetch_object_from_id(query),
+        with {:ok, object} <- Fetcher.fetch_object_from_id(query),
             %Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
             true <- Visibility.visible_for_user?(activity, user) do
          [activity]
@ -947,13 +1022,13 @@ def status_search(user, query) do
    q =
      from(
-        a in Activity,
+        [a, o] in Activity.with_preloaded_object(Activity),
        where: fragment("?->>'type' = 'Create'", a.data),
        where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
        where:
          fragment(
-            "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
+            "to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
-            a.data,
+            o.data,
            ^query
          ),
        limit: 20,
@ -1029,21 +1104,65 @@ def favourites(%{assigns: %{user: user}} = conn, params) do
      ActivityPub.fetch_activities([], params)
      |> Enum.reverse()
    user = Repo.preload(user, bookmarks: :activity)
    conn
    |> add_link_headers(:favourites, activities)
    |> put_view(StatusView)
    |> render("index.json", %{activities: activities, for: user, as: :activity})
  end
-  def bookmarks(%{assigns: %{user: user}} = conn, _) do
+  def user_favourites(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
-    user = User.get_by_id(user.id)
+    with %User{} = user <- User.get_by_id(id),
         false <- user.info.hide_favorites do
      params =
        params
        |> Map.put("type", "Create")
        |> Map.put("favorited_by", user.ap_id)
        |> Map.put("blocking_user", for_user)
      recipients =
        if for_user do
          ["https://www.w3.org/ns/activitystreams#Public"] ++
            [for_user.ap_id | for_user.following]
        else
          ["https://www.w3.org/ns/activitystreams#Public"]
        end
      activities =
-      user.bookmarks
+        recipients
-      |> Enum.map(fn id -> Activity.get_create_by_object_ap_id(id) end)
+        |> ActivityPub.fetch_activities(params)
        |> Enum.reverse()
      conn
      |> add_link_headers(:favourites, activities)
      |> put_view(StatusView)
      |> render("index.json", %{activities: activities, for: for_user, as: :activity})
    else
      nil ->
        {:error, :not_found}
      true ->
        conn
        |> put_status(403)
        |> json(%{error: "Can't get favorites"})
    end
  end
  def bookmarks(%{assigns: %{user: user}} = conn, params) do
    user = User.get_cached_by_id(user.id)
    user = Repo.preload(user, bookmarks: :activity)
    bookmarks =
      Bookmark.for_user_query(user.id)
      |> Pagination.fetch_paginated(params)
    activities =
      bookmarks
      |> Enum.map(fn b -> b.activity end)
    conn
    |> add_link_headers(:bookmarks, bookmarks)
    |> put_view(StatusView)
    |> render("index.json", %{activities: activities, for: user, as: :activity})
  end
@ -1093,7 +1212,7 @@ def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" =>
    accounts
    |> Enum.each(fn account_id ->
      with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
-           %User{} = followed <- User.get_by_id(account_id) do
+           %User{} = followed <- User.get_cached_by_id(account_id) do
        Pleroma.List.follow(list, followed)
      end
    end)
@ -1105,7 +1224,7 @@ def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_id
    accounts
    |> Enum.each(fn account_id ->
      with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
-           %User{} = followed <- Pleroma.User.get_by_id(account_id) do
+           %User{} = followed <- Pleroma.User.get_cached_by_id(account_id) do
        Pleroma.List.unfollow(list, followed)
      end
    end)
@ -1149,6 +1268,8 @@ def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params)
        |> ActivityPub.fetch_activities_bounded(following, params)
        |> Enum.reverse()
      user = Repo.preload(user, bookmarks: :activity)
      conn
      |> put_view(StatusView)
      |> render("index.json", %{activities: activities, for: user, as: :activity})
@ -1398,7 +1519,7 @@ def logout(conn, _) do
  def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
    Logger.debug("Unimplemented, returning unmodified relationship")
-    with %User{} = target <- User.get_by_id(id) do
+    with %User{} = target <- User.get_cached_by_id(id) do
      conn
      |> put_view(AccountView)
      |> render("relationship.json", %{user: user, target: target})
@ -1534,7 +1655,7 @@ def suggestions(%{assigns: %{user: user}} = conn, _) do
              x,
              "id",
              case User.get_or_fetch(x["acct"]) do
-                %{id: id} -> id
+                {:ok, %User{id: id}} -> id
                _ -> 0
              end
            )
--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
@ -53,6 +53,7 @@ def render("relationship.json", %{user: %User{} = user, target: %User{} = target
      blocking: User.blocks?(user, target),
      muting: User.mutes?(user, target),
      muting_notifications: false,
      subscribing: User.subscribed_to?(user, target),
      requested: requested,
      domain_blocking: false,
      showing_reblogs: User.showing_reblogs?(user, target),
@ -67,7 +68,7 @@ def render("relationships.json", %{user: user, targets: targets}) do
  defp do_render("account.json", %{user: user} = opts) do
    image = User.avatar_url(user) |> MediaProxy.url()
    header = User.banner_url(user) |> MediaProxy.url()
-    user_info = User.user_info(user)
+    user_info = User.get_cached_user_info(user)
    bot = (user.info.source_data["type"] || "Person") in ["Application", "Service"]
    emojis =
@ -112,19 +113,23 @@ defp do_render("account.json", %{user: user} = opts) do
      bot: bot,
      source: %{
        note: "",
-        privacy: user_info.default_scope,
+        sensitive: false,
-        sensitive: false
+        pleroma: %{}
      },
      # Pleroma extension
      pleroma: %{
        confirmation_pending: user_info.confirmation_pending,
        tags: user.tags,
-        is_moderator: user.info.is_moderator,
+        hide_followers: user.info.hide_followers,
-        is_admin: user.info.is_admin,
+        hide_follows: user.info.hide_follows,
        hide_favorites: user.info.hide_favorites,
        relationship: relationship
      }
    }
    |> maybe_put_role(user, opts[:for])
    |> maybe_put_settings(user, opts[:for], user_info)
    |> maybe_put_notification_settings(user, opts[:for])
  end
  defp username_from_nickname(string) when is_binary(string) do
@ -132,4 +137,38 @@ defp username_from_nickname(string) when is_binary(string) do
  end
  defp username_from_nickname(_), do: nil
  defp maybe_put_settings(
         data,
         %User{id: user_id} = user,
         %User{id: user_id},
         user_info
       ) do
    data
    |> Kernel.put_in([:source, :privacy], user_info.default_scope)
    |> Kernel.put_in([:source, :pleroma, :show_role], user.info.show_role)
    |> Kernel.put_in([:source, :pleroma, :no_rich_text], user.info.no_rich_text)
  end
  defp maybe_put_settings(data, _, _, _), do: data
  defp maybe_put_role(data, %User{info: %{show_role: true}} = user, _) do
    data
    |> Kernel.put_in([:pleroma, :is_admin], user.info.is_admin)
    |> Kernel.put_in([:pleroma, :is_moderator], user.info.is_moderator)
  end
  defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
    data
    |> Kernel.put_in([:pleroma, :is_admin], user.info.is_admin)
    |> Kernel.put_in([:pleroma, :is_moderator], user.info.is_moderator)
  end
  defp maybe_put_role(data, _, _), do: data
  defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
    Kernel.put_in(data, [:pleroma, :notification_settings], user.info.notification_settings)
  end
  defp maybe_put_notification_settings(data, _, _), do: data
 end
--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
@ -7,6 +7,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
  alias Pleroma.Activity
  alias Pleroma.HTML
  alias Pleroma.Object
  alias Pleroma.Repo
  alias Pleroma.User
  alias Pleroma.Web.CommonAPI
@ -19,8 +20,9 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
  defp get_replied_to_activities(activities) do
    activities
    |> Enum.map(fn
-      %{data: %{"type" => "Create", "object" => %{"inReplyTo" => in_reply_to}}} ->
+      %{data: %{"type" => "Create", "object" => object}} ->
-        in_reply_to != "" && in_reply_to
+        object = Object.normalize(object)
        object.data["inReplyTo"] != "" && object.data["inReplyTo"]
      _ ->
        nil
@ -29,7 +31,8 @@ defp get_replied_to_activities(activities) do
    |> Activity.create_by_object_ap_id()
    |> Repo.all()
    |> Enum.reduce(%{}, fn activity, acc ->
-      Map.put(acc, activity.data["object"]["id"], activity)
+      object = Object.normalize(activity)
      Map.put(acc, object.data["id"], activity)
    end)
  end
@ -54,6 +57,11 @@ defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
  defp get_context_id(_), do: nil
  defp reblogged?(activity, user) do
    object = Object.normalize(activity) || %{}
    present?(user && user.ap_id in (object.data["announcements"] || []))
  end
  def render("index.json", opts) do
    replied_to_activities = get_replied_to_activities(opts.activities)
@ -72,8 +80,13 @@ def render(
    user = get_user(activity.data["actor"])
    created_at = Utils.to_masto_date(activity.data["published"])
-    reblogged = Activity.get_create_by_object_ap_id(object)
+    reblogged_activity = Activity.get_create_by_object_ap_id(object)
-    reblogged = render("status.json", Map.put(opts, :activity, reblogged))
+    reblogged = render("status.json", Map.put(opts, :activity, reblogged_activity))
    activity_object = Object.normalize(activity)
    favorited = opts[:for] && opts[:for].ap_id in (activity_object.data["likes"] || [])
    bookmarked = opts[:for] && CommonAPI.bookmarked?(opts[:for], reblogged_activity)
    mentions =
      activity.recipients
@ -94,9 +107,9 @@ def render(
      reblogs_count: 0,
      replies_count: 0,
      favourites_count: 0,
-      reblogged: false,
+      reblogged: reblogged?(reblogged_activity, opts[:for]),
-      favourited: false,
+      favourited: present?(favorited),
-      bookmarked: false,
+      bookmarked: present?(bookmarked),
      muted: false,
      pinned: pinned?(activity, user),
      sensitive: false,
@ -117,14 +130,16 @@ def render(
    }
  end
-  def render("status.json", %{activity: %{data: %{"object" => object}} = activity} = opts) do
+  def render("status.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
    object = Object.normalize(activity)
    user = get_user(activity.data["actor"])
-    like_count = object["like_count"] || 0
+    like_count = object.data["like_count"] || 0
-    announcement_count = object["announcement_count"] || 0
+    announcement_count = object.data["announcement_count"] || 0
-    tags = object["tag"] || []
+    tags = object.data["tag"] || []
-    sensitive = object["sensitive"] || Enum.member?(tags, "nsfw")
+    sensitive = object.data["sensitive"] || Enum.member?(tags, "nsfw")
    mentions =
      activity.recipients
@ -132,65 +147,85 @@ def render("status.json", %{activity: %{data: %{"object" => object}} = activity}
      |> Enum.filter(& &1)
      |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
-    repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] || [])
+    favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
    favorited = opts[:for] && opts[:for].ap_id in (object["likes"] || [])
    bookmarked = opts[:for] && object["id"] in opts[:for].bookmarks
-    attachment_data = object["attachment"] || []
+    bookmarked = opts[:for] && CommonAPI.bookmarked?(opts[:for], activity)
    attachment_data = object.data["attachment"] || []
    attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)
-    created_at = Utils.to_masto_date(object["published"])
+    created_at = Utils.to_masto_date(object.data["published"])
    reply_to = get_reply_to(activity, opts)
    reply_to_user = reply_to && get_user(reply_to.data["actor"])
    content =
      object
      |> render_content()
    content_html =
      content
      |> HTML.get_cached_scrubbed_html_for_activity(
        User.html_filter_policy(opts[:for]),
        activity,
        "mastoapi:content"
      )
-    summary =
+    content_plaintext =
-      (object["summary"] || "")
+      content
      |> HTML.get_cached_stripped_html_for_activity(
        activity,
        "mastoapi:content"
      )
    summary = object.data["summary"] || ""
    summary_html =
      summary
      |> HTML.get_cached_scrubbed_html_for_activity(
        User.html_filter_policy(opts[:for]),
        activity,
        "mastoapi:summary"
      )
    summary_plaintext =
      summary
      |> HTML.get_cached_stripped_html_for_activity(
        activity,
        "mastoapi:summary"
      )
    card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))
    url =
      if user.local do
        Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
      else
-        object["external_url"] || object["id"]
+        object.data["external_url"] || object.data["id"]
      end
    %{
      id: to_string(activity.id),
-      uri: object["id"],
+      uri: object.data["id"],
      url: url,
      account: AccountView.render("account.json", %{user: user}),
      in_reply_to_id: reply_to && to_string(reply_to.id),
      in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
      reblog: nil,
      card: card,
-      content: content,
+      content: content_html,
      created_at: created_at,
      reblogs_count: announcement_count,
-      replies_count: object["repliesCount"] || 0,
+      replies_count: object.data["repliesCount"] || 0,
      favourites_count: like_count,
-      reblogged: present?(repeated),
+      reblogged: reblogged?(activity, opts[:for]),
      favourited: present?(favorited),
      bookmarked: present?(bookmarked),
      muted: CommonAPI.thread_muted?(user, activity) || User.mutes?(opts[:for], user),
      pinned: pinned?(activity, user),
      sensitive: sensitive,
-      spoiler_text: summary,
+      spoiler_text: summary_html,
      visibility: get_visibility(object),
      media_attachments: attachments,
      mentions: mentions,
@ -200,10 +235,13 @@ def render("status.json", %{activity: %{data: %{"object" => object}} = activity}
        website: nil
      },
      language: nil,
-      emojis: build_emojis(activity.data["object"]["emoji"]),
+      emojis: build_emojis(object.data["emoji"]),
      pleroma: %{
        local: activity.local,
-        conversation_id: get_context_id(activity)
+        conversation_id: get_context_id(activity),
        in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
        content: %{"text/plain" => content_plaintext},
        spoiler_text: %{"text/plain" => summary_plaintext}
      }
    }
  end
@ -280,13 +318,19 @@ def render("attachment.json", %{attachment: attachment}) do
  end
  def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
-    _id = activity.data["object"]["inReplyTo"]
+    object = Object.normalize(activity)
-    replied_to_activities[activity.data["object"]["inReplyTo"]]
+
    with nil <- replied_to_activities[object.data["inReplyTo"]] do
      # If user didn't participate in the thread
      Activity.get_in_reply_to_activity(activity)
    end
  end
-  def get_reply_to(%{data: %{"object" => object}}, _) do
+  def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
-    if object["inReplyTo"] && object["inReplyTo"] != "" do
+    object = Object.normalize(activity)
-      Activity.get_create_by_object_ap_id(object["inReplyTo"])
+
    if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
      Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
    else
      nil
    end
@ -294,8 +338,8 @@ def get_reply_to(%{data: %{"object" => object}}, _) do
  def get_visibility(object) do
    public = "https://www.w3.org/ns/activitystreams#Public"
-    to = object["to"] || []
+    to = object.data["to"] || []
-    cc = object["cc"] || []
+    cc = object.data["cc"] || []
    cond do
      public in to ->
@ -316,25 +360,25 @@ def get_visibility(object) do
    end
  end
-  def render_content(%{"type" => "Video"} = object) do
+  def render_content(%{data: %{"type" => "Video"}} = object) do
-    with name when not is_nil(name) and name != "" <- object["name"] do
+    with name when not is_nil(name) and name != "" <- object.data["name"] do
-      "<p><a href=\"#{object["id"]}\">#{name}</a></p>#{object["content"]}"
+      "<p><a href=\"#{object.data["id"]}\">#{name}</a></p>#{object.data["content"]}"
    else
-      _ -> object["content"] || ""
+      _ -> object.data["content"] || ""
    end
  end
-  def render_content(%{"type" => object_type} = object)
+  def render_content(%{data: %{"type" => object_type}} = object)
      when object_type in ["Article", "Page"] do
-    with summary when not is_nil(summary) and summary != "" <- object["name"],
+    with summary when not is_nil(summary) and summary != "" <- object.data["name"],
-         url when is_bitstring(url) <- object["url"] do
+         url when is_bitstring(url) <- object.data["url"] do
-      "<p><a href=\"#{url}\">#{summary}</a></p>#{object["content"]}"
+      "<p><a href=\"#{url}\">#{summary}</a></p>#{object.data["content"]}"
    else
-      _ -> object["content"] || ""
+      _ -> object.data["content"] || ""
    end
  end
-  def render_content(object), do: object["content"] || ""
+  def render_content(object), do: object.data["content"] || ""
  @doc """
  Builds a dictionary tags.
--- a/lib/pleroma/web/mastodon_api/websocket_handler.ex
+++ b/lib/pleroma/web/mastodon_api/websocket_handler.ex
@ -90,7 +90,7 @@ defp allow_request(stream, nil) when stream in @anonymous_streams do
  # Authenticated streams.
  defp allow_request(stream, {"access_token", access_token}) when stream in @streams do
    with %Token{user_id: user_id} <- Repo.get_by(Token, token: access_token),
-         user = %User{} <- User.get_by_id(user_id) do
+         user = %User{} <- User.get_cached_by_id(user_id) do
      {:ok, user}
    else
      _ -> {:error, 403}
--- a/lib/pleroma/web/media_proxy/media_proxy.ex
+++ b/lib/pleroma/web/media_proxy/media_proxy.ex
@ -13,10 +13,23 @@ def url("/" <> _ = url), do: url
  def url(url) do
    config = Application.get_env(:pleroma, :media_proxy, [])
    domain = URI.parse(url).host
-    if !Keyword.get(config, :enabled, false) or String.starts_with?(url, Pleroma.Web.base_url()) do
+    cond do
      !Keyword.get(config, :enabled, false) or String.starts_with?(url, Pleroma.Web.base_url()) ->
        url
-    else
+
      Enum.any?(Pleroma.Config.get([:media_proxy, :whitelist]), fn pattern ->
        String.equivalent?(domain, pattern)
      end) ->
        url
      true ->
        encode_url(url)
    end
  end
  def encode_url(url) do
    secret = Application.get_env(:pleroma, Pleroma.Web.Endpoint)[:secret_key_base]
    # Must preserve `%2F` for compatibility with S3
@ -37,7 +50,6 @@ def url(url) do
    build_url(sig64, base64, filename(url))
  end
  end
  def decode_url(sig, url) do
    secret = Application.get_env(:pleroma, Pleroma.Web.Endpoint)[:secret_key_base]
--- a/lib/pleroma/web/metadata/rel_me.ex
+++ b/lib/pleroma/web/metadata/rel_me.ex
@ -0,0 +1,13 @@
 defmodule Pleroma.Web.Metadata.Providers.RelMe do
  alias Pleroma.Web.Metadata.Providers.Provider
  @behaviour Provider
  @impl Provider
  def build_tags(%{user: user}) do
    (Floki.attribute(user.bio, "link[rel~=me]", "href") ++
       Floki.attribute(user.bio, "a[rel~=me]", "href"))
    |> Enum.map(fn link ->
      {:link, [rel: "me", href: link], []}
    end)
  end
 end
--- a/lib/pleroma/web/oauth/fallback_controller.ex
+++ b/lib/pleroma/web/oauth/fallback_controller.ex
@ -24,6 +24,6 @@ def call(conn, _error) do
    conn
    |> put_status(:unauthorized)
    |> put_flash(:error, "Invalid Username/Password")
-    |> OAuthController.authorize(conn.params["authorization"])
+    |> OAuthController.authorize(conn.params)
  end
 end
--- a/lib/pleroma/web/oauth/oauth_controller.ex
+++ b/lib/pleroma/web/oauth/oauth_controller.ex
@ -23,6 +23,12 @@ defmodule Pleroma.Web.OAuth.OAuthController do
  action_fallback(Pleroma.Web.OAuth.FallbackController)
  # Note: this definition is only called from error-handling methods with `conn.params` as 2nd arg
  def authorize(conn, %{"authorization" => _} = params) do
    {auth_attrs, params} = Map.pop(params, "authorization")
    authorize(conn, Map.merge(params, auth_attrs))
  end
  def authorize(%{assigns: %{token: %Token{} = token}} = conn, params) do
    if ControllerHelper.truthy_param?(params["force_login"]) do
      do_authorize(conn, params)
@ -49,6 +55,7 @@ defp do_authorize(conn, params) do
    available_scopes = (app && app.scopes) || []
    scopes = oauth_scopes(params, nil) || available_scopes
    # Note: `params` might differ from `conn.params`; use `@params` not `@conn.params` in template
    render(conn, Authenticator.auth_template(), %{
      response_type: params["response_type"],
      client_id: params["client_id"],
@ -62,18 +69,20 @@ defp do_authorize(conn, params) do
  def create_authorization(
        conn,
-        %{"authorization" => auth_params} = params,
+        %{"authorization" => _} = params,
        opts \\ []
      ) do
    with {:ok, auth} <- do_create_authorization(conn, params, opts[:user]) do
-      after_create_authorization(conn, auth, auth_params)
+      after_create_authorization(conn, auth, params)
    else
      error ->
-        handle_create_authorization_error(conn, error, auth_params)
+        handle_create_authorization_error(conn, error, params)
    end
  end
-  def after_create_authorization(conn, auth, %{"redirect_uri" => redirect_uri} = auth_params) do
+  def after_create_authorization(conn, auth, %{
        "authorization" => %{"redirect_uri" => redirect_uri} = auth_attrs
      }) do
    redirect_uri = redirect_uri(conn, redirect_uri)
    if redirect_uri == "urn:ietf:wg:oauth:2.0:oob" do
@ -86,8 +95,8 @@ def after_create_authorization(conn, auth, %{"redirect_uri" => redirect_uri} = a
      url_params = %{:code => auth.token}
      url_params =
-        if auth_params["state"] do
+        if auth_attrs["state"] do
-          Map.put(url_params, :state, auth_params["state"])
+          Map.put(url_params, :state, auth_attrs["state"])
        else
          url_params
        end
@ -98,26 +107,34 @@ def after_create_authorization(conn, auth, %{"redirect_uri" => redirect_uri} = a
    end
  end
-  defp handle_create_authorization_error(conn, {scopes_issue, _}, auth_params)
+  defp handle_create_authorization_error(
         conn,
         {scopes_issue, _},
         %{"authorization" => _} = params
       )
       when scopes_issue in [:unsupported_scopes, :missing_scopes] do
    # Per https://github.com/tootsuite/mastodon/blob/
    #   51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L39
    conn
    |> put_flash(:error, "This action is outside the authorized scopes")
    |> put_status(:unauthorized)
-    |> authorize(auth_params)
+    |> authorize(params)
  end
-  defp handle_create_authorization_error(conn, {:auth_active, false}, auth_params) do
+  defp handle_create_authorization_error(
         conn,
         {:auth_active, false},
         %{"authorization" => _} = params
       ) do
    # Per https://github.com/tootsuite/mastodon/blob/
    #   51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L76
    conn
    |> put_flash(:error, "Your login is missing a confirmed e-mail address")
    |> put_status(:forbidden)
-    |> authorize(auth_params)
+    |> authorize(params)
  end
-  defp handle_create_authorization_error(conn, error, _auth_params) do
+  defp handle_create_authorization_error(conn, error, %{"authorization" => _}) do
    Authenticator.handle_error(conn, error)
  end
@ -126,7 +143,7 @@ def token_exchange(conn, %{"grant_type" => "authorization_code"} = params) do
         fixed_token = fix_padding(params["code"]),
         %Authorization{} = auth <-
           Repo.get_by(Authorization, token: fixed_token, app_id: app.id),
-         %User{} = user <- User.get_by_id(auth.user_id),
+         %User{} = user <- User.get_cached_by_id(auth.user_id),
         {:ok, token} <- Token.exchange_token(app, auth),
         {:ok, inserted_at} <- DateTime.from_naive(token.inserted_at, "Etc/UTC") do
      response = %{
@ -151,7 +168,7 @@ def token_exchange(
        conn,
        %{"grant_type" => "password"} = params
      ) do
-    with {_, {:ok, %User{} = user}} <- {:get_user, Authenticator.get_user(conn, params)},
+    with {_, {:ok, %User{} = user}} <- {:get_user, Authenticator.get_user(conn)},
         %App{} = app <- get_app_from_request(conn, params),
         {:auth_active, true} <- {:auth_active, User.auth_active?(user)},
         {:user_active, true} <- {:user_active, !user.info.deactivated},
@ -214,19 +231,19 @@ def token_revoke(conn, %{"token" => token} = params) do
  end
  @doc "Prepares OAuth request to provider for Ueberauth"
-  def prepare_request(conn, %{"provider" => provider} = params) do
+  def prepare_request(conn, %{"provider" => provider, "authorization" => auth_attrs}) do
    scope =
-      oauth_scopes(params, [])
+      oauth_scopes(auth_attrs, [])
      |> Enum.join(" ")
    state =
-      params
+      auth_attrs
      |> Map.delete("scopes")
      |> Map.put("scope", scope)
      |> Poison.encode!()
    params =
-      params
+      auth_attrs
      |> Map.drop(~w(scope scopes client_id redirect_uri))
      |> Map.put("state", state)
@ -260,26 +277,26 @@ def callback(%{assigns: %{ueberauth_failure: failure}} = conn, params) do
  def callback(conn, params) do
    params = callback_params(params)
-    with {:ok, registration} <- Authenticator.get_registration(conn, params) do
+    with {:ok, registration} <- Authenticator.get_registration(conn) do
      user = Repo.preload(registration, :user).user
-      auth_params = Map.take(params, ~w(client_id redirect_uri scope scopes state))
+      auth_attrs = Map.take(params, ~w(client_id redirect_uri scope scopes state))
      if user do
        create_authorization(
          conn,
-          %{"authorization" => auth_params},
+          %{"authorization" => auth_attrs},
          user: user
        )
      else
        registration_params =
-          Map.merge(auth_params, %{
+          Map.merge(auth_attrs, %{
            "nickname" => Registration.nickname(registration),
            "email" => Registration.email(registration)
          })
        conn
        |> put_session(:registration_id, registration.id)
-        |> registration_details(registration_params)
+        |> registration_details(%{"authorization" => registration_params})
      end
    else
      _ ->
@ -293,53 +310,44 @@ defp callback_params(%{"state" => state} = params) do
    Map.merge(params, Poison.decode!(state))
  end
-  def registration_details(conn, params) do
+  def registration_details(conn, %{"authorization" => auth_attrs}) do
    render(conn, "register.html", %{
-      client_id: params["client_id"],
+      client_id: auth_attrs["client_id"],
-      redirect_uri: params["redirect_uri"],
+      redirect_uri: auth_attrs["redirect_uri"],
-      state: params["state"],
+      state: auth_attrs["state"],
-      scopes: oauth_scopes(params, []),
+      scopes: oauth_scopes(auth_attrs, []),
-      nickname: params["nickname"],
+      nickname: auth_attrs["nickname"],
-      email: params["email"]
+      email: auth_attrs["email"]
    })
  end
-  def register(conn, %{"op" => "connect"} = params) do
+  def register(conn, %{"authorization" => _, "op" => "connect"} = params) do
    authorization_params = Map.put(params, "name", params["auth_name"])
    create_authorization_params = %{"authorization" => authorization_params}
    with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
         %Registration{} = registration <- Repo.get(Registration, registration_id),
         {_, {:ok, auth}} <-
-           {:create_authorization, do_create_authorization(conn, create_authorization_params)},
+           {:create_authorization, do_create_authorization(conn, params)},
         %User{} = user <- Repo.preload(auth, :user).user,
         {:ok, _updated_registration} <- Registration.bind_to_user(registration, user) do
      conn
      |> put_session_registration_id(nil)
-      |> after_create_authorization(auth, authorization_params)
+      |> after_create_authorization(auth, params)
    else
      {:create_authorization, error} ->
-        {:register, handle_create_authorization_error(conn, error, create_authorization_params)}
+        {:register, handle_create_authorization_error(conn, error, params)}
      _ ->
        {:register, :generic_error}
    end
  end
-  def register(conn, %{"op" => "register"} = params) do
+  def register(conn, %{"authorization" => _, "op" => "register"} = params) do
    with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
         %Registration{} = registration <- Repo.get(Registration, registration_id),
-         {:ok, user} <- Authenticator.create_from_registration(conn, params, registration) do
+         {:ok, user} <- Authenticator.create_from_registration(conn, registration) do
      conn
      |> put_session_registration_id(nil)
      |> create_authorization(
-        %{
+        params,
          "authorization" => %{
            "client_id" => params["client_id"],
            "redirect_uri" => params["redirect_uri"],
            "scopes" => oauth_scopes(params, nil)
          }
        },
        user: user
      )
    else
@ -374,15 +382,15 @@ defp do_create_authorization(
             %{
               "client_id" => client_id,
               "redirect_uri" => redirect_uri
-             } = auth_params
+             } = auth_attrs
-         } = params,
+         },
         user \\ nil
       ) do
    with {_, {:ok, %User{} = user}} <-
-           {:get_user, (user && {:ok, user}) || Authenticator.get_user(conn, params)},
+           {:get_user, (user && {:ok, user}) || Authenticator.get_user(conn)},
         %App{} = app <- Repo.get_by(App, client_id: client_id),
         true <- redirect_uri in String.split(app.redirect_uris),
-         scopes <- oauth_scopes(auth_params, []),
+         scopes <- oauth_scopes(auth_attrs, []),
         {:unsupported_scopes, []} <- {:unsupported_scopes, scopes -- app.scopes},
         # Note: `scope` param is intentionally not optional in this context
         {:missing_scopes, false} <- {:missing_scopes, scopes == []},
--- a/lib/pleroma/web/oauth/token.ex
+++ b/lib/pleroma/web/oauth/token.ex
@ -27,7 +27,7 @@ defmodule Pleroma.Web.OAuth.Token do
  def exchange_token(app, auth) do
    with {:ok, auth} <- Authorization.use_token(auth),
         true <- auth.app_id == app.id do
-      create_token(app, User.get_by_id(auth.user_id), auth.scopes)
+      create_token(app, User.get_cached_by_id(auth.user_id), auth.scopes)
    end
  end
--- a/lib/pleroma/web/ostatus/activity_representer.ex
+++ b/lib/pleroma/web/ostatus/activity_representer.ex
@ -54,23 +54,16 @@ defp get_mentions(to) do
    end)
  end
-  defp get_links(%{local: true, data: data}) do
+  defp get_links(%{local: true}, %{"id" => object_id}) do
    h = fn str -> [to_charlist(str)] end
    [
-      {:link, [type: ['application/atom+xml'], href: h.(data["object"]["id"]), rel: 'self'], []},
+      {:link, [type: ['application/atom+xml'], href: h.(object_id), rel: 'self'], []},
-      {:link, [type: ['text/html'], href: h.(data["object"]["id"]), rel: 'alternate'], []}
+      {:link, [type: ['text/html'], href: h.(object_id), rel: 'alternate'], []}
    ]
  end
-  defp get_links(%{
+  defp get_links(%{local: false}, %{"external_url" => external_url}) do
         local: false,
         data: %{
           "object" => %{
             "external_url" => external_url
           }
         }
       }) do
    h = fn str -> [to_charlist(str)] end
    [
@ -78,7 +71,7 @@ defp get_links(%{
    ]
  end
-  defp get_links(_activity), do: []
+  defp get_links(_activity, _object_data), do: []
  defp get_emoji_links(emojis) do
    Enum.map(emojis, fn {emoji, file} ->
@ -88,14 +81,16 @@ defp get_emoji_links(emojis) do
  def to_simple_form(activity, user, with_author \\ false)
-  def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user, with_author) do
+  def to_simple_form(%{data: %{"type" => "Create"}} = activity, user, with_author) do
    h = fn str -> [to_charlist(str)] end
-    updated_at = activity.data["object"]["published"]
+    object = Object.normalize(activity)
-    inserted_at = activity.data["object"]["published"]
+
    updated_at = object.data["published"]
    inserted_at = object.data["published"]
    attachments =
-      Enum.map(activity.data["object"]["attachment"] || [], fn attachment ->
+      Enum.map(object.data["attachment"] || [], fn attachment ->
        url = hd(attachment["url"])
        {:link,
@ -108,7 +103,7 @@ def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user,
    mentions = activity.recipients |> get_mentions
    categories =
-      (activity.data["object"]["tag"] || [])
+      (object.data["tag"] || [])
      |> Enum.map(fn tag ->
        if is_binary(tag) do
          {:category, [term: to_charlist(tag)], []}
@ -118,11 +113,11 @@ def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user,
      end)
      |> Enum.filter(& &1)
-    emoji_links = get_emoji_links(activity.data["object"]["emoji"] || %{})
+    emoji_links = get_emoji_links(object.data["emoji"] || %{})
    summary =
-      if activity.data["object"]["summary"] do
+      if object.data["summary"] do
-        [{:summary, [], h.(activity.data["object"]["summary"])}]
+        [{:summary, [], h.(object.data["summary"])}]
      else
        []
      end
@ -131,10 +126,9 @@ def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user,
      {:"activity:object-type", ['http://activitystrea.ms/schema/1.0/note']},
      {:"activity:verb", ['http://activitystrea.ms/schema/1.0/post']},
      # For notes, federate the object id.
-      {:id, h.(activity.data["object"]["id"])},
+      {:id, h.(object.data["id"])},
      {:title, ['New note by #{user.nickname}']},
-      {:content, [type: 'html'],
+      {:content, [type: 'html'], h.(object.data["content"] |> String.replace(~r/[\n\r]/, ""))},
       h.(activity.data["object"]["content"] |> String.replace(~r/[\n\r]/, ""))},
      {:published, h.(inserted_at)},
      {:updated, h.(updated_at)},
      {:"ostatus:conversation", [ref: h.(activity.data["context"])],
@ -142,7 +136,7 @@ def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user,
      {:link, [ref: h.(activity.data["context"]), rel: 'ostatus:conversation'], []}
    ] ++
      summary ++
-      get_links(activity) ++
+      get_links(activity, object.data) ++
      categories ++ attachments ++ in_reply_to ++ author ++ mentions ++ emoji_links
  end
--- a/lib/pleroma/web/ostatus/handlers/note_handler.ex
+++ b/lib/pleroma/web/ostatus/handlers/note_handler.ex
@ -113,8 +113,9 @@ def handle_note(entry, doc \\ nil) do
         cw <- OStatus.get_cw(entry),
         in_reply_to <- XML.string_from_xpath("//thr:in-reply-to[1]/@ref", entry),
         in_reply_to_activity <- fetch_replied_to_activity(entry, in_reply_to),
-         in_reply_to <-
+         in_reply_to_object <-
-           (in_reply_to_activity && in_reply_to_activity.data["object"]["id"]) || in_reply_to,
+           (in_reply_to_activity && Object.normalize(in_reply_to_activity)) || nil,
         in_reply_to <- (in_reply_to_object && in_reply_to_object.data["id"]) || in_reply_to,
         attachments <- OStatus.get_attachments(entry),
         context <- get_context(entry, in_reply_to),
         tags <- OStatus.get_tags(entry),
--- a/lib/pleroma/web/ostatus/ostatus.ex
+++ b/lib/pleroma/web/ostatus/ostatus.ex
@ -294,7 +294,7 @@ def make_user(uri, update \\ false) do
      }
      with false <- update,
-           %User{} = user <- User.get_by_ap_id(data.ap_id) do
+           %User{} = user <- User.get_cached_by_ap_id(data.ap_id) do
        {:ok, user}
      else
        _e -> User.insert_or_update_user(data)
--- a/lib/pleroma/web/push/impl.ex
+++ b/lib/pleroma/web/push/impl.ex
@ -21,8 +21,10 @@ defmodule Pleroma.Web.Push.Impl do
  @doc "Performs sending notifications for user subscriptions"
  @spec perform(Notification.t()) :: list(any) | :error
  def perform(
-        %{activity: %{data: %{"type" => activity_type}, id: activity_id}, user_id: user_id} =
+        %{
-          notif
+          activity: %{data: %{"type" => activity_type}, id: activity_id} = activity,
          user_id: user_id
        } = notif
      )
      when activity_type in @types do
    actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
@ -30,13 +32,14 @@ def perform(
    type = Activity.mastodon_notification_type(notif.activity)
    gcm_api_key = Application.get_env(:web_push_encryption, :gcm_api_key)
    avatar_url = User.avatar_url(actor)
    object = Object.normalize(activity)
    for subscription <- fetch_subsriptions(user_id),
        get_in(subscription.data, ["alerts", type]) do
      %{
        title: format_title(notif),
        access_token: subscription.token.token,
-        body: format_body(notif, actor),
+        body: format_body(notif, actor, object),
        notification_id: notif.id,
        notification_type: type,
        icon: avatar_url,
@ -95,25 +98,25 @@ def build_sub(subscription) do
  end
  def format_body(
-        %{activity: %{data: %{"type" => "Create", "object" => %{"content" => content}}}},
+        %{activity: %{data: %{"type" => "Create"}}},
-        actor
+        actor,
        %{data: %{"content" => content}}
      ) do
    "@#{actor.nickname}: #{Utils.scrub_html_and_truncate(content, 80)}"
  end
  def format_body(
-        %{activity: %{data: %{"type" => "Announce", "object" => activity_id}}},
+        %{activity: %{data: %{"type" => "Announce"}}},
-        actor
+        actor,
        %{data: %{"content" => content}}
      ) do
    %Activity{data: %{"object" => %{"id" => object_id}}} = Activity.get_by_ap_id(activity_id)
    %Object{data: %{"content" => content}} = Object.get_by_ap_id(object_id)
    "@#{actor.nickname} repeated: #{Utils.scrub_html_and_truncate(content, 80)}"
  end
  def format_body(
        %{activity: %{data: %{"type" => type}}},
-        actor
+        actor,
        _object
      )
      when type in ["Follow", "Like"] do
    case type do
--- a/lib/pleroma/web/rel_me.ex
+++ b/lib/pleroma/web/rel_me.ex
@ -6,7 +6,8 @@ defmodule Pleroma.Web.RelMe do
  @hackney_options [
    pool: :media,
    recv_timeout: 2_000,
-    max_body: 2_000_000
+    max_body: 2_000_000,
    with_body: true
  ]
  if Mix.env() == :test do
--- a/lib/pleroma/web/rich_media/parser.ex
+++ b/lib/pleroma/web/rich_media/parser.ex
@ -12,7 +12,8 @@ defmodule Pleroma.Web.RichMedia.Parser do
  @hackney_options [
    pool: :media,
    recv_timeout: 2_000,
-    max_body: 2_000_000
+    max_body: 2_000_000,
    with_body: true
  ]
  def parse(nil), do: {:error, "No URL provided"}
--- a/lib/pleroma/web/router.ex
+++ b/lib/pleroma/web/router.ex
@ -135,6 +135,7 @@ defmodule Pleroma.Web.Router do
    post("/password_reset", UtilController, :password_reset)
    get("/emoji", UtilController, :emoji)
    get("/captcha", UtilController, :captcha)
    get("/healthcheck", UtilController, :healthcheck)
  end
  scope "/api/pleroma", Pleroma.Web do
@ -168,6 +169,8 @@ defmodule Pleroma.Web.Router do
    delete("/relay", AdminAPIController, :relay_unfollow)
    get("/invite_token", AdminAPIController, :get_invite_token)
    get("/invites", AdminAPIController, :invites)
    post("/revoke_invite", AdminAPIController, :revoke_invite)
    post("/email_invite", AdminAPIController, :email_invite)
    get("/password_reset", AdminAPIController, :get_password_reset)
@ -193,6 +196,7 @@ defmodule Pleroma.Web.Router do
      post("/change_password", UtilController, :change_password)
      post("/delete_account", UtilController, :delete_account)
      put("/notification_settings", UtilController, :update_notificaton_settings)
    end
    scope [] do
@ -239,7 +243,6 @@ defmodule Pleroma.Web.Router do
      get("/accounts/verify_credentials", MastodonAPIController, :verify_credentials)
      get("/accounts/relationships", MastodonAPIController, :relationships)
      get("/accounts/search", MastodonAPIController, :account_search)
      get("/accounts/:id/lists", MastodonAPIController, :account_lists)
      get("/accounts/:id/identity_proofs", MastodonAPIController, :empty_array)
@ -258,6 +261,7 @@ defmodule Pleroma.Web.Router do
      post("/notifications/dismiss", MastodonAPIController, :dismiss_notification)
      get("/notifications", MastodonAPIController, :notifications)
      get("/notifications/:id", MastodonAPIController, :get_notification)
      delete("/notifications/destroy_multiple", MastodonAPIController, :destroy_multiple)
      get("/scheduled_statuses", MastodonAPIController, :scheduled_statuses)
      get("/scheduled_statuses/:id", MastodonAPIController, :show_scheduled_status)
@ -339,6 +343,9 @@ defmodule Pleroma.Web.Router do
      post("/domain_blocks", MastodonAPIController, :block_domain)
      delete("/domain_blocks", MastodonAPIController, :unblock_domain)
      post("/pleroma/accounts/:id/subscribe", MastodonAPIController, :subscribe)
      post("/pleroma/accounts/:id/unsubscribe", MastodonAPIController, :unsubscribe)
    end
    scope [] do
@ -373,6 +380,8 @@ defmodule Pleroma.Web.Router do
    get("/trends", MastodonAPIController, :empty_array)
    get("/accounts/search", MastodonAPIController, :account_search)
    scope [] do
      pipe_through(:oauth_read_or_unauthenticated)
@ -389,6 +398,8 @@ defmodule Pleroma.Web.Router do
      get("/accounts/:id", MastodonAPIController, :user)
      get("/search", MastodonAPIController, :search)
      get("/pleroma/accounts/:id/favourites", MastodonAPIController, :user_favourites)
    end
  end
--- a/lib/pleroma/web/streamer.ex
+++ b/lib/pleroma/web/streamer.ex
@ -81,7 +81,7 @@ def handle_cast(%{action: :stream, topic: "list", item: item}, topics) do
        _ ->
          Pleroma.List.get_lists_from_activity(item)
          |> Enum.filter(fn list ->
-            owner = User.get_by_id(list.user_id)
+            owner = User.get_cached_by_id(list.user_id)
            Visibility.visible_for_user?(item, owner)
          end)
--- a/lib/pleroma/web/templates/layout/app.html.eex
+++ b/lib/pleroma/web/templates/layout/app.html.eex
@ -179,6 +179,17 @@
          flex-basis: 50%;
        }
      }
      .form-row {
        display: flex;
      }
      .form-row > label {
        text-align: left;
        line-height: 47px;
        flex: 1;
      }
      .form-row > input {
        flex: 2;
      }
    </style>
  </head>
  <body>
--- a/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex
+++ b/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex
@ -5,7 +5,7 @@
    <%= for scope <- @available_scopes do %>
      <%# Note: using hidden input with `unchecked_value` in order to distinguish user's empty selection from `scope` param being omitted %>
      <div class="scope">
-        <%= checkbox @form, :"scope_#{scope}", value: scope in @scopes && scope, checked_value: scope, unchecked_value: "", name: assigns[:scope_param] || "scope[]" %>
+        <%= checkbox @form, :"scope_#{scope}", value: scope in @scopes && scope, checked_value: scope, unchecked_value: "", name: "authorization[scope][]" %>
        <%= label @form, :"scope_#{scope}", String.capitalize(scope) %>
      </div>
    <% end %>
--- a/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex
+++ b/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex
@ -1,6 +1,6 @@
 <h2>Sign in with external provider</h2>
-<%= form_for @conn, o_auth_path(@conn, :prepare_request), [method: "get"], fn f -> %>
+<%= form_for @conn, o_auth_path(@conn, :prepare_request), [as: "authorization", method: "get"], fn f -> %>
  <%= render @view_module, "_scopes.html", Map.put(assigns, :form, f) %>
  <%= hidden_input f, :client_id, value: @client_id %>
--- a/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex
+++ b/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex
@ -8,8 +8,7 @@
 <h2>Registration Details</h2>
 <p>If you'd like to register a new account, please provide the details below.</p>
-
+<%= form_for @conn, o_auth_path(@conn, :register), [as: "authorization"], fn f -> %>
 <%= form_for @conn, o_auth_path(@conn, :register), [], fn f -> %>
 <div class="input">
  <%= label f, :nickname, "Nickname" %>
@ -25,8 +24,8 @@
 <p>Alternatively, sign in to connect to existing account.</p>
 <div class="input">
-  <%= label f, :auth_name, "Name or email" %>
+  <%= label f, :name, "Name or email" %>
-  <%= text_input f, :auth_name %>
+  <%= text_input f, :name %>
 </div>
 <div class="input">
  <%= label f, :password, "Password" %>
--- a/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
+++ b/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
@ -17,7 +17,7 @@
  <%= password_input f, :password %>
 </div>
-<%= render @view_module, "_scopes.html", Map.merge(assigns, %{form: f, scope_param: "authorization[scope][]"}) %>
+<%= render @view_module, "_scopes.html", Map.merge(assigns, %{form: f}) %>
 <%= hidden_input f, :client_id, value: @client_id %>
 <%= hidden_input f, :response_type, value: @response_type %>
--- a/lib/pleroma/web/templates/twitter_api/util/password_reset.html.eex
+++ b/lib/pleroma/web/templates/twitter_api/util/password_reset.html.eex
@ -1,12 +1,13 @@
 <h2>Password Reset for <%= @user.nickname %></h2>
 <%= form_for @conn, util_path(@conn, :password_reset), [as: "data"], fn f -> %>
-<%= label f, :password, "Password" %>
+  <div class="form-row">
-<%= password_input f, :password %>
+    <%= label f, :password, "Password" %>
-<br>
+    <%= password_input f, :password %>
-
+  </div>
-<%= label f, :password_confirmation, "Confirmation" %>
+  <div class="form-row">
-<%= password_input f, :password_confirmation %>
+    <%= label f, :password_confirmation, "Confirmation" %>
-<br>
+    <%= password_input f, :password_confirmation %>
-<%= hidden_input f, :token, value: @token.token %>
+  </div>
-<%= submit "Reset" %>
+  <%= hidden_input f, :token, value: @token.token %>
  <%= submit "Reset" %>
 <% end %>
--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
@ -22,7 +22,7 @@ defmodule Pleroma.Web.TwitterAPI.UtilController do
  def show_password_reset(conn, %{"token" => token}) do
    with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
-         %User{} = user <- User.get_by_id(token.user_id) do
+         %User{} = user <- User.get_cached_by_id(token.user_id) do
      render(conn, "password_reset.html", %{
        token: token,
        user: user
@ -75,7 +75,7 @@ def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profil
  def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
    if is_status?(acct) do
-      {:ok, object} = ActivityPub.fetch_object_from_id(acct)
+      {:ok, object} = Pleroma.Object.Fetcher.fetch_object_from_id(acct)
      %Activity{id: activity_id} = Activity.get_create_by_object_ap_id(object.data["id"])
      redirect(conn, to: "/notice/#{activity_id}")
    else
@ -101,7 +101,7 @@ def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
  end
  defp is_status?(acct) do
-    case ActivityPub.fetch_and_contain_remote_object_from_id(acct) do
+    case Pleroma.Object.Fetcher.fetch_and_contain_remote_object_from_id(acct) do
      {:ok, %{"type" => type}} when type in ["Article", "Note", "Video", "Page", "Question"] ->
        true
@ -113,13 +113,13 @@ defp is_status?(acct) do
  def do_remote_follow(conn, %{
        "authorization" => %{"name" => username, "password" => password, "id" => id}
      }) do
-    followee = User.get_by_id(id)
+    followee = User.get_cached_by_id(id)
    avatar = User.avatar_url(followee)
    name = followee.nickname
    with %User{} = user <- User.get_cached_by_nickname(username),
         true <- Pbkdf2.checkpw(password, user.password_hash),
-         %User{} = _followed <- User.get_by_id(id),
+         %User{} = _followed <- User.get_cached_by_id(id),
         {:ok, follower} <- User.follow(user, followee),
         {:ok, _activity} <- ActivityPub.follow(follower, followee) do
      conn
@ -141,7 +141,7 @@ def do_remote_follow(conn, %{
  end
  def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
-    with %User{} = followee <- User.get_by_id(id),
+    with %User{} = followee <- User.get_cached_by_id(id),
         {:ok, follower} <- User.follow(user, followee),
         {:ok, _activity} <- ActivityPub.follow(follower, followee) do
      conn
@ -286,18 +286,30 @@ def emoji(conn, _params) do
    emoji =
      Emoji.get_all()
      |> Enum.map(fn {short_code, path, tags} ->
-        %{short_code => %{image_url: path, tags: String.split(tags, ",")}}
+        {short_code, %{image_url: path, tags: tags}}
      end)
      |> Enum.into(%{})
    json(conn, emoji)
  end
  def update_notificaton_settings(%{assigns: %{user: user}} = conn, params) do
    with {:ok, _} <- User.update_notification_settings(user, params) do
      json(conn, %{status: "success"})
    end
  end
  def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
    follow_import(conn, %{"list" => File.read!(listfile.path)})
  end
  def follow_import(%{assigns: %{user: follower}} = conn, %{"list" => list}) do
-    with followed_identifiers <- String.split(list),
+    with lines <- String.split(list, "\n"),
         followed_identifiers <-
           Enum.map(lines, fn line ->
             String.split(line, ",") |> List.first()
           end)
           |> List.delete("Account address"),
         {:ok, _} = Task.start(fn -> User.follow_import(follower, followed_identifiers) end) do
      json(conn, "job started")
    end
@ -351,4 +363,22 @@ def delete_account(%{assigns: %{user: user}} = conn, params) do
  def captcha(conn, _params) do
    json(conn, Pleroma.Captcha.new())
  end
  def healthcheck(conn, _params) do
    info =
      if Pleroma.Config.get([:instance, :healthcheck]) do
        Pleroma.Healthcheck.system_info()
      else
        %{}
      end
    conn =
      if info[:healthy] do
        conn
      else
        Plug.Conn.put_status(conn, :service_unavailable)
      end
    json(conn, info)
  end
 end
--- a/lib/pleroma/web/twitter_api/twitter_api.ex
+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
@ -4,10 +4,10 @@
 defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
  alias Pleroma.Activity
-  alias Pleroma.Mailer
+  alias Pleroma.Emails.Mailer
  alias Pleroma.Emails.UserEmail
  alias Pleroma.Repo
  alias Pleroma.User
  alias Pleroma.UserEmail
  alias Pleroma.UserInviteToken
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.CommonAPI
@ -129,7 +129,7 @@ def upload(%Plug.Upload{} = file, %User{} = user, format \\ "xml") do
  end
  def register_user(params) do
-    token_string = params["token"]
+    token = params["token"]
    params = %{
      nickname: params["nickname"],
@ -163,22 +163,43 @@ def register_user(params) do
      {:error, %{error: Jason.encode!(%{captcha: [error]})}}
    else
      registrations_open = Pleroma.Config.get([:instance, :registrations_open])
-
+      registration_process(registrations_open, params, token)
-      # no need to query DB if registration is open
+    end
      token =
        unless registrations_open || is_nil(token_string) do
          Repo.get_by(UserInviteToken, %{token: token_string})
  end
-      cond do
+  defp registration_process(registration_open, params, token)
-        registrations_open || (!is_nil(token) && !token.used) ->
+       when registration_open == false or is_nil(registration_open) do
    invite =
      unless is_nil(token) do
        Repo.get_by(UserInviteToken, %{token: token})
      end
    valid_invite? = invite && UserInviteToken.valid_invite?(invite)
    case invite do
      nil ->
        {:error, "Invalid token"}
      invite when valid_invite? ->
        UserInviteToken.update_usage!(invite)
        create_user(params)
      _ ->
        {:error, "Expired token"}
    end
  end
  defp registration_process(true, params, _token) do
    create_user(params)
  end
  defp create_user(params) do
    changeset = User.register_changeset(%User{}, params)
-          with {:ok, user} <- User.register(changeset) do
+    case User.register(changeset) do
-            !registrations_open && UserInviteToken.mark_as_used(token.token)
+      {:ok, user} ->
        {:ok, user}
-          else
+
      {:error, changeset} ->
        errors =
          Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
@ -186,14 +207,6 @@ def register_user(params) do
        {:error, %{error: errors}}
    end
        !registrations_open && is_nil(token) ->
          {:error, "Invalid token"}
        !registrations_open && token.used ->
          {:error, "Expired token"}
      end
    end
  end
  def password_reset(nickname_or_email) do
@ -227,7 +240,7 @@ def get_user(user \\ nil, params) do
        end
      %{"screen_name" => nickname} ->
-        case User.get_by_nickname(nickname) do
+        case User.get_cached_by_nickname(nickname) do
          nil -> {:error, "No user with such screen_name"}
          target -> {:ok, target}
        end
@ -253,6 +266,7 @@ defp parse_int(string, default) when is_binary(string) do
  defp parse_int(_, default), do: default
  # TODO: unify the search query with MastoAPI one and do only pagination here
  def search(_user, %{"q" => query} = params) do
    limit = parse_int(params["rpp"], 20)
    page = parse_int(params["page"], 1)
@ -260,13 +274,13 @@ def search(_user, %{"q" => query} = params) do
    q =
      from(
-        a in Activity,
+        [a, o] in Activity.with_preloaded_object(Activity),
        where: fragment("?->>'type' = 'Create'", a.data),
        where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
        where:
          fragment(
-            "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
+            "to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
-            a.data,
+            o.data,
            ^query
          ),
        limit: ^limit,
@ -279,7 +293,7 @@ def search(_user, %{"q" => query} = params) do
  end
  def get_external_profile(for_user, uri) do
-    with %User{} = user <- User.get_or_fetch(uri) do
+    with {:ok, %User{} = user} <- User.get_or_fetch(uri) do
      {:ok, UserView.render("show.json", %{user: user, for: for_user})}
    else
      _e ->
--- a/lib/pleroma/web/twitter_api/twitter_api_controller.ex
+++ b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
@ -434,7 +434,7 @@ def password_reset(conn, params) do
  end
  def confirm_email(conn, %{"user_id" => uid, "token" => token}) do
-    with %User{} = user <- User.get_by_id(uid),
+    with %User{} = user <- User.get_cached_by_id(uid),
         true <- user.local,
         true <- user.info.confirmation_pending,
         true <- user.info.confirmation_token == token,
@ -587,7 +587,7 @@ def friend_requests(conn, params) do
  def approve_friend_request(conn, %{"user_id" => uid} = _params) do
    with followed <- conn.assigns[:user],
-         %User{} = follower <- User.get_by_id(uid),
+         %User{} = follower <- User.get_cached_by_id(uid),
         {:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
      conn
      |> put_view(UserView)
@ -599,7 +599,7 @@ def approve_friend_request(conn, %{"user_id" => uid} = _params) do
  def deny_friend_request(conn, %{"user_id" => uid} = _params) do
    with followed <- conn.assigns[:user],
-         %User{} = follower <- User.get_by_id(uid),
+         %User{} = follower <- User.get_cached_by_id(uid),
         {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
      conn
      |> put_view(UserView)
@ -632,7 +632,7 @@ def raw_empty_array(conn, _params) do
  defp build_info_cng(user, params) do
    info_params =
-      ["no_rich_text", "locked", "hide_followers", "hide_follows", "show_role"]
+      ["no_rich_text", "locked", "hide_followers", "hide_follows", "hide_favorites", "show_role"]
      |> Enum.reduce(%{}, fn key, res ->
        if value = params[key] do
          Map.put(res, key, value == "true")
--- a/lib/pleroma/web/twitter_api/views/activity_view.ex
+++ b/lib/pleroma/web/twitter_api/views/activity_view.ex
@ -224,15 +224,17 @@ def render("activity.json", %{activity: %{data: %{"type" => "Like"}} = activity}
  def render(
        "activity.json",
-        %{activity: %{data: %{"type" => "Create", "object" => object}} = activity} = opts
+        %{activity: %{data: %{"type" => "Create", "object" => object_id}} = activity} = opts
      ) do
    user = get_user(activity.data["actor"], opts)
-    created_at = object["published"] |> Utils.date_to_asctime()
+    object = Object.normalize(object_id)
-    like_count = object["like_count"] || 0
+
-    announcement_count = object["announcement_count"] || 0
+    created_at = object.data["published"] |> Utils.date_to_asctime()
-    favorited = opts[:for] && opts[:for].ap_id in (object["likes"] || [])
+    like_count = object.data["like_count"] || 0
-    repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] || [])
+    announcement_count = object.data["announcement_count"] || 0
    favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
    repeated = opts[:for] && opts[:for].ap_id in (object.data["announcements"] || [])
    pinned = activity.id in user.info.pinned_activities
    attentions =
@ -245,12 +247,12 @@ def render(
    conversation_id = get_context_id(activity, opts)
-    tags = activity.data["object"]["tag"] || []
+    tags = object.data["tag"] || []
-    possibly_sensitive = activity.data["object"]["sensitive"] || Enum.member?(tags, "nsfw")
+    possibly_sensitive = object.data["sensitive"] || Enum.member?(tags, "nsfw")
    tags = if possibly_sensitive, do: Enum.uniq(["nsfw" | tags]), else: tags
-    {summary, content} = render_content(object)
+    {summary, content} = render_content(object.data)
    html =
      content
@ -259,7 +261,7 @@ def render(
        activity,
        "twitterapi:content"
      )
-      |> Formatter.emojify(object["emoji"])
+      |> Formatter.emojify(object.data["emoji"])
    text =
      if content do
@ -284,33 +286,33 @@ def render(
    %{
      "id" => activity.id,
-      "uri" => activity.data["object"]["id"],
+      "uri" => object.data["id"],
      "user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
      "statusnet_html" => html,
      "text" => text,
      "is_local" => activity.local,
      "is_post_verb" => true,
      "created_at" => created_at,
-      "in_reply_to_status_id" => object["inReplyToStatusId"],
+      "in_reply_to_status_id" => reply_parent && reply_parent.id,
      "in_reply_to_screen_name" => reply_user && reply_user.nickname,
      "in_reply_to_profileurl" => User.profile_url(reply_user),
      "in_reply_to_ostatus_uri" => reply_user && reply_user.ap_id,
      "in_reply_to_user_id" => reply_user && reply_user.id,
      "statusnet_conversation_id" => conversation_id,
-      "attachments" => (object["attachment"] || []) |> ObjectRepresenter.enum_to_list(opts),
+      "attachments" => (object.data["attachment"] || []) |> ObjectRepresenter.enum_to_list(opts),
      "attentions" => attentions,
      "fave_num" => like_count,
      "repeat_num" => announcement_count,
      "favorited" => !!favorited,
      "repeated" => !!repeated,
      "pinned" => pinned,
-      "external_url" => object["external_url"] || object["id"],
+      "external_url" => object.data["external_url"] || object.data["id"],
      "tags" => tags,
      "activity_type" => "post",
      "possibly_sensitive" => possibly_sensitive,
      "visibility" => StatusView.get_visibility(object),
      "summary" => summary,
-      "summary_html" => summary |> Formatter.emojify(object["emoji"]),
+      "summary_html" => summary |> Formatter.emojify(object.data["emoji"]),
      "card" => card,
      "muted" => CommonAPI.thread_muted?(user, activity) || User.mutes?(opts[:for], user)
    }
--- a/lib/pleroma/web/twitter_api/views/user_view.ex
+++ b/lib/pleroma/web/twitter_api/views/user_view.ex
@ -74,7 +74,8 @@ defp do_render("user.json", %{user: user = %User{}} = assigns) do
      |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
      |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
-    data = %{
+    data =
      %{
        "created_at" => user.inserted_at |> Utils.format_naive_asctime(),
        "description" => HTML.strip_tags((user.bio || "") |> String.replace("<br>", "\n")),
        "description_html" => HTML.filter_tags(user.bio, User.html_filter_policy(for_user)),
@ -95,10 +96,6 @@ defp do_render("user.json", %{user: user = %User{}} = assigns) do
        "profile_image_url_https" => image,
        "profile_image_url_profile_size" => image,
        "profile_image_url_original" => image,
      "rights" => %{
        "delete_others_notice" => !!user.info.is_moderator,
        "admin" => !!user.info.is_admin
      },
        "screen_name" => user.nickname,
        "statuses_count" => user_info[:note_count],
        "statusnet_profile_url" => user.ap_id,
@ -106,8 +103,6 @@ defp do_render("user.json", %{user: user = %User{}} = assigns) do
        "background_image" => image_url(user.info.background) |> MediaProxy.url(),
        "is_local" => user.local,
        "locked" => user.info.locked,
      "default_scope" => user.info.default_scope,
      "no_rich_text" => user.info.no_rich_text,
        "hide_followers" => user.info.hide_followers,
        "hide_follows" => user.info.hide_follows,
        "fields" => fields,
@ -120,12 +115,8 @@ defp do_render("user.json", %{user: user = %User{}} = assigns) do
          }
          |> maybe_with_activation_status(user, for_user)
      }
-
+      |> maybe_with_user_settings(user, for_user)
-    data =
+      |> maybe_with_role(user, for_user)
      if(user.info.is_admin || user.info.is_moderator,
        do: maybe_with_role(data, user, for_user),
        else: data
      )
    if assigns[:token] do
      Map.put(data, "token", token_string(assigns[:token]))
@ -141,15 +132,35 @@ defp maybe_with_activation_status(data, user, %User{info: %{is_admin: true}}) do
  defp maybe_with_activation_status(data, _, _), do: data
  defp maybe_with_role(data, %User{id: id} = user, %User{id: id}) do
-    Map.merge(data, %{"role" => role(user), "show_role" => user.info.show_role})
+    Map.merge(data, %{
      "role" => role(user),
      "show_role" => user.info.show_role,
      "rights" => %{
        "delete_others_notice" => !!user.info.is_moderator,
        "admin" => !!user.info.is_admin
      }
    })
  end
  defp maybe_with_role(data, %User{info: %{show_role: true}} = user, _user) do
-    Map.merge(data, %{"role" => role(user)})
+    Map.merge(data, %{
      "role" => role(user),
      "rights" => %{
        "delete_others_notice" => !!user.info.is_moderator,
        "admin" => !!user.info.is_admin
      }
    })
  end
  defp maybe_with_role(data, _, _), do: data
  defp maybe_with_user_settings(data, %User{info: info, id: id} = _user, %User{id: id}) do
    data
    |> Kernel.put_in(["default_scope"], info.default_scope)
    |> Kernel.put_in(["no_rich_text"], info.no_rich_text)
  end
  defp maybe_with_user_settings(data, _, _), do: data
  defp role(%User{info: %{:is_admin => true}}), do: "admin"
  defp role(%User{info: %{:is_moderator => true}}), do: "moderator"
  defp role(_), do: "member"
--- a/lib/pleroma/web/web_finger/web_finger.ex
+++ b/lib/pleroma/web/web_finger/web_finger.ex
@ -37,7 +37,7 @@ def webfinger(resource, fmt) when fmt in ["XML", "JSON"] do
    regex = ~r/(acct:)?(?<username>\w+)@#{host}/
    with %{"username" => username} <- Regex.named_captures(regex, resource),
-         %User{} = user <- User.get_by_nickname(username) do
+         %User{} = user <- User.get_cached_by_nickname(username) do
      {:ok, represent_user(user, fmt)}
    else
      _e ->
--- a/mix.exs
+++ b/mix.exs
@ -22,7 +22,7 @@ def project do
      homepage_url: "https://pleroma.social/",
      docs: [
        logo: "priv/static/static/logo.png",
-        extras: ["README.md" | Path.wildcard("docs/**/*.md")],
+        extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/**/*.md"),
        groups_for_extras: [
          "Installation manuals": Path.wildcard("docs/installation/*.md"),
          Configuration: Path.wildcard("docs/config/*.md"),
@ -84,13 +84,14 @@ defp deps do
      {:ex_aws, "~> 2.0"},
      {:ex_aws_s3, "~> 2.0"},
      {:earmark, "~> 1.3"},
      {:bbcode, "~> 0.1"},
      {:ex_machina, "~> 2.3", only: :test},
      {:credo, "~> 0.9.3", only: [:dev, :test]},
      {:mock, "~> 0.3.1", only: :test},
      {:crypt,
       git: "https://github.com/msantos/crypt", ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"},
      {:cors_plug, "~> 1.5"},
-      {:ex_doc, "~> 0.19", only: :dev, runtime: false},
+      {:ex_doc, "~> 0.20.2", only: :dev, runtime: false},
      {:web_push_encryption, "~> 0.2.1"},
      {:swoosh, "~> 0.20"},
      {:gen_smtp, "~> 0.13"},
@ -101,7 +102,7 @@ defp deps do
      {:ueberauth, "~> 0.4"},
      {:auto_linker,
       git: "https://git.pleroma.social/pleroma/auto_linker.git",
-       ref: "479dd343f4e563ff91215c8275f3b5c67e032850"},
+       ref: "c00c4e75b35367fa42c95ffd9b8c455bf9995829"},
      {:pleroma_job_queue, "~> 0.2.0"},
      {:telemetry, "~> 0.3"},
      {:prometheus_ex, "~> 3.0"},
--- a/mix.lock
+++ b/mix.lock
@ -1,7 +1,8 @@
 %{
  "accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm"},
-  "auto_linker": {:git, "https://git.pleroma.social/pleroma/auto_linker.git", "479dd343f4e563ff91215c8275f3b5c67e032850", [ref: "479dd343f4e563ff91215c8275f3b5c67e032850"]},
+  "auto_linker": {:git, "https://git.pleroma.social/pleroma/auto_linker.git", "c00c4e75b35367fa42c95ffd9b8c455bf9995829", [ref: "c00c4e75b35367fa42c95ffd9b8c455bf9995829"]},
  "base64url": {:hex, :base64url, "0.0.1", "36a90125f5948e3afd7be97662a1504b934dd5dac78451ca6e9abf85a10286be", [:rebar], [], "hexpm"},
  "bbcode": {:hex, :bbcode, "0.1.0", "400e618b640b635261611d7fb7f79d104917fc5b084aae371ab6b08477cb035b", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
  "bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"},
  "cachex": {:hex, :cachex, "3.0.2", "1351caa4e26e29f7d7ec1d29b53d6013f0447630bbf382b4fb5d5bad0209f203", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm"},
  "calendar": {:hex, :calendar, "0.17.4", "22c5e8d98a4db9494396e5727108dffb820ee0d18fed4b0aa8ab76e4f5bc32f1", [:mix], [{:tzdata, "~> 0.5.8 or ~> 0.1.201603", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm"},
@ -16,13 +17,13 @@
  "crypt": {:git, "https://github.com/msantos/crypt", "1f2b58927ab57e72910191a7ebaeff984382a1d3", [ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"]},
  "db_connection": {:hex, :db_connection, "2.0.5", "ddb2ba6761a08b2bb9ca0e7d260e8f4dd39067426d835c24491a321b7f92a4da", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
  "decimal": {:hex, :decimal, "1.7.0", "30d6b52c88541f9a66637359ddf85016df9eb266170d53105f02e4a67e00c5aa", [:mix], [], "hexpm"},
-  "earmark": {:hex, :earmark, "1.3.0", "17f0c38eaafb4800f746b457313af4b2442a8c2405b49c645768680f900be603", [:mix], [], "hexpm"},
+  "earmark": {:hex, :earmark, "1.3.2", "b840562ea3d67795ffbb5bd88940b1bed0ed9fa32834915125ea7d02e35888a5", [:mix], [], "hexpm"},
  "ecto": {:hex, :ecto, "3.0.7", "44dda84ac6b17bbbdeb8ac5dfef08b7da253b37a453c34ab1a98de7f7e5fec7f", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm"},
  "ecto_sql": {:hex, :ecto_sql, "3.0.5", "7e44172b4f7aca4469f38d7f6a3da394dbf43a1bcf0ca975e958cb957becd74e", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.0.6", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.3.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
  "eternal": {:hex, :eternal, "1.2.0", "e2a6b6ce3b8c248f7dc31451aefca57e3bdf0e48d73ae5043229380a67614c41", [:mix], [], "hexpm"},
  "ex_aws": {:hex, :ex_aws, "2.1.0", "b92651527d6c09c479f9013caa9c7331f19cba38a650590d82ebf2c6c16a1d8a", [:mix], [{:configparser_ex, "~> 2.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "1.6.3 or 1.6.5 or 1.7.1 or 1.8.6 or ~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jsx, "~> 2.8", [hex: :jsx, repo: "hexpm", optional: true]}, {:poison, ">= 1.2.0", [hex: :poison, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}, {:xml_builder, "~> 0.1.0", [hex: :xml_builder, repo: "hexpm", optional: true]}], "hexpm"},
  "ex_aws_s3": {:hex, :ex_aws_s3, "2.0.1", "9e09366e77f25d3d88c5393824e613344631be8db0d1839faca49686e99b6704", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm"},
-  "ex_doc": {:hex, :ex_doc, "0.19.1", "519bb9c19526ca51d326c060cb1778d4a9056b190086a8c6c115828eaccea6cf", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.7", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm"},
+  "ex_doc": {:hex, :ex_doc, "0.20.2", "1bd0dfb0304bade58beb77f20f21ee3558cc3c753743ae0ddbb0fd7ba2912331", [:mix], [{:earmark, "~> 1.3", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.10", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm"},
  "ex_machina": {:hex, :ex_machina, "2.3.0", "92a5ad0a8b10ea6314b876a99c8c9e3f25f4dde71a2a835845b136b9adaf199a", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm"},
  "ex_syslogger": {:git, "https://github.com/slashmili/ex_syslogger.git", "f3963399047af17e038897c69e20d552e6899e1d", [tag: "1.4.0"]},
  "floki": {:hex, :floki, "0.20.4", "be42ac911fece24b4c72f3b5846774b6e61b83fe685c2fc9d62093277fb3bc86", [:mix], [{:html_entities, "~> 0.4.0", [hex: :html_entities, repo: "hexpm", optional: false]}, {:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
@ -35,8 +36,8 @@
  "idna": {:hex, :idna, "6.0.0", "689c46cbcdf3524c44d5f3dde8001f364cd7608a99556d8fbd8239a5798d4c10", [:rebar3], [{:unicode_util_compat, "0.4.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm"},
  "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
  "jose": {:hex, :jose, "1.8.4", "7946d1e5c03a76ac9ef42a6e6a20001d35987afd68c2107bcd8f01a84e75aa73", [:mix, :rebar3], [{:base64url, "~> 0.0.1", [hex: :base64url, repo: "hexpm", optional: false]}], "hexpm"},
-  "makeup": {:hex, :makeup, "0.5.5", "9e08dfc45280c5684d771ad58159f718a7b5788596099bdfb0284597d368a882", [:mix], [{:nimble_parsec, "~> 0.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
+  "makeup": {:hex, :makeup, "0.8.0", "9cf32aea71c7fe0a4b2e9246c2c4978f9070257e5c9ce6d4a28ec450a839b55f", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
-  "makeup_elixir": {:hex, :makeup_elixir, "0.10.0", "0f09c2ddf352887a956d84f8f7e702111122ca32fbbc84c2f0569b8b65cbf7fa", [:mix], [{:makeup, "~> 0.5.5", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm"},
+  "makeup_elixir": {:hex, :makeup_elixir, "0.13.0", "be7a477997dcac2e48a9d695ec730b2d22418292675c75aa2d34ba0909dcdeda", [:mix], [{:makeup, "~> 0.8", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm"},
  "meck": {:hex, :meck, "0.8.13", "ffedb39f99b0b99703b8601c6f17c7f76313ee12de6b646e671e3188401f7866", [:rebar3], [], "hexpm"},
  "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm"},
  "mime": {:hex, :mime, "1.3.1", "30ce04ab3175b6ad0bdce0035cba77bba68b813d523d1aac73d9781b4d193cf8", [:mix], [], "hexpm"},
@ -44,7 +45,7 @@
  "mochiweb": {:hex, :mochiweb, "2.15.0", "e1daac474df07651e5d17cc1e642c4069c7850dc4508d3db7263a0651330aacc", [:rebar3], [], "hexpm"},
  "mock": {:hex, :mock, "0.3.1", "994f00150f79a0ea50dc9d86134cd9ebd0d177ad60bd04d1e46336cdfdb98ff9", [:mix], [{:meck, "~> 0.8.8", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm"},
  "mogrify": {:hex, :mogrify, "0.6.1", "de1b527514f2d95a7bbe9642eb556061afb337e220cf97adbf3a4e6438ed70af", [:mix], [], "hexpm"},
-  "nimble_parsec": {:hex, :nimble_parsec, "0.4.0", "ee261bb53214943679422be70f1658fff573c5d0b0a1ecd0f18738944f818efe", [:mix], [], "hexpm"},
+  "nimble_parsec": {:hex, :nimble_parsec, "0.5.0", "90e2eca3d0266e5c53f8fbe0079694740b9c91b6747f2b7e3c5d21966bba8300", [:mix], [], "hexpm"},
  "parse_trans": {:hex, :parse_trans, "3.3.0", "09765507a3c7590a784615cfd421d101aec25098d50b89d7aa1d66646bc571c1", [:rebar3], [], "hexpm"},
  "pbkdf2_elixir": {:hex, :pbkdf2_elixir, "0.12.3", "6706a148809a29c306062862c803406e88f048277f6e85b68faf73291e820b84", [:mix], [], "hexpm"},
  "phoenix": {:hex, :phoenix, "1.4.1", "801f9d632808657f1f7c657c8bbe624caaf2ba91429123ebe3801598aea4c3d9", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "hexpm"},
--- a/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs
+++ b/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs
@ -0,0 +1,12 @@
 defmodule Pleroma.Repo.Migrations.AddFieldsToUserInviteTokens do
  use Ecto.Migration
  def change do
    alter table(:user_invite_tokens) do
      add(:expires_at, :date)
      add(:uses, :integer, default: 0)
      add(:max_use, :integer)
      add(:invite_type, :string, default: "one_time")
    end
  end
 end
--- a/priv/repo/migrations/20190405160700_add_index_on_subscribers.exs
+++ b/priv/repo/migrations/20190405160700_add_index_on_subscribers.exs
@ -0,0 +1,8 @@
 defmodule Pleroma.Repo.Migrations.AddIndexOnSubscribers do
  use Ecto.Migration
  @disable_ddl_transaction true
  def change do
    create index(:users, ["(info->'subscribers')"], name: :users_subscribers_index, using: :gin, concurrently: true)
  end
 end
--- a/priv/repo/migrations/20190413082658_create_bookmarks.exs
+++ b/priv/repo/migrations/20190413082658_create_bookmarks.exs
@ -0,0 +1,14 @@
 defmodule Pleroma.Repo.Migrations.CreateBookmarks do
  use Ecto.Migration
  def change do
    create table(:bookmarks) do
      add(:user_id, references(:users, type: :uuid, on_delete: :delete_all))
      add(:activity_id, references(:activities, type: :uuid, on_delete: :delete_all))
      timestamps()
    end
    create(unique_index(:bookmarks, [:user_id, :activity_id]))
  end
 end
--- a/priv/repo/migrations/20190414125034_migrate_old_bookmarks.exs
+++ b/priv/repo/migrations/20190414125034_migrate_old_bookmarks.exs
@ -0,0 +1,29 @@
 defmodule Pleroma.Repo.Migrations.MigrateOldBookmarks do
  use Ecto.Migration
  import Ecto.Query
  alias Pleroma.Activity
  alias Pleroma.Bookmark
  alias Pleroma.User
  alias Pleroma.Repo
  def change do
    query =
      from(u in User,
        where: u.local == true,
        where: fragment("array_length(bookmarks, 1)") > 0,
        select: %{id: u.id, bookmarks: fragment("bookmarks")}
      )
    Repo.stream(query)
    |> Enum.each(fn %{id: user_id, bookmarks: bookmarks} ->
      Enum.each(bookmarks, fn ap_id ->
        activity = Activity.get_create_by_object_ap_id(ap_id)
 	unless is_nil(activity), do: {:ok, _} = Bookmark.create(user_id, activity.id)
      end)
    end)
    alter table(:users) do
      remove(:bookmarks)
    end
  end
 end
--- a/priv/static/finmoji/1000px/a_trusted_friend.png
+++ b/priv/static/finmoji/1000px/a_trusted_friend.png
--- a/priv/static/finmoji/1000px/alandislands.png
+++ b/priv/static/finmoji/1000px/alandislands.png
--- a/priv/static/finmoji/1000px/association.png
+++ b/priv/static/finmoji/1000px/association.png
--- a/priv/static/finmoji/1000px/auroraborealis.png
+++ b/priv/static/finmoji/1000px/auroraborealis.png
--- a/priv/static/finmoji/1000px/baby_in_a_box.png
+++ b/priv/static/finmoji/1000px/baby_in_a_box.png
--- a/priv/static/finmoji/1000px/bear.png
+++ b/priv/static/finmoji/1000px/bear.png
--- a/Show more
+++ b/Show more