matrix-rust-sdk

// Copyright 2020 Damir Jelić

// Copyright 2020 The Matrix.org Foundation C.I.C.

// Copyright 2022 Kévin Commaille

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

use futures_core::Stream;

use futures_util::{StreamExt, stream};

#[cfg(feature = "experimental-element-recent-emojis")]

use itertools::Itertools;

#[cfg(feature = "experimental-element-recent-emojis")]

use js_int::uint;

#[cfg(feature = "experimental-element-recent-emojis")]

use matrix_sdk_base::recent_emojis::RecentEmojisContent;

use matrix_sdk_base::{

    SendOutsideWasm, StateStoreDataKey, StateStoreDataValue, SyncOutsideWasm,

    media::{MediaFormat, MediaRequestParameters},

    store::StateStoreExt,

};

use mime::Mime;

#[cfg(feature = "experimental-element-recent-emojis")]

use ruma::api::client::config::set_global_account_data::v3::Request as UpdateGlobalAccountDataRequest;

use ruma::{

    ClientSecret, MxcUri, OwnedMxcUri, OwnedRoomId, OwnedUserId, RoomId, SessionId, UInt, UserId,

    api::{

        Metadata,

        client::{

            account::{

                add_3pid, change_password, deactivate, delete_3pid, get_3pids,

                request_3pid_management_token_via_email, request_3pid_management_token_via_msisdn,

                request_openid_token,

            },

            config::{get_global_account_data, set_global_account_data},

            profile::{

                DisplayName, StaticProfileField, delete_profile_field, get_avatar_url, get_profile,

                get_profile_field, set_avatar_url, set_display_name, set_profile_field,

            },

            uiaa::AuthData,

        },

        error::ErrorKind,

    },

    assign,

    events::{

        AnyGlobalAccountDataEventContent, GlobalAccountDataEvent, GlobalAccountDataEventContent,

        GlobalAccountDataEventType, StaticEventContent,

        ignored_user_list::{IgnoredUser, IgnoredUserListEventContent},

        media_preview_config::{

            InviteAvatars, MediaPreviewConfigEventContent, MediaPreviews,

            UnstableMediaPreviewConfigEventContent,

        },

        push_rules::PushRulesEventContent,

        room::MediaSource,

    },

    profile::{ProfileFieldName, ProfileFieldValue},

    push::Ruleset,

    serde::Raw,

    thirdparty::Medium,

};

use serde::Deserialize;

use tracing::error;

use crate::{Client, Error, Result, config::RequestConfig};

/// The maximum number of recent emojis that should be stored and loaded.

#[cfg(feature = "experimental-element-recent-emojis")]

const MAX_RECENT_EMOJI_COUNT: usize = 100;

/// A high-level API to manage the client owner's account.

///

/// All the methods on this struct send a request to the homeserver.

#[derive(Debug, Clone)]

pub struct Account {

    /// The underlying HTTP client.

    client: Client,

}

impl Account {

    /// The maximum number of visited room identifiers to keep in the state

    /// store.

    const VISITED_ROOMS_LIMIT: usize = 20;

    pub(crate) fn new(client: Client) -> Self {

        Self { client }

    }

    /// Get the display name of the account.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// # use matrix_sdk::Client;

    /// # use url::Url;

    /// # async {

    /// # let homeserver = Url::parse("http://example.com")?;

    /// let user = "example";

    /// let client = Client::new(homeserver).await?;

    /// client.matrix_auth().login_username(user, "password").send().await?;

    ///

    /// if let Some(name) = client.account().get_display_name().await? {

    ///     println!("Logged in as user '{user}' with display name '{name}'");

    /// }

    /// # anyhow::Ok(()) };

    /// ```

    pub async fn get_display_name(&self) -> Result<Option<String>> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        self.fetch_profile_field_of_static::<DisplayName>(user_id.to_owned()).await

    }

    /// Set the display name of the account.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// # use matrix_sdk::Client;

    /// # use url::Url;

    /// # async {

    /// # let homeserver = Url::parse("http://example.com")?;

    /// let user = "example";

    /// let client = Client::new(homeserver).await?;

    /// client.matrix_auth().login_username(user, "password").send().await?;

    ///

    /// client.account().set_display_name(Some("Alice")).await?;

    /// # anyhow::Ok(()) };

    /// ```

    pub async fn set_display_name(&self, name: Option<&str>) -> Result<()> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        // Prefer the endpoint to delete profile fields, if it is supported.

        if name.is_none() {

            let versions = self.client.supported_versions().await?;

            if delete_profile_field::v3::Request::PATH_BUILDER.is_supported(&versions) {

                return self.delete_profile_field(ProfileFieldName::DisplayName).await;

            }

        }

        // If name is `Some(_)`, this endpoint is the same as `set_profile_field`, but

        // we still need to use it in case it is `None` and the server doesn't support

        // the delete endpoint yet.

        #[allow(deprecated)]

        let request =

            set_display_name::v3::Request::new(user_id.to_owned(), name.map(ToOwned::to_owned));

        self.client.send(request).await?;

        Ok(())

    }

    /// Request an OpenID token for the current account.

    pub async fn request_openid_token(&self) -> Result<request_openid_token::v3::Response> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        self.client

            .send(request_openid_token::v3::Request::new(user_id.to_owned()))

            .await

            .map_err(|error| Error::Http(Box::new(error)))

    }

    /// Get the MXC URI of the account's avatar, if set.

    ///

    /// This always sends a request to the server to retrieve this information.

    /// If successful, this fills the cache, and makes it so that

    /// [`Self::get_cached_avatar_url`] will always return something.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// # use matrix_sdk::Client;

    /// # use url::Url;

    /// # async {

    /// # let homeserver = Url::parse("http://example.com")?;

    /// # let user = "example";

    /// let client = Client::new(homeserver).await?;

    /// client.matrix_auth().login_username(user, "password").send().await?;

    ///

    /// if let Some(url) = client.account().get_avatar_url().await? {

    ///     println!("Your avatar's mxc url is {url}");

    /// }

    /// # anyhow::Ok(()) };

    /// ```

    pub async fn get_avatar_url(&self) -> Result<Option<OwnedMxcUri>> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        #[allow(deprecated)] // get_profile_field fails when the response is {"avatar_url":null} 🤷‍♂️

        let request = get_avatar_url::v3::Request::new(user_id.to_owned());

        let avatar_url = self

            .client

            .send(request)

            .with_request_config(RequestConfig::short_retry().force_auth())

            .await?

            .avatar_url;

        if let Some(url) = avatar_url.clone() {

            // If an avatar is found cache it.

            let _ = self

                .client

                .state_store()

                .set_kv_data(

                    StateStoreDataKey::UserAvatarUrl(user_id),

                    StateStoreDataValue::UserAvatarUrl(url),

                )

                .await;

        } else {

            // If there is no avatar the user has removed it and we uncache it.

            let _ = self

                .client

                .state_store()

                .remove_kv_data(StateStoreDataKey::UserAvatarUrl(user_id))

                .await;

        }

        Ok(avatar_url)

    }

    /// Get the URL of the account's avatar, if is stored in cache.

    pub async fn get_cached_avatar_url(&self) -> Result<Option<OwnedMxcUri>> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        let data = self

            .client

            .state_store()

            .get_kv_data(StateStoreDataKey::UserAvatarUrl(user_id))

            .await?;

        Ok(data.map(|v| v.into_user_avatar_url().expect("Session data is not a user avatar url")))

    }

    /// Set the MXC URI of the account's avatar.

    ///

    /// The avatar is unset if `url` is `None`.

    pub async fn set_avatar_url(&self, url: Option<&MxcUri>) -> Result<()> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        // Prefer the endpoint to delete profile fields, if it is supported.

        if url.is_none() {

            let versions = self.client.supported_versions().await?;

            if delete_profile_field::v3::Request::PATH_BUILDER.is_supported(&versions) {

                return self.delete_profile_field(ProfileFieldName::AvatarUrl).await;

            }

        }

        // If url is `Some(_)`, this endpoint is the same as `set_profile_field`, but

        // we still need to use it in case it is `None` and the server doesn't support

        // the delete endpoint yet.

        #[allow(deprecated)]

        let request =

            set_avatar_url::v3::Request::new(user_id.to_owned(), url.map(ToOwned::to_owned));

        self.client.send(request).await?;

        Ok(())

    }

    /// Get the account's avatar, if set.

    ///

    /// Returns the avatar.

    ///

    /// If a thumbnail is requested no guarantee on the size of the image is

    /// given.

    ///

    /// # Arguments

    ///

    /// * `format` - The desired format of the avatar.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// # use matrix_sdk::Client;

    /// # use matrix_sdk::ruma::room_id;

    /// # use matrix_sdk::media::MediaFormat;

    /// # use url::Url;

    /// # async {

    /// # let homeserver = Url::parse("http://example.com")?;

    /// # let user = "example";

    /// let client = Client::new(homeserver).await?;

    /// client.matrix_auth().login_username(user, "password").send().await?;

    ///

    /// if let Some(avatar) = client.account().get_avatar(MediaFormat::File).await?

    /// {

    ///     std::fs::write("avatar.png", avatar);

    /// }

    /// # anyhow::Ok(()) };

    /// ```

    pub async fn get_avatar(&self, format: MediaFormat) -> Result<Option<Vec<u8>>> {

        if let Some(url) = self.get_avatar_url().await? {

            let request = MediaRequestParameters { source: MediaSource::Plain(url), format };

            Ok(Some(self.client.media().get_media_content(&request, true).await?))

        } else {

            Ok(None)

        }

    }

    /// Upload and set the account's avatar.

    ///

    /// This will upload the data produced by the reader to the homeserver's

    /// content repository, and set the user's avatar to the MXC URI for the

    /// uploaded file.

    ///

    /// This is a convenience method for calling [`Media::upload()`],

    /// followed by [`Account::set_avatar_url()`].

    ///

    /// Returns the MXC URI of the uploaded avatar.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// # use std::fs;

    /// # use matrix_sdk::Client;

    /// # use url::Url;

    /// # async {

    /// # let homeserver = Url::parse("http://localhost:8080")?;

    /// # let client = Client::new(homeserver).await?;

    /// let image = fs::read("/home/example/selfie.jpg")?;

    ///

    /// client.account().upload_avatar(&mime::IMAGE_JPEG, image).await?;

    /// # anyhow::Ok(()) };

    /// ```

    ///

    /// [`Media::upload()`]: crate::Media::upload

    pub async fn upload_avatar(&self, content_type: &Mime, data: Vec<u8>) -> Result<OwnedMxcUri> {

        let upload_response = self.client.media().upload(content_type, data, None).await?;

        self.set_avatar_url(Some(&upload_response.content_uri)).await?;

        Ok(upload_response.content_uri)

    }

    /// Get the profile of this account.

    ///

    /// Allows to get all the profile data in a single call.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// # use matrix_sdk::Client;

    /// use ruma::api::client::profile::{AvatarUrl, DisplayName};

    /// # use url::Url;

    /// # async {

    /// # let homeserver = Url::parse("http://localhost:8080")?;

    /// # let client = Client::new(homeserver).await?;

    ///

    /// let profile = client.account().fetch_user_profile().await?;

    /// let display_name = profile.get_static::<DisplayName>()?;

    /// let avatar_url = profile.get_static::<AvatarUrl>()?;

    ///

    /// println!("You are '{display_name:?}' with avatar '{avatar_url:?}'");

    /// # anyhow::Ok(()) };

    /// ```

    pub async fn fetch_user_profile(&self) -> Result<get_profile::v3::Response> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        self.fetch_user_profile_of(user_id).await

    }

    /// Get the profile for a given user id

    ///

    /// # Arguments

    ///

    /// * `user_id` the matrix id this function downloads the profile for

    pub async fn fetch_user_profile_of(

        &self,

        user_id: &UserId,

    ) -> Result<get_profile::v3::Response> {

        let request = get_profile::v3::Request::new(user_id.to_owned());

        Ok(self

            .client

            .send(request)

            .with_request_config(RequestConfig::short_retry().force_auth())

            .await?)

    }

    /// Get the given field from the given user's profile.

    ///

    /// # Arguments

    ///

    /// * `user_id` - The ID of the user to get the profile field of.

    ///

    /// * `field` - The name of the profile field to get.

    ///

    /// # Returns

    ///

    /// Returns an error if the request fails or if deserialization of the

    /// response fails.

    ///

    /// If the field is not set, the server should respond with an error with an

    /// [`ErrorCode::NotFound`], but it might also respond with an empty

    /// response, which would result in `Ok(None)`. Note that this error code

    /// might also mean that the given user ID doesn't exist.

    ///

    /// [`ErrorCode::NotFound`]: ruma::api::error::ErrorCode::NotFound

    pub async fn fetch_profile_field_of(

        &self,

        user_id: OwnedUserId,

        field: ProfileFieldName,

    ) -> Result<Option<ProfileFieldValue>> {

        let request = get_profile_field::v3::Request::new(user_id, field);

        let response = self

            .client

            .send(request)

            .with_request_config(RequestConfig::short_retry().force_auth())

            .await?;

        Ok(response.value)

    }

    /// Get the given statically-known field from the given user's profile.

    ///

    /// # Arguments

    ///

    /// * `user_id` - The ID of the user to get the profile field of.

    ///

    /// # Returns

    ///

    /// Returns an error if the request fails or if deserialization of the

    /// response fails.

    ///

    /// If the field is not set, the server should respond with an error with an

    /// [`ErrorCode::NotFound`], but it might also respond with an empty

    /// response, which would result in `Ok(None)`. Note that this error code

    /// might also mean that the given user ID doesn't exist.

    ///

    /// [`ErrorCode::NotFound`]: ruma::api::error::ErrorCode::NotFound

    pub async fn fetch_profile_field_of_static<F>(

        &self,

        user_id: OwnedUserId,

    ) -> Result<Option<F::Value>>

    where

        F: StaticProfileField

            + std::fmt::Debug

            + Clone

            + SendOutsideWasm

            + SyncOutsideWasm

            + 'static,

        F::Value: SendOutsideWasm + SyncOutsideWasm,

    {

        let request = get_profile_field::v3::Request::new_static::<F>(user_id);

        let response = self

            .client

            .send(request)

            .with_request_config(RequestConfig::short_retry().force_auth())

            .await?;

        Ok(response.value)

    }

    /// Set the given field of our own user's profile.

    ///

    /// [`Client::homeserver_capabilities()`] should be called first to check it

    /// the field can be set on the homeserver.

    ///

    /// # Arguments

    ///

    /// * `value` - The value of the profile field to set.

    ///

    /// # Returns

    ///

    /// Returns an error if the request fails.

    pub async fn set_profile_field(&self, value: ProfileFieldValue) -> Result<()> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        let request = set_profile_field::v3::Request::new(user_id.to_owned(), value);

        self.client.send(request).await?;

        Ok(())

    }

    /// Delete the given field of our own user's profile.

    ///

    /// [`Client::homeserver_capabilities()`] should be called first to check it

    /// the field can be modified on the homeserver.

    ///

    /// # Arguments

    ///

    /// * `field` - The profile field to delete.

    ///

    /// # Returns

    ///

    /// Returns an error if the server doesn't support extended profile fields

    /// of if the request fails in some other way.

    pub async fn delete_profile_field(&self, field: ProfileFieldName) -> Result<()> {

        let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;

        let request = delete_profile_field::v3::Request::new(user_id.to_owned(), field);

        self.client.send(request).await?;

        Ok(())

    }

    /// Change the password of the account.

    ///

    /// # Arguments

    ///

    /// * `new_password` - The new password to set.

    ///

    /// * `auth_data` - This request uses the [User-Interactive Authentication

    ///   API][uiaa]. The first request needs to set this to `None` and will

    ///   always fail with an [`UiaaResponse`]. The response will contain

    ///   information for the interactive auth and the same request needs to be

    ///   made but this time with some `auth_data` provided.

    ///

    /// # Returns

    ///

    /// This method might return an [`ErrorKind::WeakPassword`] error if the new

    /// password is considered insecure by the homeserver, with details about

    /// the strength requirements in the error's message.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// # use matrix_sdk::Client;

    /// # use matrix_sdk::ruma::{

    /// #     api::client::{

    /// #         account::change_password::v3::{Request as ChangePasswordRequest},

    /// #         uiaa::{AuthData, Dummy},

    /// #     },

    /// #     assign,

    /// # };

    /// # use url::Url;

    /// # async {

    /// # let homeserver = Url::parse("http://localhost:8080")?;

    /// # let client = Client::new(homeserver).await?;

    /// client.account().change_password(

    ///     "myverysecretpassword",

    ///     Some(AuthData::Dummy(Dummy::new())),

    /// ).await?;

    /// # anyhow::Ok(()) };

    /// ```

    /// [uiaa]: https://spec.matrix.org/v1.2/client-server-api/#user-interactive-authentication-api

    /// [`UiaaResponse`]: ruma::api::client::uiaa::UiaaResponse

    /// [`ErrorKind::WeakPassword`]: ruma::api::error::ErrorKind::WeakPassword

    pub async fn change_password(

        &self,