async fn register_in_mastodon(
    domain: &str,
    reg_sess_id: &Uuid,
    data: &web::Data<WebData<'_>>,
) -> Result<(String, String), ()> {
    log::info!(
        "Mastodon domain {} registration session {} started",
        domain,
        reg_sess_id
    );

    let client = awc::Client::default();
    let website = format!("{}://{}/", data.base_proto, data.base_domain);
    match client
        .post(format!("https://{}/api/v1/apps", domain))
        .content_type("application/x-www-form-urlencoded")
        .send_body(format!(
            "client_name=FreeOrion%20Test%20Web&redirect_uris={}&scopes=read:accounts&website={}",
            pct_str::PctString::encode(website.chars(), pct_str::URIReserved).as_str(),
            pct_str::PctString::encode(website.chars(), pct_str::URIReserved).as_str()
        ))
        .await
    {
        Ok(mut resp) => match resp.json::<serde_json::Value>().await {
            Ok(serde_json::Value::Object(resp_value_obj)) => {
                let client_id_value = resp_value_obj.get("client_id");
                let client_secret_value = resp_value_obj.get("client_secret");
                if let (
                    Some(serde_json::Value::String(client_id)),
                    Some(serde_json::Value::String(client_secret)),
                ) = (client_id_value, client_secret_value)
                {
                    Ok((client_id.clone(), client_secret.clone()))
                } else {
                    log::error!(
                        "Mastodon domain {} registration session {} missing fields JSON {:?}",
                        domain,
                        reg_sess_id,
                        resp_value_obj
                    );
                    Err(())
                }
            }
            Ok(resp_value) => {
                log::error!(
                    "Mastodon domain {} registration session {} non-object JSON {:?}",
                    domain,
                    reg_sess_id,
                    resp_value
                );
                Err(())
            }
            Err(err) => {
                log::error!(
                    "Mastodon domain {} registration session {} failed JSON {:?}",
                    domain,
                    reg_sess_id,
                    err
                );
                Err(())
            }
        },
        Err(err) => {
            log::error!(
                "Mastodon domain {} registration session {} failed {:?}",
                domain,
                reg_sess_id,
                err
            );
            Err(())
        }
    }
}

            "INSERT INTO auth.mastodon_apps (domain, refresh_ts) VALUES ($1, $2)

            "INSERT INTO auth.mastodon_apps (domain, refresh_ts, reg_sess_id) VALUES ($1, $2, $3)

            RETURNING client_id, client_secret;",

            RETURNING client_id, client_secret, reg_sess_id;",

    let rows = match dbclient_rw.query_opt(&stmt, &[&domain, &ts]).await {

    let reg_sess_id = Uuid::new_v4();
    log::info!(
        "Mastodon domain {} registration session {} created",
        domain,
        reg_sess_id
    );
    let rows = match dbclient_rw
        .query_opt(&stmt, &[&domain, &ts, &reg_sess_id])
        .await
    {

    let opt_client_id = row.get::<_, Option<String>>(0);
    let opt_client_secret = row.get::<_, Option<String>>(1);
    let old_reg_sess_id = row.get::<_, uuid::Uuid>(2);

    let _opt_client_id = row.get::<_, Option<&str>>(0);
    let _opt_client_secret = row.get::<_, Option<&str>>(1);

    let (client_id, _client_secret) =
        if let (Some(client_id), Some(client_secret)) = (opt_client_id, opt_client_secret) {
            (client_id, client_secret)
        } else {
            if reg_sess_id != old_reg_sess_id {
                // Some one else registering same domain, try again later
                log::warn!(
                    "Mastodon domain {} registration session {} conflict with {}",
                    domain,
                    reg_sess_id,
                    old_reg_sess_id
                );
                return HttpResponse::Found()
                    .append_header((header::LOCATION, "index.html"))
                    .finish();
            }
            // Try to register on Mastodon domain
            match register_in_mastodon(&domain, &reg_sess_id, &data).await {
                Ok(res) => res,
                Err(_) => {
                    return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
                }
            }
        };

    // Try to register on Mastodon domain

    log::info!(
        "Mastodon domain {} registration session {} completed with client_id {}",
        domain,
        reg_sess_id,
        client_id
    );

-- Create field to store registartion session on Mastodon
DO $$
BEGIN
    IF NOT EXISTS (
        SELECT 1 FROM pg_class c
        INNER JOIN pg_namespace n ON n.oid = c.relnamespace
        INNER JOIN pg_attribute a ON a.attrelid = c.oid
        WHERE c.relname = 'mastodon_apps' AND n.nspname = 'auth' AND a.attname = 'reg_sess_id'
    ) THEN
        ALTER TABLE auth.mastodon_apps ADD COLUMN reg_sess_id UUID NOT NULL;
    END IF;
END
$$;

serde_json = "1.0"

 "serde_json",