示例#1
0
 public void OnActionExecuted(ActionExecutedContext filterContext)
 {
     if (_GTMProductService.ShoulAddEcommerceTags())
     {
         // Different handler for GA4.
         if (_GTMProductService.UseGA4())
         {
             GA4CheckoutStep(filterContext)();
         }
         else
         {
             CheckoutStep(filterContext)();
         }
     }
 }
示例#2
0
 public void OnActionExecuted(ActionExecutedContext filterContext)
 {
     CheckoutStep(filterContext)();
 }
        internal static IStep ReadStep(IParser parser, Boolean simpleOnly = false)
        {
            IStep result;

            parser.Expect <MappingStart>();
            var scalar = parser.Expect <Scalar>();

            if (String.Equals(scalar.Value, YamlConstants.Task, StringComparison.Ordinal))
            {
                var task = new TaskStep {
                    Enabled = true
                };
                scalar = parser.Expect <Scalar>();
                String[] refComponents = (scalar.Value ?? String.Empty).Split('@');
                Int32    version;
                if (refComponents.Length != 2 ||
                    String.IsNullOrEmpty(refComponents[0]) ||
                    String.IsNullOrEmpty(refComponents[1]) ||
                    !Int32.TryParse(refComponents[1], NumberStyles.None, CultureInfo.InvariantCulture, out version))
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"Task reference must be in the format <NAME>@<VERSION>. For example MyTask@2. The following task reference format is invalid: '{scalar.Value}'");
                }

                task.Reference = new TaskReference
                {
                    Name    = refComponents[0],
                    Version = refComponents[1],
                };
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.Inputs:
                        task.Inputs = ReadMappingOfStringString(parser, StringComparer.OrdinalIgnoreCase);
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Script, StringComparison.Ordinal))
            {
                var task = new TaskStep
                {
                    Enabled   = true,
                    Reference = new TaskReference
                    {
                        Name    = "CmdLine",
                        Version = "2",
                    },
                    Inputs = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase),
                };

                task.Inputs["script"] = parser.Expect <Scalar>().Value ?? String.Empty;
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.FailOnStderr:
                        task.Inputs["failOnStderr"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.WorkingDirectory:
                        task.Inputs["workingDirectory"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Bash, StringComparison.Ordinal))
            {
                var task = new TaskStep
                {
                    Enabled   = true,
                    Reference = new TaskReference
                    {
                        Name    = "Bash",
                        Version = "3",
                    },
                    Inputs = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase),
                };

                task.Inputs["targetType"] = "inline";
                task.Inputs["script"]     = parser.Expect <Scalar>().Value ?? String.Empty;
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.FailOnStderr:
                        task.Inputs["failOnStderr"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.WorkingDirectory:
                        task.Inputs["workingDirectory"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.PowerShell, StringComparison.Ordinal))
            {
                var task = new TaskStep
                {
                    Enabled   = true,
                    Reference = new TaskReference
                    {
                        Name    = "PowerShell",
                        Version = "2",
                    },
                    Inputs = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase),
                };

                task.Inputs["targetType"] = "inline";
                task.Inputs["script"]     = parser.Expect <Scalar>().Value ?? String.Empty;
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.ErrorActionPreference:
                        task.Inputs["errorActionPreference"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.FailOnStderr:
                        task.Inputs["failOnStderr"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.IgnoreLASTEXITCODE:
                        task.Inputs["ignoreLASTEXITCODE"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.WorkingDirectory:
                        task.Inputs["workingDirectory"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Checkout, StringComparison.Ordinal))
            {
                var checkoutStep = new CheckoutStep();
                scalar            = parser.Expect <Scalar>();
                checkoutStep.Name = scalar.Value ?? String.Empty;
                if (String.Equals(checkoutStep.Name, YamlConstants.Self, StringComparison.Ordinal))
                {
                    while (parser.Allow <MappingEnd>() == null)
                    {
                        scalar = parser.Expect <Scalar>();
                        switch (scalar.Value ?? String.Empty)
                        {
                        case YamlConstants.Clean:
                            checkoutStep.Clean = ReadNonEmptyString(parser);
                            break;

                        case YamlConstants.FetchDepth:
                            checkoutStep.FetchDepth = ReadNonEmptyString(parser);
                            break;

                        case YamlConstants.Lfs:
                            checkoutStep.Lfs = ReadNonEmptyString(parser);
                            break;
                        }
                    }
                }
                else if (String.Equals(checkoutStep.Name, YamlConstants.None, StringComparison.Ordinal))
                {
                    parser.Expect <MappingEnd>();
                }
                else
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected resource name '{scalar.Value}'. The '{YamlConstants.Checkout}' step currently can only be used with the resource name '{YamlConstants.Self}' or '{YamlConstants.None}'.");
                }

                result = checkoutStep;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Group, StringComparison.Ordinal))
            {
                if (simpleOnly)
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"A step '{YamlConstants.Group}' cannot be nested within a step group or steps template.");
                }

                var stepGroup = new StepGroup()
                {
                    Name = ReadNonEmptyString(parser)
                };
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    if (String.Equals(scalar.Value, YamlConstants.Steps, StringComparison.Ordinal))
                    {
                        stepGroup.Steps = ReadSteps(parser, simpleOnly: true).Cast <ISimpleStep>().ToList();
                    }
                    else
                    {
                        throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected property: '{scalar.Value}'");
                    }
                }

                result = stepGroup;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Template, StringComparison.Ordinal))
            {
                if (simpleOnly)
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"Steps '{YamlConstants.Template}' cannot be nested within a step group or steps template.");
                }

                var templateReference = new StepsTemplateReference {
                    Name = ReadNonEmptyString(parser)
                };
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.Parameters:
                        templateReference.Parameters = ReadMapping(parser);
                        break;

                    case YamlConstants.Steps:
                        templateReference.StepOverrides = ReadStepOverrides(parser);
                        break;

                    default:
                        throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected property: '{scalar.Value}'");
                    }
                }

                result = templateReference;
            }
            else
            {
                throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unknown step type: '{scalar.Value}'");
            }

            return(result);
        }
 protected virtual CheckoutStep GetPreviousStep(CheckoutStep currentStep) {
     switch (currentStep) {
         case CheckoutStep.ConfirmDetails:
             return CheckoutStep.EnterAddressDetails;
         default:
             return CheckoutStep.SelectPaymentMethod;
     }
 }
        protected virtual CheckoutStep GetNextStep(CheckoutStep currentStep, BasketDecorator basketOrder) {

            //Can't move on unless the current page is valid
            if (!Page.IsValid) {
                return currentStep;
            }

            switch (currentStep) {
                case CheckoutStep.SelectPaymentMethod:
                    return (!IsAccountPayment) ? CheckoutStep.EnterAddressDetails : CheckoutStep.EnterAccountDetails;
                case CheckoutStep.EnterAccountDetails:
                    return CheckoutStep.ShowSubmittedOrder;
                case CheckoutStep.EnterAddressDetails:
                    return CheckoutStep.ConfirmDetails;
                default:
                    if (basketOrder.OrderHeader != null && basketOrder.OrderHeader.PaymentMethod == PaymentMethodType.PurchaseOrderInvoice) {
                        return CheckoutStep.ShowCompletedOrder;
                    } else {
                        return CheckoutStep.ProceedToPayment;
                    }
            }
        }
        protected virtual void PerformStepActions(CheckoutStep oldStep, CheckoutStep newStep, BasketDecorator basketOrder) {

            //Hide all of the steps
            phStep1.Visible
                = phStep1a.Visible
                = phStep2a.Visible
                = phStep2b.Visible
                = phStep3a.Visible
                = phStep3b.Visible
                = false;

            btnPrevious.Visible = (newStep != CheckoutStep.SelectPaymentMethod);

            switch (newStep) {

                case CheckoutStep.ShowCompletedOrder:

                    if (IsAccountPayment) {
                        phStep3a.Visible = true;
                    } else {
                        phStep3b.Visible = true;
                    }

                    CloseOrder(basketOrder);
                    ShowCompletedOrder();

                    btnNext.Visible = false;
                    btnPrevious.Visible = false;

                    break;

                case CheckoutStep.ConfirmDetails:

                    if (IsAccountPayment) {
                        phStep3a.Visible = true;
                        btnNext.Text = GetText("submit order request");
                    } else {
                        phStep3b.Visible = true;
                        btnNext.Text = GetText("proceed to payment");
                    }

                    PopulateOrderDetailsFromForm(basketOrder);
                    break;

                case CheckoutStep.ProceedToPayment:

                    if (IsAccountPayment) {
                        phStep2a.Visible = true;
                    } else {
                        phStep2b.Visible = true;
                    }

                    CollectPayment(basketOrder);
                    break;

                case CheckoutStep.EnterAddressDetails:

                    if (IsAccountPayment) {
                        phStep2a.Visible = true;
                    } else {
                        phStep2b.Visible = true;
                    }

                    btnNext.Text = GetText("proceed to step 3");
                    break;

                case CheckoutStep.SelectPaymentMethod:
                    phStep1.Visible = true;
                    btnNext.Text = GetText("proceed to step 2");
                    break;

                case CheckoutStep.EnterAccountDetails:
                    phStep2a.Visible = true;
                    btnNext.Text = GetText("submit order request");
                    break;

                case CheckoutStep.ShowSubmittedOrder:
                    phStep3a.Visible = true;
                    SubmitAccountOrder(basketOrder);
                    btnNext.Visible = false;
                    btnPrevious.Visible = false;
                    break;

                case CheckoutStep.Login:
                    phStep1a.Visible = true;
                    btnNext.Visible = false;
                    btnPrevious.Visible = false;
                    ctlLogin.RedirectTo = this.Page.Request.RawUrl;
                    break;
            }
        }
 private void SetAndActionNewStep(CheckoutStep newStep, BasketDecorator basketOrder) {
     CheckoutStep oldStep = Step;
     Step = newStep;
     PerformStepActions(oldStep, Step, basketOrder);
 }