public async Task <IActionResult> Localize(string contentItemId, string targetCulture)
        {
            // Invariant culture name is empty so a null value is bound.
            targetCulture = targetCulture ?? "";

            var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest);

            if (contentItem == null)
            {
                return(NotFound());
            }

            if (!await _authorizationService.AuthorizeAsync(User, Permissions.LocalizeContent, contentItem))
            {
                return(Forbid());
            }

            var checkContentItem = await _contentManager.NewAsync(contentItem.ContentType);

            // Set the current user as the owner to check for ownership permissions on creation
            checkContentItem.Owner = User.FindFirstValue(ClaimTypes.NameIdentifier);

            if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.EditContent, checkContentItem))
            {
                return(Forbid());
            }

            var part = contentItem.As <LocalizationPart>();

            if (part == null)
            {
                return(NotFound());
            }

            var alreadyLocalizedContent = await _contentLocalizationManager.GetContentItemAsync(part.LocalizationSet, targetCulture);

            if (alreadyLocalizedContent != null)
            {
                await _notifier.WarningAsync(H["A localization already exists for '{0}'.", targetCulture]);

                return(RedirectToAction("Edit", "Admin", new { area = "OrchardCore.Contents", contentItemId = contentItemId }));
            }

            try
            {
                var newContent = await _contentLocalizationManager.LocalizeAsync(contentItem, targetCulture);

                await _notifier.InformationAsync(H["Localized version of the content created successfully."]);

                return(RedirectToAction("Edit", "Admin", new { area = "OrchardCore.Contents", contentItemId = newContent.ContentItemId }));
            }
            catch (InvalidOperationException)
            {
                await _notifier.WarningAsync(H["Could not create localized version of the content item."]);

                return(RedirectToAction("Edit", "Admin", new { area = "OrchardCore.Contents", contentItemId = contentItem.ContentItemId }));
            }
        }
        public async ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, LiquidTemplateContext ctx)
        {
            var locale = arguments.At(0).ToStringValue();

            if (arguments.At(0).IsNil())
            {
                locale = ctx.CultureInfo.Name;
            }

            if (input.Type == FluidValues.Array)
            {
                // List of content item ids

                var localizationSets = input.Enumerate().Select(x => x.ToStringValue()).ToArray();

                return(FluidValue.Create(await _contentLocalizationManager.GetItemsForSetsAsync(localizationSets, locale), ctx.Options));
            }
            else
            {
                var localizationSet = input.ToStringValue();

                return(FluidValue.Create(await _contentLocalizationManager.GetContentItemAsync(localizationSet, locale), ctx.Options));
            }
        }