Parse.com 重新发送验证电子邮件

Question

I am using the email verification feature that Parse offers and would like my users to be able to resend the email verification if it fails to send or they cannot see it. Last I saw, Parse does not offer an intrinsic way to do this (stupid) and people have been half-hazzerdly writing code to change the email and then change it back to trigger a re-send. Has there been any updates to this or is changing the email from the original and back still the only way? Thanks

Answer 1

You should only need to update the email to its existing value. This should trigger another email verification to be sent. I haven't been able to test the code, but this should be how you do it for the various platforms.

// Swift
PFUser.currentUser().email = PFUser.currentUser().email
PFUser.currentUser().saveInBackground()

// Java
ParseUser.getCurrentUser().setEmail(ParseUser.getCurrentUser().getEmail());
ParseUser.getCurrentUser().saveInBackground();

// JavaScript
Parse.User.current().set("email", Parse.User.current().get("email"));
Parse.User.current().save();

Answer 2

You have to set the email address to a fake one save and then set it back to the original and then parse will trigger the verification process. Just setting it to what it was will not trigger the process.

iOS

           if let email = PFUser.currentUser()?.email {
                PFUser.currentUser()?.email = email+".verify"
                PFUser.currentUser()?.saveInBackgroundWithBlock({ (success, error) -> Void in
                    if success {
                        PFUser.currentUser()?.email = email
                        PFUser.currentUser()?.saveEventually()
                    }
                })
            }

Answer 3

Poking around the source code for Parse server, there doesn't seem to be any public api to manually resend verification emails. However I was able to find 2 undocumented ways to access the functionality.

The first would be to use the internal UserController on the server (for instance from a Cloud function) like this:

import { AppCache } from 'parse-server/lib/cache'

Cloud.define('resendVerificationEmail', async request => {
    const userController = AppCache.get(process.env.APP_ID).userController
    await userController.resendVerificationEmail(
        request.user.get('username')
    )

    return true
})

The other is to take advantage of an endpoint that is used for the verification webpage:

curl -X "POST" "http://localhost:5000/api/apps/press-play-development/resend_verification_email" \
     -H 'Content-Type: application/json; charset=utf-8' \
     -d $'{ "username": "7757429624" }'

Both are prone to break if you update Parse and internals get changed, but should be more reliable than changing the users email and then changing it back.

We were setting emails to an empty string, but found that there was a race condition where 2 users would hit it at the same time and 1 would fail because Parse considered it to be a duplicate of the other blank email. In other cases, the user's network connection would fail between the 2 requests and they would be stuck without an email.

Answer 4

Now, with Parse 3.4.1 that I'm testing, you can do (for Javascript):

Parse.User.requestEmailVerification(Parse.User.current().get("email"));

BUT NOTE that it will throw error if user is already verified.

Just curious also, are people still using the open-sourced Parse nowadays? Because when I searched online, I kept getting old posts from stackoverflow.

Reference: http://parseplatform.org/Parse-SDK-JS/api/3.4.1/Parse.User.html#.requestEmailVerification

Answer 5

To resend the verification email, as stated above, you have to modify then reset the user email address. To perform this operation in secure and efficient way, you can use the following cloud code function:

Parse.Cloud.define("resendVerificationEmail", async function(request, response) {
var originalEmail = request.params.email;
const User = Parse.Object.extend("User");

const query = new Parse.Query(User);
query.equalTo("email", originalEmail);
var userObject = await query.first({useMasterKey: true});

if(userObject !=null)
{
    userObject.set("email", "tmp_email_prefix_"+originalEmail);
    await userObject.save(null, {useMasterKey: true}).catch(error => {response.error(error);});

    userObject.set("email", originalEmail);
    await userObject.save(null, {useMasterKey: true}).catch(error => {response.error(error);});

    response.success("Verification email is well resent to the user email");
}

});

After that, you just need to call the cloud code function from your client code. From Android client, you can use the following code (Kotlin):

 fun resendVerificationEmail(email:String){
    val progress = ProgressDialog(this)
    progress.setMessage("Loading ...")
    progress.show()

    val params: HashMap<String, String> = HashMap<String,String>()

    params.put("email",  email)

    ParseCloud.callFunctionInBackground("resendVerificationEmail", params,
        FunctionCallback<Any> { response, exc ->
            progress.dismiss()
            if (exc == null) {
                // The function executed, but still has to check the response
                Toast.makeText(baseContext, "Verification email is well sent", Toast.LENGTH_SHORT)
                    .show()
            } else {
                // Something went wrong
                Log.d(TAG, "$TAG: ---- exeception: "+exc.message)
                Toast.makeText(
                    baseContext,
                    "Error encountered when resending verification email:"+exc.message,
                    Toast.LENGTH_LONG
                ).show()

            }
        })
}