TypeScript IReply.redirect方法代码示例

export async function postBilling(server: Server, request: Request, reply: IReply)
{
    async function view(error: string)
    {
        const artifacts = request.auth.artifacts;
        const service = new RecurringCharges(artifacts.shopDomain, artifacts.shopToken);
        const charge = await service.get(artifacts.chargeId);
        const props: BillingProps = {
            title: "Billing Settings.",
            plan: findPlan(request.auth.artifacts.planId),
            trialEndsOn: charge.trial_ends_on,
            billingOn: charge.billing_on,
            error: error,
        }

        return reply.view("account/billing.js", props);
    }

    const artifacts = request.auth.artifacts;
    const validation = joi.validate<{plan: string}>(request.payload, JoiValidation.postBilling);

    if (validation.error)
    {
        return await view(humanizeError(validation.error));
    }

    const plan = findPlan(validation.value.plan);

    if (plan.id === artifacts.planId)
    {
        return reply.redirect(Routes.GetBilling);
    }

    const service = new RecurringCharges(artifacts.shopDomain, artifacts.shopToken);

    // Get the user's current charge so we can transfer their trial days 
    const currentCharge = await service.get(artifacts.chargeId, {fields: ["trial_ends_on"]});

    // Figure out the new trial length by checking if current charge's trial_ends_on hasn't happened yet (Today < Tomorrow)
    const trialDays = Math.round((new Date(currentCharge.trial_ends_on).valueOf() - new Date().valueOf()) / 1000 / 60 / 60 / 24);

    // The new charge will replace the user's current charge on activation.
    const charge = await service.create({
        name: plan.name,
        price: plan.price,
        test: !server.app.isLive,
        trial_days: trialDays > 0 ? trialDays : 0,
        return_url: `${getRequestDomain(request)}${Routes.UpdatePlan}?plan_id=${plan.id}`.toLowerCase(),
    });
    
    //Send the user to the confirmation url
    return reply.redirect(charge.confirmation_url);
}

export async function setup(server: Server, request: Request, reply: IReply)
{
    let payload = request.payload as {shopUrl: string};
    const props: SetupProps = {
        title: "Connect your Shopify store.",
        shopUrl: payload.shopUrl,
    };
    const validation = joi.validate(payload, setupValidation);
    
    if (validation.error)
    {
        props.error = humanizeError(validation.error);
        
        return reply.view("setup/setup.js", props);
    }
    
    payload = validation.value;
    
    if (! (await isValidShopifyDomain(payload.shopUrl)))
    {
        props.error = "It looks like the URL you entered is not a valid Shopify domain.";
        
        return reply.view("setup/setup.js", props);
    }
    
    const scopes: Enums.AuthScope[] = ["write_script_tags"]
    const redirect = `${getRequestProtocol(request)}://${getDomain(true)}${ConnectRoutes.GetShopify}`.toLowerCase();
    const oauthUrl = await buildAuthorizationUrl(scopes, payload.shopUrl, ShopifyApiKey, redirect);

    return reply.redirect(oauthUrl);
}

export async function activateShopifyPlan(server: Server, request: Request, reply: IReply)
{
    const query: {shop: string, hmac: string, charge_id: number, plan_id: string} = request.query;
    const plan = findPlan(query.plan_id);
    const artifacts = request.auth.artifacts;
    const service = new RecurringCharges(artifacts.shopDomain, artifacts.shopToken);
    let charge: RecurringCharge;
    
    try
    {
        charge = await service.get(query.charge_id);
        
        if (charge.status !== "accepted")
        {
            //Charges can only be activated when they've been accepted
            throw new Error(`Charge status was ${charge.status}`);
        }
    }
    catch (e)
    {
        console.error("Recurring charge error", e);
        
        // Charge has expired or was declined. Send the user to select a new plan.
        return reply.redirect(SetupRoutes.GetPlans);
    }
    
    await service.activate(charge.id);
    
    // Update the user's planid
    let user = await Users.get(request.auth.credentials.userId) as User;
    user.planId = plan.id;
    user.chargeId = charge.id;
    
    const update = await Users.put(user);
    
    if (!update.ok)
    {
        throw new Error("Activated user plan but failed to save plan id.");
    }
    
    await setUserAuth(request, user);

    // Create the script tag on the user's store.
    await createTag(user.shopifyDomain, user.shopifyAccessToken, user.shopifyShopId);
    
    return reply.redirect("/");
}

    transporter.sendMail(message, (error, info) =>
    {
        if (error)
        {
            return reply(boom.wrap(error));
        }

        return reply.redirect(Routes.GetResetSent);
    });

export async function selectPlan(server: Server, request: Request, reply: IReply): Promise<any>
{
    // Ensure user has connected their store before they can select a plan
    if (! request.auth.artifacts.shopToken)
    {
        return reply.redirect("/setup");
    }
    
    const props: PlansProps = {
        title: "Select your plan.",
        plans: activePlans,
    };
    let payload: {planId: string} = request.payload;
    
    const validation = joi.validate(request.payload, planValidation);
    
    if (validation.error)
    {
        console.error("Selected invalid plan", validation.error);
        
        return reply.view("setup/plans.js", props);
    }
    
    payload = validation.value;

    const plan = findPlan(payload.planId);
    const artifacts = request.auth.artifacts;
    const service = new RecurringCharges(artifacts.shopDomain, artifacts.shopToken); 
    const charge = await service.create({
        name: plan.name,
        price: plan.price,
        test: !server.app.isLive,
        trial_days: plan.trialDays,
        return_url: `${getRequestProtocol(request)}://${getDomain(true)}${ConnectRoutes.GetShopifyActivate}?plan_id=${plan.id}`.toLowerCase(),
    });
    
    //Send the user to the confirmation url
    return reply.redirect(charge.confirmation_url);
}

export async function postLogin(server: Server, request: Request, reply: IReply)
{
    const validation = joi.validate<{username: string; password: string}>(request.payload, JoiValidation.login);
    const payload = validation.value;
    const props: LoginProps = {
        username: payload.username,
        title: "Sign in to your account.", 
    };

    if (validation.error)
    {
        props.error = humanizeError(validation.error);

        return reply.view("auth/login.js", props);
    }
    
    let user: User;
    let passwordMatches = false;
    
    try
    {
        user = await Users.get<User>(payload.username.toLowerCase());
        
        if (user)
        {
            //Check if password matches the one stored in the database
            passwordMatches = compareSync(payload.password, user.hashedPassword);
        }
    }
    catch (e)
    {
        let error: pouch.api.PouchError = e;
        
        if (error.status !== 404)
        {
            throw e;
        }
    }

    if (!user || !passwordMatches)
    {
        props.error = "Username or password is incorrect."        
        
        return reply.view("auth/login.js", props);
    }
    
    //Successful login
    await setUserAuth(request, user);
    
    return reply.redirect("/");
}

export async function connectShopify(server: Server, request: Request, reply: IReply): Promise<IBoom | Response>
{
    const query: {code: string, shop: string, hmac: string} = request.query;
    const accessToken = await authorize(query.code, query.shop, ShopifyApiKey, ShopifySecretKey);
    
    // Grab the user's shop name and id and their database record
    const shopData = (await new Shops(query.shop, accessToken).get({fields: ["name,id"]}));
    let user = await Users.get(request.auth.credentials.userId) as User;
    
    // Store the user's shop data
    user.shopifyDomain = query.shop;
    user.shopifyAccessToken = accessToken;
    user.shopifyShopName = shopData.name;
    user.shopifyShopId = shopData.id;
    
    const response = await Users.put(user);
    
    if (!response.ok)
    {
        console.error(`Failed to update user ${user._id}'s Shopify access token`);
        
        return reply(expectationFailed("Could not save Shopify access token."));
    }
    
    // Update the user's auth token
    await setUserAuth(request, user);

    const redirect = reply.redirect("/");

    if (!server.app.isLive)
    {
        // Don't create any webhooks unless this app is running on a real domain. Webhooks cannot point to localhost.
        return redirect;
    }

    // Create the AppUninstalled webhook immediately after the user accepts installation
    const webhooks = new Webhooks(user.shopifyDomain, user.shopifyAccessToken);

    // Ensure the webhook doesn't already exist
    if ((await webhooks.list({topic: "app/uninstalled", fields: ["id"], limit: 1})).length === 0)
    {
        await webhooks.create({
            address: `https://${Domain}/${WebhookRoutes.GetAppUninstalled}?shopId=${user.shopifyShopId}`,
            topic: "app/uninstalled"
        })
    }
    
    return redirect;
}

export async function postResetPassword(server: Server, request: Request, reply: IReply): Promise<IBoom | Response>
{
    const payload: {password: string, token: string, confirmPassword: string} = request.payload;
    const validation = joi.validate(payload, JoiValidation.resetPassword);
    const props: ResetPasswordProps = {
        title: "Reset your password.",
        token: payload.token,
    }

    if (validation.error)
    {
        props.error = humanizeError(validation.error);

        return reply.view("auth/reset_password.js", props);
    }

    if (payload.confirmPassword !== payload.password)
    {
        props.error = "Passwords do not match.";

        return reply.view("auth/reset_password.js", props);
    }

    // Ensure the user's password token is still valid
    const user = await findUserByPasswordResetToken(payload.token);

    if (!user || user.passwordResetToken !== payload.token || new Date(user.passwordResetRequestedAt as string) < new Date(new Date().getTime() - (30 * 60 * 1000) /* 30 minutes */))
    {
        props.error = "Your password reset request has expired.";

        return reply.view("auth/reset_password.js", props);
    }

    // Reset user's password
    user.passwordResetToken = undefined;
    user.passwordResetRequestedAt = undefined;
    user.hashedPassword = hashSync(payload.password, 10);

    const update = await Users.put(user);

    if (!update.ok)
    {
        console.error("Failed to save user's new password during password reset request.", update);

        return reply(boom.expectationFailed("Failed to save user's new password during password reset request.")); 
    }

    return reply.redirect(Routes.GetLogin);
}

export async function getPlans(server: Server, request: Request, reply: IReply)
{
    // Ensure user has connected their store before they can select a plan
    if (! request.auth.artifacts.shopToken)
    {
        return reply.redirect("/setup");
    }
    
    const props: PlansProps = {
        title: "Select your plan.",
        plans: activePlans,
    }
    
    return reply.view("setup/plans.js", props);
}

 handler: function(request: Request, reply: IReply) {
     reply.redirect('/blog' + request.path);
 }