<form id="reset-game-form" action="reset-game-pwd.do" method="post">
<fieldset>
<legend>Enter data to set new game password:</legend>
<div>
<label for="password">Password:</label>
<input name="password" id="password" type="password" placeholder="Password" required autofocus />
</div>
<div>
<label for="password_copy">Password:</label>
<input name="password_copy" id="password_copy" type="password" placeholder="Copy password" required autofocus />
</div>
<input name="csrf" type="hidden" value="{{ csrf }}">
<input name="submit" type="submit" value="Reset password">
</fieldset>
</form>

    login: String,

    login: Option<String>,

    token: Uuid,

    token: Option<Uuid>,

    request: HttpRequest,

    if form.token != cached_token {

    if cached_token.is_nil() {
        if form.token.is_some() {
            log::warn!("Expected nil token for CSRF: {}", form.csrf);
            return HttpResponse::BadRequest().body("Incorrect");
        }
    } else if form.token != Some(cached_token) {

    let jar = request_to_jar(request);
    let form_login = jar
        .private(&data.cookies_key)
        .get("auth")
        .map(|x| std::borrow::Cow::Owned(x.value().to_string()))
        .or(form.login.as_ref().map(std::borrow::Cow::Borrowed))
        .map(|x| x.to_ascii_lowercase());

    let login_match = form.login.to_ascii_lowercase() == cached_login.to_ascii_lowercase();

    let login_match = form_login == Some(cached_login.to_ascii_lowercase());

        let stmt = match dbclient
            .prepare("delete from auth.reset_tokens where token = $1 and player_name = $2;")
            .await
        {
            Ok(stmt) => stmt,
            Err(e) => {
                log::error!("Pool RW statement delete error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
            }
        };
        let deleted = match dbclient.execute(&stmt, &[&form.token, &form.login]).await {
            Ok(c) => c,
            Err(e) => {
                log::error!("Pool RW execute delete error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());

        if !cached_token.is_nil() {
            let stmt = match dbclient
                .prepare("delete from auth.reset_tokens where token = $1 and player_name = $2;")
                .await
            {
                Ok(stmt) => stmt,
                Err(e) => {
                    log::error!("Pool RW statement delete error {}", e);
                    return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
                }
            };
            let deleted = match dbclient
                .execute(&stmt, &[&cached_token, &cached_login])
                .await
            {
                Ok(c) => c,
                Err(e) => {
                    log::error!("Pool RW execute delete error {}", e);
                    return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
                }
            };
            if deleted == 0 {
                log::error!("Not delete error: {}", cached_token);
                return HttpResponse::BadRequest().body("Incorrect");

        };
        if deleted == 0 {
            log::error!("Not delete error: {}", cached_token);
            return HttpResponse::BadRequest().body("Incorrect");

            .execute(&stmt, &[&form.password, &form.login])

            .execute(&stmt, &[&form.password, &cached_login])

use uuid::Uuid;

    csrf: Uuid,

        let csrf = Uuid::new_v4();

        {
            let mut cache = data.cache_reset_game_pwd.lock().await;
            cache.insert(
                csrf,
                (Uuid::nil(), user.to_string(), true),
                std::time::Duration::from_secs(data.cache_duration_sec),
            );
        }

                csrf,