O01eg/freeorion-test-web - Change W2AVMCLON3ANLDK6LSDEYLOLMC3VYX267ESPG4SYWJUQ2QLNWDEQC

Log in with Mastodon

Created by O01eg on July 31, 2024

W2AVMCLON3ANLDK6LSDEYLOLMC3VYX267ESPG4SYWJUQ2QLNWDEQC

Dependencies

In channels

main

Change contents

Replacement in src/pages/slow_game.rs at line 136 [8.625]
B:BD[7.195] → [7.195:234]
```
    let jar = request_to_jar(request);
```
[7.195]
[8.2400]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/slow_game.rs at line 423 [8.625]
B:BD[9.645] → [9.645:684]
```
    let jar = request_to_jar(request);
```
[9.645]
[9.684]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/slow_game.rs at line 491 [8.625]
B:BD[10.1293] → [10.1293:1332]
```
    let jar = request_to_jar(request);
```
[10.1293]
[10.1332]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/slow_game.rs at line 559 [8.625]
B:BD[11.657] → [11.657:696]
```
    let jar = request_to_jar(request);
```
[11.657]
[11.696]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/slow_game.rs at line 628 [8.625]
B:BD[12.2197] → [12.2197:2236]
```
    let jar = request_to_jar(request);
```
[12.2197]
[12.2236]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/slow_game.rs at line 695 [8.625]
B:BD[13.2809] → [13.2809:2848]
```
    let jar = request_to_jar(request);
```
[13.2809]
[13.2848]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/reset_game_pwd.rs at line 35 [16.597]
B:BD[14.189] → [15.208:247]
```
    let jar = request_to_jar(request);
```
[14.189]
[15.247]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/reset_game_pwd.rs at line 140 [16.597]
B:BD[4.932] → [4.932:971]
```
    let jar = request_to_jar(request);
```
[4.932]
[4.971]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/query_reset_game_pwd.rs at line 29 [17.557]
B:BD[3.710] → [3.710:749]
```
    let jar = request_to_jar(request);
```
[3.710]
[3.749]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/my.rs at line 39 [18.979]
B:BD[18.1586] → [18.1586:1625]
```
    let jar = request_to_jar(request);
```
[18.1586]
[18.1625]
```
    let jar = request_to_jar(&request);
```

Replacement in src/pages/mod.rs at line 82 [20.50]

B:BD[19.1552] → [19.1552:1619]

pub fn request_to_jar(request: HttpRequest) -> cookie::CookieJar {

[19.1552]

[19.1619]

pub fn request_to_jar(request: &HttpRequest) -> cookie::CookieJar {

Replacement in src/pages/log_in.rs at line 40 [19.2605]
B:BD[19.3342] → [21.95:134]
```
    let jar = request_to_jar(request);
```
[19.3342]
[21.134]
```
    let jar = request_to_jar(&request);
```

Insertion in src/pages/log_in.rs at line 61 [19.2605]

[19.3679]

fn log_in_response(
    player_name: &str,
    request: &HttpRequest,
    cookies_key: &actix_web::cookie::Key,
    set_cookie_domain: bool,
    base_domain: &str,
) -> HttpResponse {
    let mut jar = request_to_jar(request);
    if !jar
        .private(cookies_key)
        .get("i_accept_cookie")
        .map_or(false, |x| x.value() == "yes")
    {
        return HttpResponse::Found()
            .append_header((header::LOCATION, "cookies-policy.html"))
            .finish();
    }
    let mut builder = cookie::Cookie::build("auth", player_name.to_lowercase())
        .path("/")
        .secure(true)
        .http_only(true)
        .same_site(cookie::SameSite::Strict)
        .max_age(cookie::time::Duration::weeks(4));
    if set_cookie_domain {
        builder = builder.domain(base_domain.to_string());
    }
    jar.private_mut(cookies_key).add(builder.finish());
    let mut response = HttpResponse::Found()
        .append_header((header::LOCATION, "my.html"))
        .finish();
    if let Some(c) = jar.get("auth") {
        if let Err(e) = response.add_cookie(c) {
            log::error!("Cann't set cookie {}", e);
        }
    }
    response
}

Deletion in src/pages/log_in.rs at line 149 [19.2605]

B:BD[19.5287] → [19.5287:5337]

B:BD[19.5337] → [21.405:668]

    }
    let mut jar = request_to_jar(request);
    if !jar
        .private(&data.cookies_key)
        .get("i_accept_cookie")
        .map_or(false, |x| x.value() == "yes")
    {
        return HttpResponse::Found()
            .append_header((header::LOCATION, "cookies-policy.html"))
            .finish();

Replacement in src/pages/log_in.rs at line 151 [19.2605]

B:BD[21.675] → [22.1975:2054]

∅:D[22.2054] → [19.5409:5736]

B:BD[19.5409] → [19.5409:5736]

    let mut builder = cookie::Cookie::build("auth", form.login.to_lowercase())
        .path("/")
        .secure(true)
        .http_only(true)
        .same_site(cookie::SameSite::Strict)
        .max_age(cookie::time::Duration::weeks(4));
    if data.set_cookie_domain {
        builder = builder.domain(data.base_domain.to_string());
    }
    jar.private_mut(&data.cookies_key).add(builder.finish());

[21.675]

[19.5736]

    log_in_response(
        &form.login,
        &request,
        &data.cookies_key,
        data.set_cookie_domain,
        &data.base_domain,
    )
}

Replacement in src/pages/log_in.rs at line 160 [19.2605]

B:BD[19.5737] → [19.5737:5782]

B:BD[19.5782] → [18.3922:3976]

∅:D[18.3976] → [19.5839:6027]

B:BD[19.5839] → [19.5839:6027]

    let mut response = HttpResponse::Found()
        .append_header((header::LOCATION, "my.html"))
        .finish();
    if let Some(c) = jar.get("auth") {
        if let Err(e) = response.add_cookie(c) {
            log::error!("Cann't set cookie {}", e);
        }
    }
    response

[19.5737]

[23.106]

fn get_mastodon_redirect_url(base_proto: &str, base_domain: &str, domain: &str) -> String {
    format!(
        "{}://{}/mastodon-redirect-{}.html",
        base_proto, base_domain, domain
    )

Replacement in src/pages/log_in.rs at line 180 [19.2605]

B:BD[24.382] → [6.0:84]

    let website_redirect = format!("{}mastodon-redirect-{}.html", website, domain);

[24.382]

    let website_redirect = get_mastodon_redirect_url(&data.base_proto, &data.base_domain, domain);

Insertion in src/pages/log_in.rs at line 237 [19.2605]

[24.2575]

            Err(())
        }
    }
}
async fn obtain_token_mastodon(
    base_proto: &str,
    base_domain: &str,
    domain: &str,
    client_id: &str,
    client_secret: &str,
    code: &str,
) -> Result<String, ()> {
    let client = awc::Client::default();
    let website_redirect = get_mastodon_redirect_url(base_proto, base_domain, domain);
    match client
        .post(format!("https://{}/oauth/token", domain))
        .content_type("application/x-www-form-urlencoded")
        .send_body(format!(
            "client_id={}&client_secret={}&redirect_uri={}&grant_type=authorization_code&code={}&scopes=read:accounts",
            pct_str::PctString::encode(client_id.chars(), pct_str::URIReserved).as_str(),
            pct_str::PctString::encode(client_secret.chars(), pct_str::URIReserved).as_str(),
            pct_str::PctString::encode(website_redirect.chars(), pct_str::URIReserved).as_str(),
            pct_str::PctString::encode(code.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 access_token_value = resp_value_obj.get("access_token");
                    if let Some(serde_json::Value::String(access_token)) = access_token_value {
                        Ok(access_token.clone())
                    } else {
                        log::error!(
                            "Mastodon domain {} login failed missing fields JSON {:?}",
                            domain,
                            resp_value_obj
                        );
                        Err(())
                    }
                }
                Ok(resp_value) => {
                    log::error!(
                        "Mastodon domain {} login failed non-object JSON {:?}",
                        domain,
                        resp_value
                    );
                    Err(())
                }
                Err(err) => {
                    log::error!(
                        "Mastodon domain {} login failed JSON {:?}",
                        domain,
                        err
                    );
                    Err(())
                }
            }
            Err(err) => {
                log::error!(
                    "Mastodon domain {} login failed {:?}",
                    domain,
                    err
                );
                Err(())
            }
        }
}
async fn check_token_mastodon(domain: &str, token: &str) -> Result<String, ()> {
    let client = awc::Client::default();
    match client
        .get(format!(
            "https://{}/api/v1/accounts/verify_credentials",
            domain
        ))
        .insert_header(("Authorization", format!("Bearer {}", token)))
        .send()
        .await
    {
        Ok(mut resp) => match resp.json::<serde_json::Value>().await {
            Ok(serde_json::Value::Object(resp_value_obj)) => {
                let username_value = resp_value_obj.get("username");
                if let Some(serde_json::Value::String(username)) = username_value {
                    Ok(username.clone())
                } else {
                    log::error!(
                        "Mastodon domain {} login failed missing fields JSON {:?}",
                        domain,
                        resp_value_obj
                    );
                    Err(())
                }
            }
            Ok(resp_value) => {
                log::error!(
                    "Mastodon domain {} login failed non-object JSON {:?}",
                    domain,
                    resp_value
                );
                Err(())
            }
            Err(err) => {
                log::error!("Mastodon domain {} login failed JSON {:?}", domain, err);
                Err(())
            }
        },
        Err(err) => {
            log::error!("Mastodon domain {} login failed {:?}", domain, err);

Insertion in src/pages/log_in.rs at line 348 [19.2605]

[24.2611]

}
async fn player_name_by_mastodon(
    dbclient: &deadpool::managed::Object<deadpool_postgres::Manager>,
    user: &str,
    domain: &str,
) -> Result<Option<String>, ()> {
    let stmt = match dbclient.prepare("select player_name from auth.contacts where protocol = 'mastodon' and is_active = true and delete_ts is null and address = $1 limit 1;").await {
        Ok(stmt) => stmt,
        Err(e) => {
            log::error!("Pool RO statement error {}", e);
            return Err(())
        }
    };
    let address = format!("{}@{}", user, domain);
    let rows = match dbclient.query_opt(&stmt, &[&address]).await {
        Ok(rows) => rows,
        Err(e) => {
            log::error!("Pool RO query error {}", e);
            return Err(());
        }
    };
    let row = match rows {
        Some(row) => row,
        None => {
            return Ok(None);
        }
    };
    Ok(Some(row.get::<_, String>(0)))

Replacement in src/pages/log_in.rs at line 413 [19.2605]

B:BD[25.736] → [25.736:1114]

    let stmt = match dbclient.prepare("select player_name from auth.contacts where protocol = 'mastodon' and is_active = true and delete_ts is null and address = $1 limit 1;").await {
        Ok(stmt) => stmt,
        Err(e) => {
            log::error!("Pool RO statement error {}", e);
            return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());

[25.736]

[25.1114]


    let player_name = match player_name_by_mastodon(&dbclient, &user, &domain).await {
        Ok(Some(player_name)) => player_name,
        Ok(None) => {
            return HttpResponse::NotFound().body("Not found");

Replacement in src/pages/log_in.rs at line 419 [19.2605]

B:BD[25.1124] → [25.1124:1349]

    };
    let address = format!("{}@{}", user, domain);
    let rows = match dbclient.query_opt(&stmt, &[&address]).await {
        Ok(rows) => rows,
        Err(e) => {
            log::error!("Pool RO query error {}", e);

[25.1124]

[25.1349]

        Err(()) => {

Deletion in src/pages/log_in.rs at line 423 [19.2605]

B:BD[25.1456] → [25.1456:1607]

    let row = match rows {
        Some(row) => row,
        None => {
            return HttpResponse::NotFound().body("Not found");
        }
    };

Deletion in src/pages/log_in.rs at line 424 [19.2605]
B:BD[25.1608] → [25.1608:1654]
```
    let player_name = row.get::<_, &str>(0);
```

Replacement in src/pages/log_in.rs at line 547 [19.2605]

B:BD[26.1] → [26.1:75]

B:BD[26.75] → [6.2220:2601]

    let website = format!("{}://{}/", data.base_proto, data.base_domain);
    let website_redirect = format!("{}mastodon-redirect-{}.html", website, domain);
    let location = format!("https://{}/oauth/authorize?client_id={}&scope=read:accounts&redirect_uri={}&response_type=code", domain, pct_str::PctString::encode(client_id.chars(), pct_str::URIReserved).as_str(), pct_str::PctString::encode(website_redirect.chars(), pct_str::URIReserved).as_str());

[26.1]

[27.1531]

    let website_redirect = get_mastodon_redirect_url(&data.base_proto, &data.base_domain, &domain);
    let location = format!("https://{}/oauth/authorize?client_id={}&scope=read:accounts&redirect_uri={}&response_type=code", 
        domain,
        pct_str::PctString::encode(client_id.chars(), pct_str::URIReserved).as_str(),
        pct_str::PctString::encode(website_redirect.chars(), pct_str::URIReserved).as_str(),);

Insertion in src/pages/log_in.rs at line 556 [19.2605]

[23.616]

[19.6027]

}
#[actix_web::get("/mastodon-redirect-{domain}.html")]
pub async fn get_log_in_mastodon_redirect(
    req: HttpRequest,
    domain: web::Path<String>,
    data: web::Data<WebData<'_>>,
    data_ro: web::Data<DataBaseRo>,
) -> HttpResponse {
    let domain = domain.into_inner();
    let domain = match domain.char_indices().nth(128) {
        None => domain,
        Some((idx, _)) => domain[..idx].to_string(),
    };
    let mut code = None;
    for params in req.query_string().split('&') {
        if let Some((k, v)) = params.split_once('=') {
            if k == "code" {
                code = Some(v);
            }
        }
    }
    let code = match code {
        Some(r) => r,
        None => {
            log::warn!(
                "Mastodon not redirected with code in {}",
                req.query_string()
            );
            return HttpResponse::BadRequest().body("Incorrect query");
        }
    };
    let dbclient = match data_ro.0.get().await {
        Ok(client) => client,
        Err(e) => {
            log::error!("{}", e);
            return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
        }
    };
    let stmt = match dbclient
        .prepare("select client_id, client_secret from auth.mastodon_apps where domain = $1;")
        .await
    {
        Ok(stmt) => stmt,
        Err(e) => {
            log::error!("{}", e);
            return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
        }
    };
    let rows = match dbclient.query_opt(&stmt, &[&domain]).await {
        Ok(rows) => rows,
        Err(e) => {
            log::error!("Pool RO query error {}", e);
            return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
        }
    };
    let row = match rows {
        Some(r) => r,
        None => {
            return HttpResponse::NotFound().body("Not found");
        }
    };
    let opt_client_id = row.get::<_, Option<&str>>(0);
    let opt_client_secret = row.get::<_, Option<&str>>(1);
    if let (Some(client_id), Some(client_secret)) = (opt_client_id, opt_client_secret) {
        match obtain_token_mastodon(
            &data.base_proto,
            &data.base_domain,
            &domain,
            client_id,
            client_secret,
            code,
        )
        .await
        {
            Ok(token) => match check_token_mastodon(&domain, &token).await {
                Ok(user) => match player_name_by_mastodon(&dbclient, &user, &domain).await {
                    Ok(Some(player_name)) => log_in_response(
                        &player_name,
                        &req,
                        &data.cookies_key,
                        data.set_cookie_domain,
                        &data.base_domain,
                    ),
                    Ok(None) => HttpResponse::NotFound().body("Not found"),
                    Err(()) => {
                        HttpResponse::ServiceUnavailable().body(actix_web::body::None::new())
                    }
                },
                Err(()) => HttpResponse::NotFound().body("Not found"),
            },
            Err(()) => HttpResponse::NotFound().body("Not found"),
        }
    } else {
        log::warn!("Missing mastodon client data for domain {}", domain);
        HttpResponse::NotFound().body("Not found")
    }

Replacement in src/pages/index.rs at line 14 [20.100]
B:BD[19.6363] → [19.6363:6402]
```
    let jar = request_to_jar(request);
```
[19.6363]
[19.6402]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/cookies_policy.rs at line 14 [29.788]
B:BD[28.207] → [28.207:246]
```
    let jar = request_to_jar(request);
```
[28.207]
[30.395]
```
    let jar = request_to_jar(&request);
```
Replacement in src/pages/cookies_policy.rs at line 37 [29.788]
B:BD[28.361] → [28.361:404]
```
    let mut jar = request_to_jar(request);
```
[28.361]
[28.404]
```
    let mut jar = request_to_jar(&request);
```

Replacement in src/main.rs at line 16 [31.17]

B:BD[20.423] → [23.617:685]

use pages::log_in::{get_log_in, post_log_in, post_log_in_mastodon};

[20.423]

[19.6784]

use pages::log_in::{get_log_in, get_log_in_mastodon_redirect, post_log_in, post_log_in_mastodon};

Insertion in src/main.rs at line 302 [31.17]

[2.787]

[32.1998]

            .service(get_log_in_mastodon_redirect)

Insertion in Cargo.toml at line 21 [31.77]
[5.19]
[33.0]
```
deadpool = "0.12"
```
Insertion in Cargo.lock at line 869 [34.8513]
[34.20503]
[14.4003]
```
 "deadpool",
```

Log in with Mastodon

Dependencies

In channels

Change contents

Replacement in src/pages/slow_game.rs at line 136 [8.625]

Replacement in src/pages/slow_game.rs at line 423 [8.625]

Replacement in src/pages/slow_game.rs at line 491 [8.625]

Replacement in src/pages/slow_game.rs at line 559 [8.625]

Replacement in src/pages/slow_game.rs at line 628 [8.625]

Replacement in src/pages/slow_game.rs at line 695 [8.625]

Replacement in src/pages/reset_game_pwd.rs at line 35 [16.597]

Replacement in src/pages/reset_game_pwd.rs at line 140 [16.597]

Replacement in src/pages/query_reset_game_pwd.rs at line 29 [17.557]

Replacement in src/pages/my.rs at line 39 [18.979]

Replacement in src/pages/mod.rs at line 82 [20.50]

Replacement in src/pages/log_in.rs at line 40 [19.2605]