public async Task <ActionResult> FeaturesPOST(FeaturesBulkAction bulkAction, IList <string> featureIds, bool?force)
        {
            if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageFeatures))
            {
                return(Unauthorized());
            }

            if (featureIds == null || !featureIds.Any())
            {
                ModelState.AddModelError("featureIds", T["Please select one or more features."].ToString());
            }

            if (ModelState.IsValid)
            {
                var availableFeatures = await _featureManager.GetAvailableFeaturesAsync();

                var features           = availableFeatures.Where(feature => ExtensionIsAllowed(feature.Extension)).ToList();
                var selectedFeatures   = features.Where(x => featureIds.Contains(x.Id)).ToList();
                var allEnabledFeatures = await _featureManager.GetEnabledFeaturesAsync(); //features.Where(x => x.IsEnabled && featureIds.Contains(x.Id)).Select(x => x.Descriptor.Id).ToList();

                var idFeaturesEnabled   = allEnabledFeatures.Where(x => featureIds.Contains(x.Id)).Select(x => x.Id).ToList();
                var allDisabledFeatures = await _featureManager.GetDisabledFeaturesAsync(); //features.Where(x => !x.IsEnabled && featureIds.Contains(x.Id)).Select(x => x.Descriptor.Id).ToList();

                var idFeaturesDisabled = allDisabledFeatures.Where(x => featureIds.Contains(x.Id)).Select(x => x.Id).ToList();

                switch (bulkAction)
                {
                case FeaturesBulkAction.None:
                    break;

                case FeaturesBulkAction.Enable:
                    //_moduleService.EnableFeatures(featuresToDisable, force == true);

                    var enabledFeatures = await _featureManager.EnableFeaturesAsync(idFeaturesDisabled, force == true);

                    foreach (string featureId in enabledFeatures.ToList())
                    {
                        var featureName = availableFeatures.Single(f => f.Id.Equals(featureId, StringComparison.OrdinalIgnoreCase)).Name;
                        _notifier.Success(T["{0} was enabled", featureName]);
                    }
                    break;

                case FeaturesBulkAction.Disable:
                    //_moduleService.DisableFeatures(enabledFeatures, force == true);

                    var disabledFeatures = await _featureManager.DisableFeaturesAsync(idFeaturesEnabled, force == true);

                    foreach (string featureId in disabledFeatures.ToList())
                    {
                        var featureName = availableFeatures.Single(f => f.Id.Equals(featureId, StringComparison.OrdinalIgnoreCase)).Name;
                        _notifier.Success(T["{0} was disabled", featureName]);
                    }
                    break;

                case FeaturesBulkAction.Toggle:
                    //_moduleService.EnableFeatures(idFeaturesDisabled, force == true);
                    //_moduleService.DisableFeatures(idFeaturesEnabled, force == true);

                    var enabledFeaturesToggle = await _featureManager.EnableFeaturesAsync(idFeaturesDisabled, force == true);

                    foreach (string featureId in enabledFeaturesToggle.ToList())
                    {
                        var featureName = availableFeatures.Single(f => f.Id.Equals(featureId, StringComparison.OrdinalIgnoreCase)).Name;
                        _notifier.Success(T["{0} was enabled", featureName]);
                    }

                    var disabledFeaturesToggle = await _featureManager.DisableFeaturesAsync(idFeaturesEnabled, force == true);

                    foreach (string featureId in disabledFeaturesToggle.ToList())
                    {
                        var featureName = availableFeatures.Single(f => f.Id.Equals(featureId, StringComparison.OrdinalIgnoreCase)).Name;
                        _notifier.Success(T["{0} was disabled", featureName]);
                    }
                    break;

                case FeaturesBulkAction.Update:
                    //var featuresThatNeedUpdate = _dataMigrationManager.GetFeaturesThatNeedUpdate();
                    //var selectedFeaturesThatNeedUpdate = selectedFeatures.Where(x => featuresThatNeedUpdate.Contains(x.Id));

                    //foreach (var feature in selectedFeaturesThatNeedUpdate)
                    //{
                    //    var id = feature.Descriptor.Id;
                    //    try
                    //    {
                    //        _dataMigrationManager.Update(id);
                    //        _notifier.Success(T["The feature {0} was updated successfully", id]);
                    //    }
                    //    catch (Exception exception)
                    //    {
                    //        _notifier.Error(T["An error occurred while updating the feature {0}: {1}", id, exception.Message]);
                    //    }
                    //}
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            return(RedirectToAction("Features"));
        }