Jak zmienić status użytkownika FORCE_CHANGE_PASSWORD?

104

Korzystając z AWS Cognito, chcę stworzyć fałszywych użytkowników do celów testowych.

Następnie używam konsoli AWS do tworzenia takiego użytkownika, ale ten użytkownik ma ustawiony statusFORCE_CHANGE_PASSWORD . Przy tej wartości ten użytkownik nie może zostać uwierzytelniony.

Czy istnieje sposób na zmianę tego statusu?

UPDATE To samo zachowanie podczas tworzenia użytkownika z CLI

Fiolka Dominique
źródło
1
Odpowiedź użytkownika udzielona przez @joe
donlys

Odpowiedzi:

15

Przepraszamy, masz trudności. Nie mamy jednoetapowego procesu, w którym można po prostu tworzyć użytkowników i bezpośrednio ich uwierzytelniać. W przyszłości możemy to zmienić, na przykład zezwalając administratorom na ustawianie haseł, których użytkownicy mogą bezpośrednio używać. Na razie, gdy tworzysz użytkowników za pomocą aplikacji AdminCreateUserlub rejestrując użytkowników w aplikacji, wymagane są dodatkowe kroki, zmuszające użytkowników do zmiany hasła po zalogowaniu lub wymagające weryfikacji adresu e-mail lub numeru telefonu w celu zmiany statusu użytkownika na CONFIRMED.

Ionut Trestian
źródło
4
Na razie, gdy tworzysz użytkowników za pomocą AdminCreateUser lub rejestrując użytkowników za pomocą aplikacji, wymagane są dodatkowe kroki, zmuszające użytkowników do zmiany hasła po zalogowaniu lub wymagające zweryfikowania adresu e-mail lub numeru telefonu w celu zmiany statusu użytkownika na POTWIERDZONY. Czym dokładnie są te dodatkowe wysiłki i jak mogę je wyzwolić z JS SDK.
Saurabh Tiwari
3
@joe wskazał, że jest to teraz możliwe, ponieważ zostało dodane. szukaj --permanentflagi: stackoverflow.com/a/56948249/3165552
isaias-b
152

Wiem, że minęło trochę czasu, ale pomyślałem, że może to pomóc innym osobom, które natknęły się na ten post.

Możesz użyć interfejsu AWS CLI, aby zmienić hasło użytkownika, jednak jest to proces wieloetapowy:


Krok 1: Uzyskaj token sesji dla wybranego użytkownika:

aws cognito-idp admin-initiate-auth --user-pool-id %USER POOL ID% --client-id %APP CLIENT ID% --auth-flow ADMIN_NO_SRP_AUTH --auth-parameters USERNAME=%USERS USERNAME%,PASSWORD=%USERS CURRENT PASSWORD%

Jeśli to zwróci błąd dotyczący Unable to verify secret hash for client, utwórz innego klienta aplikacji bez wpisu tajnego i użyj tego identyfikatora klienta.

Krok 2: Jeśli krok 1 zakończy się powodzeniem, odpowie wyzwaniem NEW_PASSWORD_REQUIRED, innymi parametrami wyzwania i kluczem sesji użytkownika. Następnie możesz uruchomić drugie polecenie, aby wydać odpowiedź na wyzwanie:

aws cognito-idp admin-respond-to-auth-challenge --user-pool-id %USER POOL ID% --client-id %CLIENT ID% --challenge-name NEW_PASSWORD_REQUIRED --challenge-responses NEW_PASSWORD=%DESIRED PASSWORD%,USERNAME=%USERS USERNAME% --session %SESSION KEY FROM PREVIOUS COMMAND with ""%

Jeśli pojawi się błąd dotyczący Invalid attributes given, XXX is missingprzekazania brakujących atrybutów przy użyciu formatuuserAttributes.$FIELD_NAME=$VALUE

Powyższe polecenie powinno zwrócić prawidłowy wynik uwierzytelnienia i odpowiednie tokeny.


Ważne: aby to zadziałało, pula użytkowników Cognito MUSI mieć skonfigurowanego klienta aplikacji z ADMIN_NO_SRP_AUTHfunkcjonalnością ( krok 5 w tym dokumencie ).

Neutralny pingwin
źródło
26
Niezwykle pomocne. Jeszcze dwie wskazówki: jeśli pojawi się błąd „Nie można zweryfikować tajnego skrótu klienta”, utwórz innego klienta aplikacji bez hasła i użyj go ( stackoverflow.com/questions/37438879/ ... ). Jeśli pojawi się błąd dotyczący „Podano nieprawidłowe atrybuty, brakuje XXX”, przekaż brakujące atrybuty w formacie userAttributes.$FIELD_NAME=$VALUE( github.com/aws/aws-sdk-js/issues/1290 ).
Lane Rettig
Jeśli nie możesz wyprowadzić użytkownika z FORCE_CHANGE_PASSWORD za pomocą żadnego z poleceń CLI (w tym tej odpowiedzi), spróbuj „admin-disable-user”, a następnie „admin-enable-user” lub użyj konsoli. Następnie użyj tego procesu lub możesz użyć normalnego przepływu resetowania hasła. Czasami użytkownik „wygaśnie”, jeśli nie zaloguje się do cognito w ramach wcześniej określonego limitu. (myślę, że domyślnie 7 dni)
comfytoday
Próbowałem z CLI i wewnątrz lambdy, otrzymałem ten błąd: Podano nieprawidłowe atrybuty, brak nazwy
kolodi
1
@misher, otrzymujesz to z powodu wymaganych atrybutów. możesz dołączyć je do wywołania, ale składnia jest nieco dziwna:--challenge-responses NEW_PASSWORD=password,USERNAME=username,userAttributes.picture=picture,userAttributes.name=name
edzillion
103

To zostało ostatecznie dodane do AWSCLI: https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/admin-set-user-password.html

Możesz zmienić hasło użytkownika i zaktualizować stan za pomocą:

aws cognito-idp admin-set-user-password --user-pool-id <your user pool id> --username user1 --password password --permanent

Przed użyciem tego może być konieczne zaktualizowanie interfejsu wiersza polecenia AWS za pomocą:

pip3 install awscli --upgrade

joe
źródło
15
To najnowsze i najbardziej wydajne rozwiązanie!
kończy się
9
To powinna być odpowiedź.
Pan Młody
6
Najlepsze i najłatwiejsze rozwiązanie w 2020 roku. Dzięki!
tudor
23

Po prostu dodaj ten kod po swojej onSuccess: function (result) { ... },funkcji logowania. Twój użytkownik będzie miał wtedy status POTWIERDZONY .

newPasswordRequired: function(userAttributes, requiredAttributes) {
    // User was signed up by an admin and must provide new
    // password and required attributes, if any, to complete
    // authentication.

    // the api doesn't accept this field back
    delete userAttributes.email_verified;

    // unsure about this field, but I don't send this back
    delete userAttributes.phone_number_verified;

    // Get these details and call
    cognitoUser.completeNewPasswordChallenge(newPassword, userAttributes, this);
}
Pieczone Inhalf
źródło
1
To działa dla mnie. Możesz nawet podać aktualne hasło, jeśli nie chcesz go zmieniać.
mvandillen
Rekursja FTW! dzięki! (rekurencja jest jednym z thiswyzwań związanych z nowym hasłem)
Paul S,
22

Możesz zmienić ten status użytkownika FORCE_CHANGE_PASSWORD, dzwoniąc respondToAuthChallenge()do użytkownika w ten sposób:

var params = {
  ChallengeName: 'NEW_PASSWORD_REQUIRED', 
  ClientId: 'your_own3j6...0obh',
  ChallengeResponses: {
    USERNAME: 'user3',
    NEW_PASSWORD: 'changed12345'
  },
  Session: 'xxxxxxxxxxZDMcRu-5u...sCvrmZb6tHY'
};

cognitoidentityserviceprovider.respondToAuthChallenge(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Następnie zobaczysz w konsoli, że user3status to CONFIRMED.

Ariel Araza
źródło
1
Nie rozumiem, jak się tu dostałeś. Jak zadzwoniłeś, aby rozpocząć sesję, którą XXX miałeś? Kiedy dzwonię do adminInitiateAuth, pojawia się błąd z informacją o wyjątku UserNotFoundException.
Ryan Shillington
3
Przepraszam, jeśli ta odpowiedź nie była kryształowo jasna. Oto więcej szczegółów: 1. Pula użytkowników ma klienta o nazwie „your_own3j63rs8j16bxxxsto25db00obh”, który jest tworzony BEZ wygenerowanego tajnego klucza. Powyższy kod nie zadziała, jeśli klientowi zostanie przypisany klucz. 2) Klucz sesji to wartość zwracana przez telefoncognitoidentityserviceprovider.adminInitiateAuth({ AuthFlow: 'ADMIN_NO_SRP_AUTH', ClientId: 'your_own3j63rs8j16bxxxsto25db00obh', UserPoolId: 'us-east-1_DtNSUVT7n', AuthParameters: { USERNAME: 'user3', PASSWORD: 'original_password' } }, callback);
Ariel Araza
3) user3został utworzony w konsoli i początkowo otrzymał hasło'original_password'
Ariel Araza
DOBRZE. Rozumiem teraz, dlaczego otrzymuję wyjątek UserNotFoundException. To dlatego, że użyłem aliasu jako nazwy użytkownika do logowania, co działa dobrze w JS API, ale najwyraźniej nie działa z adminInitiateAuth. Dziękuję Ariel Araza, doceniam twoją pomoc.
Ryan Shillington,
Yay! W końcu to zadziałało. Dziękuję Ci! Dziękuję Ariel!
Ryan Shillington,
11

nie jestem pewien, czy nadal z tym walczysz, ale do tworzenia tylko grupy użytkowników testowych, użyłem awsclijako takiego:

  1. Użyj komendy rejestracji z cognito-idp, aby utworzyć użytkownika
aws cognito-idp sign-up \
   --region %aws_project_region% \
   --client-id %aws_user_pools_web_client_id% \
   --username %email_address% \
   --password %password% \
   --user-attributes Name=email,Value=%email_address%
  1. Potwierdź użytkownika za pomocą polecenia admin-confirm-sign-up
aws cognito-idp admin-confirm-sign-up \
--user-pool-id %aws_user_pools_web_client_id% \
--username %email_address%
Björn W
źródło
5

Jeśli próbujesz zmienić status jako administrator z konsoli. Następnie wykonaj poniższe czynności po utworzeniu użytkownika.

  1. W Cognito goto -> "zarządzaj pulą użytkowników" ->
  2. Przejdź do „Ustawienia klienta aplikacji” w sekcji Integracja aplikacji.
  3. Sprawdź poniższe elementy i) Pula użytkowników Cognito ii) Nadanie kodu autoryzacji iii) Udzielenie niejawne iv) telefon v) e-mail vi) openid vii) aws.cognito.signin.user.admin viii) profil
  4. Wprowadź adres zwrotny swojej aplikacji. Jeśli nie masz pewności, wpisz na przykład: https://google.com i później możesz zmienić go na rzeczywisty adres zwrotny
  5. kliknij Zapisz zmiany.
  6. Po zapisaniu zmian kliknij link „Uruchom hostowany interfejs użytkownika”
  7. Wprowadź poświadczenia nowo utworzonego użytkownika
  8. Zresetuj hasło, używając nowych poświadczeń i udostępnij je użytkownikowi

krok 2

krok 3 4 5 6

krok 7

krok 8

Rahil BR
źródło
5

AKTUALIZACJA:

Pojawiły się pewne aktualizacje i klient Amplify nie jest już potrzebny. Po adminCreateUser () możesz teraz po prostu użyć

cisp.adminSetUserPassword({
  UserPoolId: pool_id,
  Username: login,
  Password: password,
  Permanent: true
}) 

[https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminSetUserPassword.html]

spowoduje to ustawienie użytkownika na „potwierdzone”.

AKTUALIZACJA:

Teraz używam tego, przetłumaczonego na wzmocnienie, wewnątrz NodeJS Lambda:

// enable node-fetch polyfill for Node.js
global.fetch = require("node-fetch").default;
global.navigator = {};

const AWS = require("aws-sdk");
const cisp = new AWS.CognitoIdentityServiceProvider();

const Amplify = require("@aws-amplify/core").default;
const Auth = require("@aws-amplify/auth").default;

...


/*
  this_user: {
    given_name: string,
    password: string,
    email: string,
    cell: string
  }
*/
const create_cognito = (this_user) => {
  let this_defaults = {
    password_temp: Math.random().toString(36).slice(-8),
    password: this_user.password,
    region: global._env === "prod" ? production_region : development_region,
    UserPoolId:
      global._env === "prod"
        ? production_user_pool
        : development_user_pool,
    ClientId:
      global._env === "prod"
        ? production_client_id
        : development_client_id,
    given_name: this_user.given_name,
    email: this_user.email,
    cell: this_user.cell,
  };

  // configure Amplify
  Amplify.configure({
    Auth: {
      region: this_defaults.region,
      userPoolId: this_defaults.UserPoolId,
      userPoolWebClientId: this_defaults.ClientId,
    },
  });
  if (!Auth.configure())
    return Promise.reject("could not configure amplify");

  return new Promise((resolve, reject) => {
    let _result = {};

    let this_account = undefined;
    let this_account_details = undefined;

    // create cognito account
    cisp
      .adminCreateUser({
        UserPoolId: this_defaults.UserPoolId,
        Username: this_defaults.given_name,
        DesiredDeliveryMediums: ["EMAIL"],
        ForceAliasCreation: false,
        MessageAction: "SUPPRESS",
        TemporaryPassword: this_defaults.password_temp,
        UserAttributes: [
          { Name: "given_name", Value: this_defaults.given_name },
          { Name: "email", Value: this_defaults.email },
          { Name: "phone_number", Value: this_defaults.cell },
          { Name: "email_verified", Value: "true" },
        ],
      })
      .promise()
      .then((user) => {
        console.warn(".. create_cognito: create..");
        _result.username = user.User.Username;
        _result.temporaryPassword = this_defaults.password_temp;
        _result.password = this_defaults.password;

        // sign into cognito account
        return Auth.signIn(_result.username, _result.temporaryPassword);
      })
      .then((user) => {
        console.warn(".. create_cognito: signin..");

        // complete challenge
        return Auth.completeNewPassword(user, _result.password, {
          email: this_defaults.email,
          phone_number: this_defaults.cell,
        });
      })
      .then((user) => {
        console.warn(".. create_cognito: confirmed..");
        this_account = user;
        // get details
        return Auth.currentAuthenticatedUser();
      })
      .then((this_details) => {
        if (!(this_details && this_details.attributes))
          throw "account creation failes";

        this_account_details = Object.assign({}, this_details.attributes);

        // signout
        return this_account.signOut();
      })
      .then(() => {
        console.warn(".. create_cognito: complete");
        resolve(this_account_details);
      })
      .catch((err) => {
        console.error(".. create_cognito: error");
        console.error(err);
        reject(err);
      });
  });
};

Ustawiam hasło tymczasowe, a następnie resetuję je do hasła żądanego przez użytkownika.

STARY POST:

Możesz rozwiązać ten problem za pomocą zestawu SDK amazon-cognito-identity-js, uwierzytelniając się tymczasowym hasłem po utworzeniu konta cognitoidentityserviceprovider.adminCreateUser()i uruchamiając cognitoUser.completeNewPasswordChallenge()wcognitoUser.authenticateUser( ,{newPasswordRequired}) ramach funkcji, która tworzy użytkownika.

Używam poniższego kodu wewnątrz lambdy AWS, aby utworzyć włączone konta użytkowników Cognito. Jestem pewien, że można to zoptymalizować, bądź do mnie cierpliwa. To jest mój pierwszy post, a ja wciąż jestem całkiem nowy w JavaScript.

var AWS = require("aws-sdk");
var AWSCognito = require("amazon-cognito-identity-js");

var params = {
    UserPoolId: your_poolId,
    Username: your_username,
    DesiredDeliveryMediums: ["EMAIL"],
    ForceAliasCreation: false,
    MessageAction: "SUPPRESS",
    TemporaryPassword: your_temporaryPassword,
    UserAttributes: [
        { Name: "given_name", Value: your_given_name },
        { Name: "email", Value: your_email },
        { Name: "phone_number", Value: your_phone_number },
        { Name: "email_verified", Value: "true" }
    ]
};

var cognitoidentityserviceprovider = new AWS.CognitoIdentityServiceProvider();
let promise = new Promise((resolve, reject) => {
    cognitoidentityserviceprovider.adminCreateUser(params, function(err, data) {
        if (err) {
            reject(err);
        } else {
            resolve(data);
        }
    });
});

promise
    .then(data => {
        // login as new user and completeNewPasswordChallenge
        var anotherPromise = new Promise((resolve, reject) => {
            var authenticationDetails = new AWSCognito.AuthenticationDetails({
                Username: your_username,
                Password: your_temporaryPassword
            });
            var poolData = {
                UserPoolId: your_poolId,
                ClientId: your_clientId
            };
            var userPool = new AWSCognito.CognitoUserPool(poolData);
            var userData = {
                Username: your_username,
                Pool: userPool
            };

            var cognitoUser = new AWSCognito.CognitoUser(userData);
            let finalPromise = new Promise((resolve, reject) => {
                cognitoUser.authenticateUser(authenticationDetails, {
                    onSuccess: function(authResult) {
                        cognitoUser.getSession(function(err) {
                            if (err) {
                            } else {
                                cognitoUser.getUserAttributes(function(
                                    err,
                                    attResult
                                ) {
                                    if (err) {
                                    } else {
                                        resolve(authResult);
                                    }
                                });
                            }
                        });
                    },
                    onFailure: function(err) {
                        reject(err);
                    },
                    newPasswordRequired(userAttributes, []) {
                        delete userAttributes.email_verified;
                        cognitoUser.completeNewPasswordChallenge(
                            your_newPoassword,
                            userAttributes,
                            this
                        );
                    }
                });
            });

            finalPromise
                .then(finalResult => {
                    // signout
                    cognitoUser.signOut();
                    // further action, e.g. email to new user
                    resolve(finalResult);
                })
                .catch(err => {
                    reject(err);
                });
        });
        return anotherPromise;
    })
    .then(() => {
        resolve(finalResult);
    })
    .catch(err => {
        reject({ statusCode: 406, error: err });
    });
qqan.ny
źródło
@Tom - czy to działa dla Ciebie? coś, co mogę wyjaśnić?
qqan.ny
Teraz dużo lepiej.
Tom Aranda,
@ qqan.ny używać obietnic i wywołań zwrotnych w tym samym czasie? Czemu?
Iurii Golskyi
@Iurii Golskyi - wtedy nie wiedziałem lepiej, właśnie zacząłem uczyć się zarówno AWS, jak i JS od podstaw.
qqan.ny
4

W przypadku Java SDK, zakładając, że klient Cognito jest skonfigurowany, a użytkownik jest w stanie FORCE_CHANGE_PASSWORD, można wykonać następujące czynności, aby uzyskać POTWIERDZENIE użytkownika ... a następnie normalnie uwierzytelnić.

AdminCreateUserResult createUserResult = COGNITO_CLIENT.adminCreateUser(createUserRequest());

AdminInitiateAuthResult authResult = COGNITO_CLIENT.adminInitiateAuth(authUserRequest());


Map<String,String> challengeResponses = new HashMap<>();
challengeResponses.put("USERNAME", USERNAME);
challengeResponses.put("NEW_PASSWORD", PASSWORD);
RespondToAuthChallengeRequest respondToAuthChallengeRequest = new RespondToAuthChallengeRequest()
      .withChallengeName("NEW_PASSWORD_REQUIRED")
      .withClientId(CLIENT_ID)
      .withChallengeResponses(challengeResponses)
      .withSession(authResult.getSession());

COGNITO_CLIENT.respondToAuthChallenge(respondToAuthChallengeRequest);

Mam nadzieję, że pomoże to w tych testach integracji (przepraszam za formatowanie)

HKalsi
źródło
4

Zasadniczo jest to ta sama odpowiedź, ale w przypadku zestawu SDK .Net C #:

Poniższe czynności spowodują utworzenie pełnego administratora z żądaną nazwą użytkownika i hasłem. Posiadanie następującego modelu użytkownika:

public class User
{
    public string Username { get; set; }
    public string Password { get; set; }
}

Możesz utworzyć użytkownika i przygotować go do użycia za pomocą:

   public void AddUser(User user)
    {
        var tempPassword = "ANY";
        var request = new AdminCreateUserRequest()
        {
            Username = user.Username,
            UserPoolId = "MyuserPoolId",
            TemporaryPassword = tempPassword
        };
        var result = _cognitoClient.AdminCreateUserAsync(request).Result;
        var authResponse = _cognitoClient.AdminInitiateAuthAsync(new AdminInitiateAuthRequest()
        {
            UserPoolId = "MyuserPoolId",
            ClientId = "MyClientId",
            AuthFlow = AuthFlowType.ADMIN_NO_SRP_AUTH,
            AuthParameters = new Dictionary<string, string>()
            {
                {"USERNAME",user.Username },
                {"PASSWORD", tempPassword}
            }
        }).Result;
        _cognitoClient.RespondToAuthChallengeAsync(new RespondToAuthChallengeRequest()
        {
         ClientId = "MyClientId",
            ChallengeName = ChallengeNameType.NEW_PASSWORD_REQUIRED,
            ChallengeResponses = new Dictionary<string, string>()
            {
                {"USERNAME",user.Username },
                {"NEW_PASSWORD",user.Password }
            },
            Session = authResponse.Session
        });
    }
Yahya Hussein
źródło
2

Wiem, że to ta sama odpowiedź, ale pomyślałem, że może pomóc Gospołeczności programistów. w zasadzie jest to zainicjowanie żądania autoryzacji, uzyskanie sesji i odpowiedź na wyzwanieNEW_PASSWORD_REQUIRED

func sessionWithDefaultRegion(region string) *session.Session {
    sess := Session.Copy()
    if v := aws.StringValue(sess.Config.Region); len(v) == 0 {
        sess.Config.Region = aws.String(region)
    }

    return sess
}



func (c *CognitoAppClient) ChangePassword(userName, currentPassword, newPassword string)   error {

    sess := sessionWithDefaultRegion(c.Region)
    svc := cognitoidentityprovider.New(sess)

    auth, err := svc.AdminInitiateAuth(&cognitoidentityprovider.AdminInitiateAuthInput{
        UserPoolId:aws.String(c.UserPoolID),
        ClientId:aws.String(c.ClientID),
        AuthFlow:aws.String("ADMIN_NO_SRP_AUTH"),
        AuthParameters: map[string]*string{
            "USERNAME": aws.String(userName),
            "PASSWORD": aws.String(currentPassword),
        },

    })



    if err != nil {
        return err
    }

    request := &cognitoidentityprovider.AdminRespondToAuthChallengeInput{
        ChallengeName: aws.String("NEW_PASSWORD_REQUIRED"),
        ClientId:aws.String(c.ClientID),
        UserPoolId: aws.String(c.UserPoolID),
        ChallengeResponses:map[string]*string{
            "USERNAME":aws.String(userName),
            "NEW_PASSWORD": aws.String(newPassword),
        },
        Session:auth.Session,
    }


    _, err = svc.AdminRespondToAuthChallenge(request)

    return err 
}

Oto test jednostkowy:

import (
    "fmt"
    "github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
    . "github.com/smartystreets/goconvey/convey"
    "testing"
)


func TestCognitoAppClient_ChangePassword(t *testing.T) {


    Convey("Testing ChangePassword!", t, func() {
        err := client.ChangePassword("user_name_here", "current_pass", "new_pass")



        Convey("Testing ChangePassword Results!", func() {
            So(err, ShouldBeNil)

        })

    })
}
Muhammad Soliman
źródło
1

DOBRZE. W końcu mam kod, w którym administrator może utworzyć nowego użytkownika. Proces przebiega następująco:

  1. Administrator tworzy użytkownika
  2. Użytkownik otrzyma wiadomość e-mail z tymczasowym hasłem
  3. Użytkownik loguje się i jest proszony o zmianę hasła

Krok 1 to najtrudniejsza część. Oto mój kod do tworzenia użytkownika w Node JS:

let params = {
  UserPoolId: "@cognito_pool_id@",
  Username: username,
  DesiredDeliveryMediums: ["EMAIL"],
  ForceAliasCreation: false,
  UserAttributes: [
    { Name: "given_name", Value: firstName },
    { Name: "family_name", Value: lastName},
    { Name: "name", Value: firstName + " " + lastName},
    { Name: "email", Value: email},
    { Name: "custom:title", Value: title},
    { Name: "custom:company", Value: company + ""}
  ],
};
let cognitoIdentityServiceProvider = new AWS.CognitoIdentityServiceProvider();
cognitoIdentityServiceProvider.adminCreateUser(params, function(error, data) {
  if (error) {
    console.log("Error adding user to cognito: " + error, error.stack);
    reject(error);
  } else {
    // Uncomment for interesting but verbose logging...
    //console.log("Received back from cognito: " + CommonUtils.stringify(data));
    cognitoIdentityServiceProvider.adminUpdateUserAttributes({
      UserAttributes: [{
        Name: "email_verified",
        Value: "true"
      }],
      UserPoolId: "@cognito_pool_id@",
      Username: username
    }, function(err) {
      if (err) {
        console.log(err, err.stack);
      } else {
        console.log("Success!");
        resolve(data);
      }
    });
  }
});

Zasadniczo musisz wysłać drugie polecenie, aby wymusić uznanie wiadomości e-mail za zweryfikowaną. Użytkownik nadal musi przejść do swojego adresu e-mail, aby uzyskać tymczasowe hasło (które również weryfikuje e-mail). Ale bez tego drugiego połączenia, które ustawia adres e-mail na zweryfikowany, nie otrzymasz odpowiedniego połączenia zwrotnego, aby zresetować hasło.

Ryan Shillington
źródło
Nadal nie otrzymuję e-maila, jakieś sugestie?
Vinicius
Dziwne, czy poprawnie ustawiłeś adres e-mail w Cognito, z dostępem do SES itp.? Cogntio nie będzie wysyłać e-maili do ludzi, dopóki nie zweryfikujesz adresu e-mail, na który próbujesz wysłać, lub nie uzyskasz zgody na wysyłanie do kogokolwiek.
Ryan Shillington
Otrzymuję e-maile z kodem potwierdzającym, więc ustawienia są prawidłowe. Tylko e-mail z tymczasowym hasłem nigdy nie przychodzi ... Skończyło się na utworzeniu lambdy dołączonej do wyzwalacza przed rejestracją, aby wysłać e-mail.
Vinicius