public async Task SubscriptionOperationAsync()

in src/CustomerSite/Controllers/HomeController.cs [559:666]
100 lines of code
15 McCabe index (conditional complexity)

    public async Task<IActionResult> SubscriptionOperationAsync(SubscriptionResultExtension subscriptionResultExtension, Guid subscriptionId, string planId, string operation)
    {
        this.logger.Info(HttpUtility.HtmlEncode($"Home Controller / SubscriptionOperation subscriptionId:{subscriptionId} :: planId : {planId} :: operation:{operation}"));
        if (this.User.Identity.IsAuthenticated)
        {
            try
            {
                var userDetails = this.userRepository.GetPartnerDetailFromEmail(this.CurrentUserEmailAddress);

                if (subscriptionId != default)
                {
                    this.logger.Info("GetPartnerSubscription");
                    var oldValue = this.subscriptionService.GetPartnerSubscription(this.CurrentUserEmailAddress, subscriptionId, true).FirstOrDefault();
                    if (oldValue == null)
                    {
                        this.logger.LogError($"Cannot find subscription or subscription associated to the current user");
                        return this.RedirectToAction(nameof(this.Index));
                    }
                    Plans planDetail = this.planRepository.GetById(oldValue.PlanId);
                    this.logger.Info("GetUserIdFromEmailAddress");
                    var currentUserId = this.userService.GetUserIdFromEmailAddress(this.CurrentUserEmailAddress);
                    if (operation == "Activate")
                    {
                        try
                        {
                            this.logger.Info(HttpUtility.HtmlEncode($"Save Subscription Parameters:  {JsonSerializer.Serialize(subscriptionResultExtension.SubscriptionParameters)}" ));
                            if (subscriptionResultExtension.SubscriptionParameters != null && subscriptionResultExtension.SubscriptionParameters.Count() > 0)
                            {
                                var inputParms = subscriptionResultExtension.SubscriptionParameters.ToList().Where(s => s.Type.ToLower() == "input");
                                if (inputParms != null)
                                {
                                    var inputParmsList = inputParms.ToList();
                                    this.subscriptionService.AddSubscriptionParameters(inputParmsList, currentUserId);
                                }
                            }

                            if (Convert.ToBoolean(this.applicationConfigRepository.GetValueByName("IsAutomaticProvisioningSupported")))
                            {
                                this.logger.Info(HttpUtility.HtmlEncode($"UpdateStateOfSubscription PendingActivation: SubscriptionId: {subscriptionId} "));
                                if (oldValue.SubscriptionStatus.ToString() != SubscriptionStatusEnumExtension.PendingActivation.ToString())
                                {
                                    this.subscriptionService.UpdateStateOfSubscription(subscriptionId, SubscriptionStatusEnumExtension.PendingActivation.ToString(), true);
                                    if (oldValue != null)
                                    {
                                        SubscriptionAuditLogs auditLog = new SubscriptionAuditLogs()
                                        {
                                            Attribute = Convert.ToString(SubscriptionLogAttributes.Status),
                                            SubscriptionId = oldValue.SubscribeId,
                                            NewValue = SubscriptionStatusEnumExtension.PendingActivation.ToString(),
                                            OldValue = oldValue.SubscriptionStatus.ToString(),
                                            CreateBy = currentUserId,
                                            CreateDate = DateTime.Now,
                                        };
                                        this.subscriptionLogRepository.Save(auditLog);
                                    }
                                }

                                this.pendingActivationStatusHandlers.Process(subscriptionId);
                            }
                            else
                            {
                                this.pendingFulfillmentStatusHandlers.Process(subscriptionId);
                            }
                            
                            await _webNotificationService.PushExternalWebNotificationAsync(subscriptionId, subscriptionResultExtension.SubscriptionParameters);
                        }
                        catch (MarketplaceException fex)
                        {
                            this.logger.Error(fex.Message);
                        }
                    }

                    if (operation == "Deactivate")
                    {
                        this.subscriptionService.UpdateStateOfSubscription(subscriptionId, SubscriptionStatusEnumExtension.PendingUnsubscribe.ToString(), true);
                        if (oldValue != null)
                        {
                            SubscriptionAuditLogs auditLog = new SubscriptionAuditLogs()
                            {
                                Attribute = Convert.ToString(SubscriptionLogAttributes.Status),
                                SubscriptionId = oldValue.SubscribeId,
                                NewValue = SubscriptionStatusEnumExtension.PendingUnsubscribe.ToString(),
                                OldValue = oldValue.SubscriptionStatus.ToString(),
                                CreateBy = currentUserId,
                                CreateDate = DateTime.Now,
                            };
                            this.subscriptionLogRepository.Save(auditLog);
                        }

                        this.unsubscribeStatusHandlers.Process(subscriptionId);
                    }
                }

                this.notificationStatusHandlers.Process(subscriptionId);

                return this.RedirectToAction(nameof(this.ProcessMessage), new { action = operation, status = operation });
            }
            catch (Exception ex)
            {
                this.logger.LogError($"Message:{ex.Message} :: {ex.InnerException}   ");
                return this.View("Error", ex);
            }
        }
        else
        {
            return this.RedirectToAction(nameof(this.Index));
        }
    }