let user_id = user.id;
let read_user = blocking(context.pool(), move |conn| User_::read(conn, user_id)).await??;
- let bio = match &data.bio {
- Some(bio) => {
- if bio.chars().count() <= 300 {
- Some(bio.to_owned())
- } else {
- return Err(APIError::err("bio_length_overflow").into());
- }
- }
- None => read_user.bio,
- };
-
let avatar = diesel_option_overwrite(&data.avatar);
let banner = diesel_option_overwrite(&data.banner);
let email = diesel_option_overwrite(&data.email);
+ let bio = diesel_option_overwrite(&data.bio);
+ let preferred_username = diesel_option_overwrite(&data.preferred_username);
+ let matrix_user_id = diesel_option_overwrite(&data.matrix_user_id);
- // The DB constraint should stop too many characters
- let preferred_username = match &data.preferred_username {
- Some(preferred_username) => {
- if !is_valid_preferred_username(preferred_username.trim()) {
- return Err(APIError::err("invalid_username").into());
- }
- Some(preferred_username.trim().to_string())
+ if let Some(Some(bio)) = &bio {
+ if bio.chars().count() > 300 {
+ return Err(APIError::err("bio_length_overflow").into());
}
- None => read_user.preferred_username,
- };
+ }
+
+ if let Some(Some(preferred_username)) = &preferred_username {
+ if !is_valid_preferred_username(preferred_username.trim()) {
+ return Err(APIError::err("invalid_username").into());
+ }
+ }
let password_encrypted = match &data.new_password {
Some(new_password) => {
let user_form = UserForm {
name: read_user.name,
email,
- matrix_user_id: data.matrix_user_id.to_owned(),
+ matrix_user_id,
avatar,
banner,
password_encrypted,
.context(location_info!())?
.to_string();
let preferred_username = person.inner.preferred_username().map(|u| u.to_string());
+
+ // TODO a limit check (like the API does) might need to be done
+ // here when we federate to other platforms. Same for preferred_username
let bio = person
.inner
.summary()
Ok(UserForm {
name,
- preferred_username,
+ preferred_username: Some(preferred_username),
password_encrypted: "".to_string(),
admin: false,
banned: false,
send_notifications_to_email: false,
matrix_user_id: None,
actor_id: Some(check_actor_domain(person, expected_domain)?),
- bio,
+ bio: Some(bio),
local: false,
private_key: None,
public_key: Some(person.ext_one.public_key.to_owned().public_key_pem),
#[table_name = "user_"]
pub struct UserForm {
pub name: String,
- pub preferred_username: Option<String>,
+ pub preferred_username: Option<Option<String>>,
pub password_encrypted: String,
pub admin: bool,
pub banned: bool,
pub lang: String,
pub show_avatars: bool,
pub send_notifications_to_email: bool,
- pub matrix_user_id: Option<String>,
+ pub matrix_user_id: Option<Option<String>>,
pub actor_id: Option<String>,
- pub bio: Option<String>,
+ pub bio: Option<Option<String>>,
pub local: bool,
pub private_key: Option<String>,
pub public_key: Option<String>,
let form = UserForm {
name: cuser.name.to_owned(),
email: Some(cuser.email.to_owned()),
- matrix_user_id: cuser.matrix_user_id.to_owned(),
+ matrix_user_id: Some(cuser.matrix_user_id.to_owned()),
avatar: Some(cuser.avatar.to_owned()),
banner: Some(cuser.banner.to_owned()),
password_encrypted: cuser.password_encrypted.to_owned(),
- preferred_username: cuser.preferred_username.to_owned(),
+ preferred_username: Some(cuser.preferred_username.to_owned()),
published: Some(cuser.published),
updated: None,
admin: cuser.admin,
show_avatars: cuser.show_avatars,
send_notifications_to_email: cuser.send_notifications_to_email,
actor_id: Some(make_apub_endpoint(EndpointType::User, &cuser.name).to_string()),
- bio: cuser.bio.to_owned(),
+ bio: Some(cuser.bio.to_owned()),
local: cuser.local,
private_key: Some(keypair.private_key),
public_key: Some(keypair.public_key),