saveUser method

@override Future<void> saveUser(User user, { List<String>? attribNames, })

Saves the user attributes to the AWS Cognito backend. If attribNames is provided then only those attributes will be saved.

Implementation

@override
Future<void> saveUser(
  User user, {
  List<String>? attribNames,
}) async {
  try {
    var reconfigureMFA = false;

    final userAttributes = [
      AuthUserAttributeKey.givenName,
      AuthUserAttributeKey.middleName,
      AuthUserAttributeKey.familyName,
      AuthUserAttributeKey.preferredUsername,
      AuthUserAttributeKey.picture,
      AuthUserAttributeKey.email,
      AuthUserAttributeKey.phoneNumber,
      preferences,
      userProfile,
    ]
        .where((key) =>
            attribNames == null ||
            attribNames
                .firstWhere(
                  (name) => key.key == name,
                  orElse: () => '',
                )
                .isNotEmpty)
        .map(
          (key) {
            // get value for each user attribute key from User object

            switch (key) {
              case AuthUserAttributeKey.givenName:
                if (user.firstName != null) {
                  return AuthUserAttribute(
                    userAttributeKey: key,
                    value: user.firstName!,
                  );
                }

              case AuthUserAttributeKey.middleName:
                if (user.middleName != null) {
                  return AuthUserAttribute(
                    userAttributeKey: key,
                    value: user.middleName!,
                  );
                }

              case AuthUserAttributeKey.familyName:
                if (user.familyName != null) {
                  return AuthUserAttribute(
                    userAttributeKey: key,
                    value: user.familyName!,
                  );
                }

              case AuthUserAttributeKey.preferredUsername:
                if (user.preferredName != null) {
                  return AuthUserAttribute(
                    userAttributeKey: key,
                    value: user.preferredName!,
                  );
                }

              case AuthUserAttributeKey.picture:
                if (user.profilePictureUrl != null) {
                  return AuthUserAttribute(
                    userAttributeKey: key,
                    value: user.profilePictureUrl!,
                  );
                }

              case AuthUserAttributeKey.email:
                return AuthUserAttribute(
                  userAttributeKey: key,
                  value: user.emailAddress,
                );

              case AuthUserAttributeKey.phoneNumber:
                return AuthUserAttribute(
                  userAttributeKey: key,
                  value: user.mobilePhone,
                );

              case preferences:
                reconfigureMFA = true;
                return AuthUserAttribute(
                  userAttributeKey: key,
                  value: jsonEncode({
                    'enableBiometric': user.enableBiometric,
                    'enableMFA': user.enableMFA,
                    'enableTOTP': user.enableTOTP,
                    'rememberFor24h': user.rememberFor24h,
                    'defaultOrg': user.defaultOrg,
                    'defaultSpace': user.defaultSpace,
                  }),
                );

              case userProfile:
                return AuthUserAttribute(
                  userAttributeKey: key,
                  value: jsonEncode(user.userProfile),
                );
            }
          },
        )
        .nonNulls
        .toList();

    if (reconfigureMFA) {
      var smsPreference = aws_cognito.MfaPreference.disabled;
      var totpPreference = aws_cognito.MfaPreference.disabled;
      if (user.enableMFA) {
        if (user.enableTOTP) {
          totpPreference = aws_cognito.MfaPreference.enabled;
        } else if (user.mobilePhoneVerified) {
          smsPreference = aws_cognito.MfaPreference.enabled;
        }
      }

      try {
        await _cognitoPlugin.updateMfaPreference(
          sms: smsPreference,
          totp: totpPreference,
        );
        _logger.fine(
          'Successfully configured MFA for the user: '
          'sms=${smsPreference.name}, totp=${totpPreference.name}',
        );
      } on aws_cognito.AuthException catch (e) {
        throw MFAConfigurationException(
          message: 'Failed to configure MFA for user',
          innerException: e,
          innerStackTrace: StackTrace.current,
        );
      }
    }
    final result = await _amplifyAuth.updateUserAttributes(
      attributes: userAttributes,
    );
    _logger.fine('Successfully saved user attributes: $result');

    _enqueueEvent(
      UserSavedEvent(user.copy()),
    );
  } on aws_cognito.AuthException catch (e) {
    throw SaveUserException(
      message: 'Failed to save user attributes',
      innerException: e,
      innerStackTrace: StackTrace.current,
    );
  }
}