Basic user profile page

src/backend/api/article.rs

@@ -140,11 +140,11 @@ pub(in crate::backend::api) async fn get_article(
     match (query.title, query.id) {
         (Some(title), None) => Ok(Json(DbArticle::read_view_title(
             &title,
-            query.instance_domain,
+            query.domain,
             &data.db_connection,
         )?)),
         (None, Some(id)) => {
-            if query.instance_domain.is_some() {
+            if query.domain.is_some() {
                 return Err(anyhow!("Cant combine id and instance_domain").into());
             }
             Ok(Json(DbArticle::read_view(id, &data.db_connection)?))

src/backend/api/mod.rs

@@ -4,8 +4,8 @@ use crate::backend::api::article::{
 use crate::backend::api::article::{edit_article, fork_article, get_article};
 use crate::backend::api::instance::get_local_instance;
 use crate::backend::api::instance::{follow_instance, resolve_instance};
-use crate::backend::api::user::register_user;
 use crate::backend::api::user::validate;
+use crate::backend::api::user::{get_user, register_user};
 use crate::backend::api::user::{login_user, logout_user};
 use crate::backend::api::user::{my_profile, AUTH_COOKIE};
 use crate::backend::database::conflict::DbConflict;
@@ -45,6 +45,7 @@ pub fn api_routes() -> Router {
         .route("/instance/follow", post(follow_instance))
         .route("/instance/resolve", get(resolve_instance))
         .route("/search", get(search_article))
+        .route("/user", get(get_user))
         .route("/account/register", post(register_user))
         .route("/account/login", post(login_user))
         .route("/account/my_profile", get(my_profile))

src/backend/api/user.rs

@@ -1,8 +1,9 @@
 use crate::backend::database::{read_jwt_secret, IbisData};
 use crate::backend::error::MyResult;
-use crate::common::{DbLocalUser, DbPerson, LocalUserView, LoginUserData, RegisterUserData};
+use crate::common::{DbPerson, GetUserData, LocalUserView, LoginUserData, RegisterUserData};
 use activitypub_federation::config::Data;
 use anyhow::anyhow;
+use axum::extract::Query;
 use axum::{Form, Json};
 use axum_extra::extract::cookie::{Cookie, CookieJar, Expiration, SameSite};
 use axum_macros::debug_handler;
@@ -19,7 +20,7 @@ pub static AUTH_COOKIE: &str = "auth";
 
 #[derive(Debug, Serialize, Deserialize)]
 struct Claims {
-    /// local_user.id
+    /// person.username
     pub sub: String,
     /// hostname
     pub iss: String,
@@ -29,10 +30,10 @@ struct Claims {
     pub exp: u64,
 }
 
-fn generate_login_token(local_user: &DbLocalUser, data: &Data<IbisData>) -> MyResult<String> {
+fn generate_login_token(person: &DbPerson, data: &Data<IbisData>) -> MyResult<String> {
     let hostname = data.domain().to_string();
     let claims = Claims {
-        sub: local_user.id.to_string(),
+        sub: person.username.clone(),
         iss: hostname,
         iat: Utc::now().timestamp(),
         exp: get_current_timestamp() + 60 * 60 * 24 * 365,
@@ -49,7 +50,7 @@ pub async fn validate(jwt: &str, data: &Data<IbisData>) -> MyResult<LocalUserVie
     let secret = read_jwt_secret(data)?;
     let key = DecodingKey::from_secret(secret.as_bytes());
     let claims = decode::<Claims>(jwt, &key, &validation)?;
-    DbPerson::read_local_from_id(claims.claims.sub.parse()?, data)
+    DbPerson::read_local_from_name(&claims.claims.sub, data)
 }
 
 #[debug_handler]
@@ -62,7 +63,7 @@ pub(in crate::backend::api) async fn register_user(
         return Err(anyhow!("Registration is closed").into());
     }
     let user = DbPerson::create_local(form.username, form.password, false, &data)?;
-    let token = generate_login_token(&user.local_user, &data)?;
+    let token = generate_login_token(&user.person, &data)?;
     let jar = jar.add(create_cookie(token, &data));
     Ok((jar, Json(user)))
 }
@@ -78,7 +79,7 @@ pub(in crate::backend::api) async fn login_user(
     if !valid {
         return Err(anyhow!("Invalid login").into());
     }
-    let token = generate_login_token(&user.local_user, &data)?;
+    let token = generate_login_token(&user.person, &data)?;
     let jar = jar.add(create_cookie(token, &data));
     Ok((jar, Json(user)))
 }
@@ -122,3 +123,15 @@ pub(in crate::backend::api) async fn logout_user(
     let jar = jar.remove(create_cookie(String::new(), &data));
     Ok(jar)
 }
+
+#[debug_handler]
+pub(in crate::backend::api) async fn get_user(
+    params: Query<GetUserData>,
+    data: Data<IbisData>,
+) -> MyResult<Json<DbPerson>> {
+    Ok(Json(DbPerson::read_from_name(
+        &params.name,
+        &params.domain,
+        &data,
+    )?))
+}

src/backend/database/article.rs

@@ -77,7 +77,7 @@ impl DbArticle {
 
     pub fn read_view_title(
         title: &str,
-        instance_domain: Option<String>,
+        domain: Option<String>,
         conn: &Mutex<PgConnection>,
     ) -> MyResult<ArticleView> {
         let article: DbArticle = {
@@ -86,9 +86,9 @@ impl DbArticle {
                 .inner_join(instance::table)
                 .filter(article::dsl::title.eq(title))
                 .into_boxed();
-            let query = if let Some(instance_domain) = instance_domain {
+            let query = if let Some(domain) = domain {
                 query
-                    .filter(instance::dsl::domain.eq(instance_domain))
+                    .filter(instance::dsl::domain.eq(domain))
                     .filter(instance::dsl::local.eq(false))
             } else {
                 query.filter(article::dsl::local.eq(true))

src/backend/database/instance.rs

@@ -34,7 +34,7 @@ impl DbInstance {
         let mut conn = conn.lock().unwrap();
         Ok(insert_into(instance::table)
             .values(form)
-            .on_conflict(instance::dsl::ap_id)
+            .on_conflict(instance::ap_id)
             .do_update()
             .set(form)
             .get_result(conn.deref_mut())?)
@@ -51,14 +51,14 @@ impl DbInstance {
     ) -> MyResult<DbInstance> {
         let mut conn = data.db_connection.lock().unwrap();
         Ok(instance::table
-            .filter(instance::dsl::ap_id.eq(ap_id))
+            .filter(instance::ap_id.eq(ap_id))
             .get_result(conn.deref_mut())?)
     }
 
     pub fn read_local_instance(conn: &Mutex<PgConnection>) -> MyResult<Self> {
         let mut conn = conn.lock().unwrap();
         Ok(instance::table
-            .filter(instance::dsl::local.eq(true))
+            .filter(instance::local.eq(true))
             .get_result(conn.deref_mut())?)
     }
 
@@ -101,7 +101,7 @@ impl DbInstance {
         use instance_follow::dsl::{follower_id, instance_id};
         let mut conn = conn.lock().unwrap();
         Ok(instance_follow::table
-            .inner_join(person::table.on(follower_id.eq(person::dsl::id)))
+            .inner_join(person::table.on(follower_id.eq(person::id)))
             .filter(instance_id.eq(id_))
             .select(person::all_columns)
             .get_results(conn.deref_mut())?)

src/backend/database/user.rs

@@ -9,9 +9,9 @@ use activitypub_federation::http_signatures::generate_actor_keypair;
 use bcrypt::hash;
 use bcrypt::DEFAULT_COST;
 use chrono::{DateTime, Local, Utc};
-use diesel::QueryDsl;
 use diesel::{insert_into, AsChangeset, Insertable, PgConnection, RunQueryDsl};
 use diesel::{ExpressionMethods, JoinOnDsl};
+use diesel::{PgTextExpressionMethods, QueryDsl};
 use std::ops::DerefMut;
 use std::sync::{Mutex, MutexGuard};
 
@@ -103,6 +103,27 @@ impl DbPerson {
             .get_result(conn.deref_mut())?)
     }
 
+    pub fn read_from_name(
+        username: &str,
+        domain: &Option<String>,
+        data: &Data<IbisData>,
+    ) -> MyResult<DbPerson> {
+        let mut conn = data.db_connection.lock().unwrap();
+        let mut query = person::table
+            .filter(person::username.eq(username))
+            .select(person::all_columns)
+            .into_boxed();
+        query = if let Some(domain) = domain {
+            let domain_pattern = format!("http://{domain}/%");
+            query
+                .filter(person::ap_id.ilike(domain_pattern))
+                .filter(person::local.eq(false))
+        } else {
+            query.filter(person::local.eq(true))
+        };
+        Ok(query.get_result(conn.deref_mut())?)
+    }
+
     pub fn read_local_from_name(username: &str, data: &Data<IbisData>) -> MyResult<LocalUserView> {
         let mut conn = data.db_connection.lock().unwrap();
         let (person, local_user) = person::table
@@ -119,22 +140,6 @@ impl DbPerson {
         })
     }
 
-    pub fn read_local_from_id(id: i32, data: &Data<IbisData>) -> MyResult<LocalUserView> {
-        let mut conn = data.db_connection.lock().unwrap();
-        let (person, local_user) = person::table
-            .inner_join(local_user::table)
-            .filter(person::dsl::local)
-            .filter(person::dsl::id.eq(id))
-            .get_result::<(DbPerson, DbLocalUser)>(conn.deref_mut())?;
-        // TODO: handle this in single query
-        let following = Self::read_following(person.id, conn)?;
-        Ok(LocalUserView {
-            person,
-            local_user,
-            following,
-        })
-    }
-
     fn read_following(id_: i32, mut conn: MutexGuard<PgConnection>) -> MyResult<Vec<DbInstance>> {
         use instance_follow::dsl::{follower_id, instance_id};
         Ok(instance_follow::table

src/backend/federation/activities/accept.rs

@@ -26,7 +26,7 @@ impl Accept {
         object: Follow,
         data: &Data<IbisData>,
     ) -> MyResult<()> {
-        let id = generate_activity_id(local_instance.ap_id.inner())?;
+        let id = generate_activity_id(&local_instance.ap_id)?;
         let follower = object.actor.dereference(data).await?;
         let accept = Accept {
             actor: local_instance.ap_id.clone(),

src/backend/federation/activities/create_article.rs

@@ -30,7 +30,7 @@ impl CreateArticle {
     pub async fn send_to_followers(article: DbArticle, data: &Data<IbisData>) -> MyResult<()> {
         let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
         let object = article.clone().into_json(data).await?;
-        let id = generate_activity_id(local_instance.ap_id.inner())?;
+        let id = generate_activity_id(&local_instance.ap_id)?;
         let to = local_instance.follower_ids(data)?;
         let create = CreateArticle {
             actor: local_instance.ap_id.clone(),

src/backend/federation/activities/follow.rs

@@ -27,7 +27,7 @@ pub struct Follow {
 
 impl Follow {
     pub async fn send(actor: DbPerson, to: &DbInstance, data: &Data<IbisData>) -> MyResult<()> {
-        let id = generate_activity_id(actor.ap_id.inner())?;
+        let id = generate_activity_id(&actor.ap_id)?;
         let follow = Follow {
             actor: actor.ap_id.clone(),
             object: to.ap_id.clone(),

src/backend/federation/activities/reject.rs

@@ -34,7 +34,7 @@ impl RejectEdit {
         data: &Data<IbisData>,
     ) -> MyResult<()> {
         let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
-        let id = generate_activity_id(local_instance.ap_id.inner())?;
+        let id = generate_activity_id(&local_instance.ap_id)?;
         let reject = RejectEdit {
             actor: local_instance.ap_id.clone(),
             to: vec![user_instance.ap_id.into_inner()],

src/backend/federation/activities/update_local_article.rs

@@ -38,7 +38,7 @@ impl UpdateLocalArticle {
     ) -> MyResult<()> {
         debug_assert!(article.local);
         let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
-        let id = generate_activity_id(local_instance.ap_id.inner())?;
+        let id = generate_activity_id(&local_instance.ap_id)?;
         let mut to = local_instance.follower_ids(data)?;
         to.extend(extra_recipients.iter().map(|i| i.ap_id.inner().clone()));
         let update = UpdateLocalArticle {

src/backend/federation/activities/update_remote_article.rs

@@ -40,7 +40,7 @@ impl UpdateRemoteArticle {
         data: &Data<IbisData>,
     ) -> MyResult<()> {
         let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
-        let id = generate_activity_id(local_instance.ap_id.inner())?;
+        let id = generate_activity_id(&local_instance.ap_id)?;
         let update = UpdateRemoteArticle {
             actor: local_instance.ap_id.clone(),
             to: vec![article_instance.ap_id.into_inner()],

src/backend/federation/objects/instance.rs

@@ -1,14 +1,13 @@
 use crate::backend::database::instance::DbInstanceForm;
 use crate::backend::database::IbisData;
 use crate::backend::error::Error;
+use crate::backend::error::MyResult;
 use crate::backend::federation::objects::articles_collection::DbArticleCollection;
 use crate::backend::federation::send_activity;
-
+use crate::common::utils::extract_domain;
+use crate::common::DbInstance;
 use activitypub_federation::fetch::collection_id::CollectionId;
 use activitypub_federation::kinds::actor::ServiceType;
-
-use crate::backend::error::MyResult;
-use crate::common::DbInstance;
 use activitypub_federation::traits::ActivityHandler;
 use activitypub_federation::{
     config::Data,
@@ -108,10 +107,7 @@ impl Object for DbInstance {
     }
 
     async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> {
-        let mut domain = json.id.inner().host_str().unwrap().to_string();
+        let domain = extract_domain(&json.id);
-        if let Some(port) = json.id.inner().port() {
-            domain = format!("{domain}:{port}");
-        }
         let form = DbInstanceForm {
             domain,
             ap_id: json.id,

src/backend/utils.rs

@@ -1,24 +1,28 @@
 use crate::backend::error::MyResult;
 use crate::common::DbEdit;
 use crate::common::EditVersion;
+use activitypub_federation::fetch::object_id::ObjectId;
+use activitypub_federation::traits::Object;
 use anyhow::anyhow;
 use diffy::{apply, Patch};
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
+use serde::Deserialize;
 
+use crate::common::utils::extract_domain;
 use url::{ParseError, Url};
 
-pub fn generate_activity_id(domain: &Url) -> Result<Url, ParseError> {
+pub fn generate_activity_id<T>(for_url: &ObjectId<T>) -> Result<Url, ParseError>
-    let port = match domain.port() {
+where
-        Some(p) => format!(":{p}"),
+    T: Object + Send + 'static,
-        None => String::new(),
+    for<'de2> <T as Object>::Kind: Deserialize<'de2>,
-    };
+{
-    let domain = domain.host_str().unwrap();
+    let domain = extract_domain(for_url);
     let id: String = thread_rng()
         .sample_iter(&Alphanumeric)
         .take(7)
         .map(char::from)
         .collect();
-    Url::parse(&format!("http://{}{}/objects/{}", domain, port, id))
+    Url::parse(&format!("http://{}/objects/{}", domain, id))
 }
 
 /// Starting from empty string, apply edits until the specified version is reached. If no version is

src/common/mod.rs

@@ -1,3 +1,4 @@
+pub mod utils;
 pub mod validation;
 
 use chrono::{DateTime, Utc};
@@ -21,7 +22,7 @@ pub const MAIN_PAGE_NAME: &str = "Main_Page";
 #[derive(Deserialize, Serialize, Clone, Debug)]
 pub struct GetArticleData {
     pub title: Option<String>,
-    pub instance_domain: Option<String>,
+    pub domain: Option<String>,
     pub id: Option<i32>,
 }
 
@@ -245,6 +246,12 @@ pub struct InstanceView {
     pub registration_open: bool,
 }
 
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct GetUserData {
+    pub name: String,
+    pub domain: Option<String>,
+}
+
 #[test]
 fn test_edit_versions() {
     let default = EditVersion::default();

src/common/utils.rs

@@ -0,0 +1,22 @@
+#[cfg(feature = "ssr")]
+pub fn extract_domain<T>(url: &activitypub_federation::fetch::object_id::ObjectId<T>) -> String
+where
+    T: activitypub_federation::traits::Object + Send + 'static,
+    for<'de2> <T as activitypub_federation::traits::Object>::Kind: serde::Deserialize<'de2>,
+{
+    let mut port = String::new();
+    if let Some(port_) = url.inner().port() {
+        port = format!(":{port_}");
+    }
+    format!("{}{port}", url.inner().host_str().unwrap())
+}
+
+#[cfg(not(feature = "ssr"))]
+pub fn extract_domain(url: &String) -> String {
+    let url = url::Url::parse(url).unwrap();
+    let mut port = String::new();
+    if let Some(port_) = url.port() {
+        port = format!(":{port_}");
+    }
+    format!("{}{port}", url.host_str().unwrap())
+}

src/frontend/api.rs

@@ -1,9 +1,9 @@
-use crate::common::ResolveObject;
 use crate::common::{ApiConflict, ListArticlesData};
 use crate::common::{ArticleView, LoginUserData, RegisterUserData};
 use crate::common::{CreateArticleData, EditArticleData, ForkArticleData, LocalUserView};
 use crate::common::{DbArticle, GetArticleData};
 use crate::common::{DbInstance, FollowInstance, InstanceView, SearchArticleData};
+use crate::common::{DbPerson, GetUserData, ResolveObject};
 use crate::frontend::error::MyResult;
 use anyhow::anyhow;
 use reqwest::{Client, RequestBuilder, StatusCode};
@@ -84,7 +84,7 @@ impl ApiClient {
 
         self.get_article(GetArticleData {
             title: None,
-            instance_domain: None,
+            domain: None,
             id: Some(edit_form.article_id),
         })
         .await
@@ -175,6 +175,9 @@ impl ApiClient {
         self.get_query("instance/resolve", Some(resolve_object))
             .await
     }
+    pub async fn get_user(&self, data: GetUserData) -> MyResult<DbPerson> {
+        self.get_query("user", Some(data)).await
+    }
 }
 
 async fn handle_json_res<T>(#[allow(unused_mut)] mut req: RequestBuilder) -> MyResult<T>

src/frontend/app.rs

@@ -11,6 +11,7 @@ use crate::frontend::pages::instance_details::InstanceDetails;
 use crate::frontend::pages::login::Login;
 use crate::frontend::pages::register::Register;
 use crate::frontend::pages::search::Search;
+use crate::frontend::pages::user_profile::UserProfile;
 use leptos::{
     component, create_local_resource, create_rw_signal, expect_context, provide_context,
     use_context, view, IntoView, RwSignal, SignalGet, SignalGetUntracked, SignalUpdate,
@@ -97,6 +98,7 @@ pub fn App() -> impl IntoView {
                         <Route path="/article/create" view=CreateArticle/>
                         <Route path="/article/list" view=ListArticles/>
                         <Route path="/instance/:hostname" view=InstanceDetails/>
+                        <Route path="/user/:name" view=UserProfile/>
                         <Route path="/login" view=Login/>
                         <Route path="/register" view=Register/>
                         <Route path="/search" view=Search/>

src/frontend/components/nav.rs

@@ -55,20 +55,9 @@ pub fn Nav() -> impl IntoView {
                 </form>
             </li>
             <Show
-                when=move || global_state.with(|state| state.my_profile.is_none())
+                when=move || global_state.with(|state| state.my_profile.is_some())
                 fallback=move ||  {
                     view! {
-                        <p>"Logged in as: "
-                            {
-                                move || global_state.with(|state| state.my_profile.clone().unwrap().person.username)
-                            }
-                            <button on:click=move |_| logout_action.dispatch(())>
-                                Logout
-                            </button>
-                        </p>
-                    }
-                }
-            >
                         <li>
                             <A href="/login">"Login"</A>
                         </li>
@@ -77,6 +66,23 @@ pub fn Nav() -> impl IntoView {
                                 <A href="/register">"Register"</A>
                             </li>
                         </Show>
+                    }
+                }
+            >
+                {
+                    let my_profile = global_state.with(|state| state.my_profile.clone().unwrap());
+                    let profile_link = format!("/user/{}", my_profile.person.username);
+                    view ! {
+                        <p>"Logged in as "
+                            <a href=profile_link style="border: none; padding: 0; color: var(--accent) !important;">
+                                {my_profile.person.username}
+                            </a>
+                        </p>
+                        <button on:click=move |_| logout_action.dispatch(())>
+                            Logout
+                        </button>
+                    }
+                }
             </Show>
         </nav>
     }

src/frontend/mod.rs

@@ -1,5 +1,5 @@
+use crate::common::utils::extract_domain;
 use crate::common::DbArticle;
-use url::Url;
 
 pub mod api;
 pub mod app;
@@ -11,28 +11,15 @@ pub mod pages;
 #[wasm_bindgen::prelude::wasm_bindgen]
 pub fn hydrate() {}
 
-fn extract_hostname(article: &DbArticle) -> String {
-    let ap_id: Url;
-    #[cfg(not(feature = "ssr"))]
-    {
-        ap_id = article.ap_id.parse().unwrap();
-    }
-    #[cfg(feature = "ssr")]
-    {
-        ap_id = article.ap_id.inner().clone();
-    }
-    let mut port = String::new();
-    if let Some(port_) = ap_id.port() {
-        port = format!(":{port_}");
-    }
-    format!("{}{port}", ap_id.host_str().unwrap())
-}
-
 fn article_link(article: &DbArticle) -> String {
     if article.local {
         format!("/article/{}", article.title)
     } else {
-        format!("/article/{}@{}", article.title, extract_hostname(article))
+        format!(
+            "/article/{}@{}",
+            article.title,
+            extract_domain(&article.ap_id)
+        )
     }
 }
 
@@ -41,6 +28,6 @@ fn article_title(article: &DbArticle) -> String {
     if article.local {
         title
     } else {
-        format!("{}@{}", title, extract_hostname(article))
+        format!("{}@{}", title, extract_domain(&article.ap_id))
     }
 }

src/frontend/pages/mod.rs

@@ -8,6 +8,7 @@ pub(crate) mod instance_details;
 pub(crate) mod login;
 pub(crate) mod register;
 pub(crate) mod search;
+pub(crate) mod user_profile;
 
 fn article_resource(
     title: impl Fn() -> Option<String> + 'static,
@@ -22,7 +23,7 @@ fn article_resource(
         GlobalState::api_client()
             .get_article(GetArticleData {
                 title: Some(title),
-                instance_domain: domain,
+                domain,
                 id: None,
             })
             .await

src/frontend/pages/user_profile.rs

@@ -0,0 +1,45 @@
+use crate::common::{DbPerson, GetUserData};
+use crate::frontend::app::GlobalState;
+use crate::frontend::extract_domain;
+use leptos::*;
+use leptos_router::use_params_map;
+
+#[component]
+pub fn UserProfile() -> impl IntoView {
+    let params = use_params_map();
+    let name = move || params.get().get("name").cloned().unwrap();
+    let (error, set_error) = create_signal(None::<String>);
+    let user_profile = create_resource(name, move |mut name| async move {
+        set_error.set(None);
+        let mut domain = None;
+        if let Some((title_, domain_)) = name.clone().split_once('@') {
+            name = title_.to_string();
+            domain = Some(domain_.to_string());
+        }
+        let params = GetUserData { name, domain };
+        GlobalState::api_client().get_user(params).await.unwrap()
+    });
+
+    view! {
+        {move || {
+            error
+                .get()
+                .map(|err| {
+                    view! { <p style="color:red;">{err}</p> }
+                })
+        }}
+        <Suspense fallback=|| view! {  "Loading..." }> {
+            move || user_profile.get().map(|person: DbPerson| {
+                let name =
+                if person.local {
+                    person.username
+                } else {
+                    format!("{}@{}", person.username, extract_domain(&person.ap_id))
+                };
+                view! {
+                    <h1>{name}</h1>
+                }
+            })
+        }</Suspense>
+    }
+}

tests/common.rs

@@ -56,6 +56,7 @@ impl TestData {
         ] {
             j.join().unwrap();
         }
+        dbg!(&alpha_db_path);
 
         Self {
             alpha: IbisInstance::start(alpha_db_path, port_alpha, "alpha").await,

tests/test.rs

@@ -4,7 +4,7 @@ mod common;
 
 use crate::common::{TestData, TEST_ARTICLE_DEFAULT_TEXT};
 use ibis_lib::common::{
-    ArticleView, EditArticleData, ForkArticleData, GetArticleData, ListArticlesData,
+    ArticleView, EditArticleData, ForkArticleData, GetArticleData, GetUserData, ListArticlesData,
 };
 use ibis_lib::common::{CreateArticleData, SearchArticleData};
 use ibis_lib::common::{LoginUserData, RegisterUserData};
@@ -29,7 +29,7 @@ async fn test_create_read_and_edit_local_article() -> MyResult<()> {
     // now article can be read
     let get_article_data = GetArticleData {
         title: Some(create_res.article.title.clone()),
-        instance_domain: None,
+        domain: None,
         id: None,
     };
     let get_res = data.alpha.get_article(get_article_data.clone()).await?;
@@ -152,7 +152,7 @@ async fn test_synchronize_articles() -> MyResult<()> {
 
     let mut get_article_data = GetArticleData {
         title: Some(create_res.article.title),
-        instance_domain: None,
+        domain: None,
         id: None,
     };
 
@@ -161,7 +161,7 @@ async fn test_synchronize_articles() -> MyResult<()> {
     assert!(get_res.is_err());
 
     // get the article with instance id and compare
-    get_article_data.instance_domain = Some(instance.domain);
+    get_article_data.domain = Some(instance.domain);
     let get_res = data.beta.get_article(get_article_data).await?;
     assert_eq!(create_res.article.ap_id, get_res.article.ap_id);
     assert_eq!(create_form.title, get_res.article.title);
@@ -194,7 +194,7 @@ async fn test_edit_local_article() -> MyResult<()> {
     // article should be federated to alpha
     let get_article_data = GetArticleData {
         title: Some(create_res.article.title.to_string()),
-        instance_domain: Some(beta_instance.domain),
+        domain: Some(beta_instance.domain),
         id: None,
     };
     let get_res = data.alpha.get_article(get_article_data.clone()).await?;
@@ -254,7 +254,7 @@ async fn test_edit_remote_article() -> MyResult<()> {
     // article should be federated to alpha and gamma
     let get_article_data_alpha = GetArticleData {
         title: Some(create_res.article.title.to_string()),
-        instance_domain: Some(beta_id_on_alpha.domain),
+        domain: Some(beta_id_on_alpha.domain),
         id: None,
     };
     let get_res = data
@@ -267,7 +267,7 @@ async fn test_edit_remote_article() -> MyResult<()> {
 
     let get_article_data_gamma = GetArticleData {
         title: Some(create_res.article.title.to_string()),
-        instance_domain: Some(beta_id_on_gamma.domain),
+        domain: Some(beta_id_on_gamma.domain),
         id: None,
     };
     let get_res = data
@@ -397,7 +397,7 @@ async fn test_federated_edit_conflict() -> MyResult<()> {
     // alpha edits article
     let get_article_data = GetArticleData {
         title: Some(create_form.title.to_string()),
-        instance_domain: Some(beta_id_on_alpha.domain),
+        domain: Some(beta_id_on_alpha.domain),
         id: None,
     };
     let get_res = data.alpha.get_article(get_article_data).await?;
@@ -582,3 +582,30 @@ async fn test_user_registration_login() -> MyResult<()> {
 
     data.stop()
 }
+
+#[tokio::test]
+async fn test_user_profile() -> MyResult<()> {
+    let data = TestData::start().await;
+
+    // Create an article and federate it, in order to federate the user who created it
+    let create_form = CreateArticleData {
+        title: "Manu_Chao".to_string(),
+        text: TEST_ARTICLE_DEFAULT_TEXT.to_string(),
+        summary: "create article".to_string(),
+    };
+    let create_res = data.alpha.create_article(&create_form).await?;
+    data.beta
+        .resolve_article(create_res.article.ap_id.into_inner())
+        .await?;
+
+    // Now we can fetch the remote user from local api
+    let params = GetUserData {
+        name: "alpha".to_string(),
+        domain: Some("localhost:8100".to_string()),
+    };
+    let user = data.beta.get_user(params).await?;
+    assert_eq!("alpha", user.username);
+    assert!(!user.local);
+
+    data.stop()
+}