use chrono::NaiveDateTime; use super::*; impl Database {    /// Creates a new user.    pub async fn create_user(        &self,        email_address: &str,        name: Option<&str>,        admin: bool,        params: NewUserParams,    ) -> Result<NewUserResult> {        self.transaction(|tx| async {            let tx = tx;            let user = user::Entity::insert(user::ActiveModel {                email_address: ActiveValue::set(Some(email_address.into())),                name: ActiveValue::set(name.map(|s| s.into())),                github_login: ActiveValue::set(params.github_login.clone()),                github_user_id: ActiveValue::set(params.github_user_id),                admin: ActiveValue::set(admin),                metrics_id: ActiveValue::set(Uuid::new_v4()),                ..Default::default()            })            .on_conflict(                OnConflict::column(user::Column::GithubUserId)                    .update_columns([                        user::Column::Admin,                        user::Column::EmailAddress,                        user::Column::GithubLogin,                    ])                    .to_owned(),            )            .exec_with_returning(&*tx)            .await?;             Ok(NewUserResult {                user_id: user.id,                metrics_id: user.metrics_id.to_string(),                signup_device_id: None,                inviting_user_id: None,            })        })        .await    }     /// Returns a user by ID. There are no access checks here, so this should only be used internally.    pub async fn get_user_by_id(&self, id: UserId) -> Result<Option<user::Model>> {        self.transaction(|tx| async move { Ok(user::Entity::find_by_id(id).one(&*tx).await?) })            .await    }     /// Returns all users by ID. There are no access checks here, so this should only be used internally.    pub async fn get_users_by_ids(&self, ids: Vec<UserId>) -> Result<Vec<user::Model>> {        if ids.len() >= 10000_usize {            return Err(anyhow!("too many users"))?;        }        self.transaction(|tx| async {            let tx = tx;            Ok(user::Entity::find()                .filter(user::Column::Id.is_in(ids.iter().copied()))                .all(&*tx)                .await?)        })        .await    }     /// Returns a user by email address. There are no access checks here, so this should only be used internally.    pub async fn get_user_by_email(&self, email: &str) -> Result<Option<User>> {        self.transaction(|tx| async move {            Ok(user::Entity::find()                .filter(user::Column::EmailAddress.eq(email))                .one(&*tx)                .await?)        })        .await    }     /// Returns a user by GitHub user ID. There are no access checks here, so this should only be used internally.    pub async fn get_user_by_github_user_id(&self, github_user_id: i32) -> Result<Option<User>> {        self.transaction(|tx| async move {            Ok(user::Entity::find()                .filter(user::Column::GithubUserId.eq(github_user_id))                .one(&*tx)                .await?)        })        .await    }     /// Returns a user by GitHub login. There are no access checks here, so this should only be used internally.    pub async fn get_user_by_github_login(&self, github_login: &str) -> Result<Option<User>> {        self.transaction(|tx| async move {            Ok(user::Entity::find()                .filter(user::Column::GithubLogin.eq(github_login))                .one(&*tx)                .await?)        })        .await    }     pub async fn get_or_create_user_by_github_account(        &self,        github_login: &str,        github_user_id: i32,        github_email: Option<&str>,        github_name: Option<&str>,        github_user_created_at: DateTimeUtc,        initial_channel_id: Option<ChannelId>,    ) -> Result<User> {        self.transaction(|tx| async move {            self.get_or_create_user_by_github_account_tx(                github_login,                github_user_id,                github_email,                github_name,                github_user_created_at.naive_utc(),                initial_channel_id,                &tx,            )            .await        })        .await    }     #[allow(clippy::too_many_arguments)]    pub async fn get_or_create_user_by_github_account_tx(        &self,        github_login: &str,        github_user_id: i32,        github_email: Option<&str>,        github_name: Option<&str>,        github_user_created_at: NaiveDateTime,        initial_channel_id: Option<ChannelId>,        tx: &DatabaseTransaction,    ) -> Result<User> {        if let Some(existing_user) = self            .get_user_by_github_user_id_or_github_login(github_user_id, github_login, tx)            .await?        {            let mut existing_user = existing_user.into_active_model();            existing_user.github_login = ActiveValue::set(github_login.into());            existing_user.github_user_created_at = ActiveValue::set(Some(github_user_created_at));             if let Some(github_email) = github_email {                existing_user.email_address = ActiveValue::set(Some(github_email.into()));            }             if let Some(github_name) = github_name {                existing_user.name = ActiveValue::set(Some(github_name.into()));            }             Ok(existing_user.update(tx).await?)        } else {            let user = user::Entity::insert(user::ActiveModel {                email_address: ActiveValue::set(github_email.map(|email| email.into())),                name: ActiveValue::set(github_name.map(|name| name.into())),                github_login: ActiveValue::set(github_login.into()),                github_user_id: ActiveValue::set(github_user_id),                github_user_created_at: ActiveValue::set(Some(github_user_created_at)),                admin: ActiveValue::set(false),                invite_count: ActiveValue::set(0),                invite_code: ActiveValue::set(None),                metrics_id: ActiveValue::set(Uuid::new_v4()),                ..Default::default()            })            .exec_with_returning(tx)            .await?;            if let Some(channel_id) = initial_channel_id {                channel_member::Entity::insert(channel_member::ActiveModel {                    id: ActiveValue::NotSet,                    channel_id: ActiveValue::Set(channel_id),                    user_id: ActiveValue::Set(user.id),                    accepted: ActiveValue::Set(true),                    role: ActiveValue::Set(ChannelRole::Guest),                })                .exec(tx)                .await?;            }            Ok(user)        }    }     /// Tries to retrieve a user, first by their GitHub user ID, and then by their GitHub login.    ///    /// Returns `None` if a user is not found with this GitHub user ID or GitHub login.    pub async fn get_user_by_github_user_id_or_github_login(        &self,        github_user_id: i32,        github_login: &str,        tx: &DatabaseTransaction,    ) -> Result<Option<User>> {        if let Some(user_by_github_user_id) = user::Entity::find()            .filter(user::Column::GithubUserId.eq(github_user_id))            .one(tx)            .await?        {            return Ok(Some(user_by_github_user_id));        }         if let Some(user_by_github_login) = user::Entity::find()            .filter(user::Column::GithubLogin.eq(github_login))            .one(tx)            .await?        {            return Ok(Some(user_by_github_login));        }         Ok(None)    }     /// get_all_users returns the next page of users. To get more call again with    /// the same limit and the page incremented by 1.    pub async fn get_all_users(&self, page: u32, limit: u32) -> Result<Vec<User>> {        self.transaction(|tx| async move {            Ok(user::Entity::find()                .order_by_asc(user::Column::GithubLogin)                .limit(limit as u64)                .offset(page as u64 * limit as u64)                .all(&*tx)                .await?)        })        .await    }     /// Returns the metrics id for the user.    pub async fn get_user_metrics_id(&self, id: UserId) -> Result<String> {        #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]        enum QueryAs {            MetricsId,        }         self.transaction(|tx| async move {            let metrics_id: Uuid = user::Entity::find_by_id(id)                .select_only()                .column(user::Column::MetricsId)                .into_values::<_, QueryAs>()                .one(&*tx)                .await?                .ok_or_else(|| anyhow!("could not find user"))?;            Ok(metrics_id.to_string())        })        .await    }     /// Sets "connected_once" on the user for analytics.    pub async fn set_user_connected_once(&self, id: UserId, connected_once: bool) -> Result<()> {        self.transaction(|tx| async move {            user::Entity::update_many()                .filter(user::Column::Id.eq(id))                .set(user::ActiveModel {                    connected_once: ActiveValue::set(connected_once),                    ..Default::default()                })                .exec(&*tx)                .await?;            Ok(())        })        .await    }     /// Sets "accepted_tos_at" on the user to the given timestamp.    pub async fn set_user_accepted_tos_at(        &self,        id: UserId,        accepted_tos_at: Option<DateTime>,    ) -> Result<()> {        self.transaction(|tx| async move {            user::Entity::update_many()                .filter(user::Column::Id.eq(id))                .set(user::ActiveModel {                    accepted_tos_at: ActiveValue::set(accepted_tos_at),                    ..Default::default()                })                .exec(&*tx)                .await?;            Ok(())        })        .await    }     /// hard delete the user.    pub async fn destroy_user(&self, id: UserId) -> Result<()> {        self.transaction(|tx| async move {            access_token::Entity::delete_many()                .filter(access_token::Column::UserId.eq(id))                .exec(&*tx)                .await?;            user::Entity::delete_by_id(id).exec(&*tx).await?;            Ok(())        })        .await    }     /// Find users where github_login ILIKE name_query.    pub async fn fuzzy_search_users(&self, name_query: &str, limit: u32) -> Result<Vec<User>> {        self.transaction(|tx| async {            let tx = tx;            let like_string = Self::fuzzy_like_string(name_query);            let query = "                SELECT users.*                FROM users                WHERE github_login ILIKE $1                ORDER BY github_login <-> $2                LIMIT $3            ";             Ok(user::Entity::find()                .from_raw_sql(Statement::from_sql_and_values(                    self.pool.get_database_backend(),                    query,                    vec![like_string.into(), name_query.into(), limit.into()],                ))                .all(&*tx)                .await?)        })        .await    }     /// fuzzy_like_string creates a string for matching in-order using fuzzy_search_users.    /// e.g. "cir" would become "%c%i%r%"    pub fn fuzzy_like_string(string: &str) -> String {        let mut result = String::with_capacity(string.len() * 2 + 1);        for c in string.chars() {            if c.is_alphanumeric() {                result.push('%');                result.push(c);            }        }        result.push('%');        result    }     /// Returns all feature flags.    pub async fn list_feature_flags(&self) -> Result<Vec<feature_flag::Model>> {        self.transaction(|tx| async move { Ok(feature_flag::Entity::find().all(&*tx).await?) })            .await    }     /// Creates a new feature flag.    pub async fn create_user_flag(&self, flag: &str, enabled_for_all: bool) -> Result<FlagId> {        self.transaction(|tx| async move {            let flag = feature_flag::Entity::insert(feature_flag::ActiveModel {                flag: ActiveValue::set(flag.to_string()),                enabled_for_all: ActiveValue::set(enabled_for_all),                ..Default::default()            })            .exec(&*tx)            .await?            .last_insert_id;             Ok(flag)        })        .await    }     /// Add the given user to the feature flag    pub async fn add_user_flag(&self, user: UserId, flag: FlagId) -> Result<()> {        self.transaction(|tx| async move {            user_feature::Entity::insert(user_feature::ActiveModel {                user_id: ActiveValue::set(user),                feature_id: ActiveValue::set(flag),            })            .exec(&*tx)            .await?;             Ok(())        })        .await    }     /// Returns the active flags for the user.    pub async fn get_user_flags(&self, user: UserId) -> Result<Vec<String>> {        self.transaction(|tx| async move {            #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]            enum QueryAs {                Flag,            }             let flags_enabled_for_all = feature_flag::Entity::find()                .filter(feature_flag::Column::EnabledForAll.eq(true))                .select_only()                .column(feature_flag::Column::Flag)                .into_values::<_, QueryAs>()                .all(&*tx)                .await?;             let flags_enabled_for_user = user::Model {                id: user,                ..Default::default()            }            .find_linked(user::UserFlags)            .select_only()            .column(feature_flag::Column::Flag)            .into_values::<_, QueryAs>()            .all(&*tx)            .await?;             let mut all_flags = HashSet::from_iter(flags_enabled_for_all);            all_flags.extend(flags_enabled_for_user);             Ok(all_flags.into_iter().collect())        })        .await    }     pub async fn get_users_missing_github_user_created_at(&self) -> Result<Vec<user::Model>> {        self.transaction(|tx| async move {            Ok(user::Entity::find()                .filter(user::Column::GithubUserCreatedAt.is_null())                .all(&*tx)                .await?)        })        .await    }}