squidex/backend/i18n/translator/Squidex.Translator/Processes/Helper.cs

// ==========================================================================
//  Squidex Headless CMS
// ==========================================================================
//  Copyright (c) Squidex UG (haftungsbeschraenkt)
//  All rights reserved. Licensed under the MIT license.
// ==========================================================================

using Squidex.Translator.State;

namespace Squidex.Translator.Processes;

public static class Helper
{
    private static readonly string[][] AllowedPrefixCombos =
    [
        [
            "apps",
            "teams"
        ],
        [
            "chatBot",
            "translate"
        ]
    ];

    public static string RelativeName(FileInfo file, DirectoryInfo folder)
    {
        return file.FullName[folder.FullName.Length..].Replace('\\', '/');
    }

    public static void CheckOtherLocales(TranslationService service)
    {
        var mainTranslations = service.MainTranslations;

        foreach (var (locale, texts) in service.Translations.Where(x => x.Key != service.MainLocale))
        {
            Console.WriteLine();
            Console.WriteLine("----- CHECKING <{0}> -----", locale);

            var notTranslated = mainTranslations.Keys.Except(texts.Keys).ToList();
            var notUsing = texts.Keys.Except(mainTranslations.Keys).ToList();

            if (notTranslated.Count > 0 || notUsing.Count > 0)
            {
                if (notTranslated.Count > 0)
                {
                    Console.WriteLine();
                    Console.WriteLine("Translations missing:");

                    foreach (var key in notTranslated.OrderBy(x => x))
                    {
                        Console.Write(" * ");
                        Console.WriteLine(key);
                    }
                }

                if (notUsing.Count > 0)
                {
                    Console.WriteLine();
                    Console.WriteLine("Translations not used:");

                    foreach (var key in notUsing.OrderBy(x => x))
                    {
                        Console.Write(" * ");
                        Console.WriteLine(key);
                    }
                }
            }
            else
            {
                Console.WriteLine("> No errors found");
            }
        }
    }

    public static void CleanOtherLocales(TranslationService service)
    {
        var mainTranslations = service.MainTranslations;

        foreach (var (locale, texts) in service.Translations.Where(x => x.Key != service.MainLocale))
        {
            Console.WriteLine();
            Console.WriteLine("----- CLEANING <{0}> -----", locale);

            var notUsed = texts.Keys.Except(mainTranslations.Keys).ToList();

            if (notUsed.Count > 0)
            {
                foreach (var unused in notUsed)
                {
                    texts.Remove(unused);
                }

                Console.WriteLine("Cleaned {0} translations.", notUsed.Count);
            }
            else
            {
                Console.WriteLine("> No errors found");
            }
        }
    }

    public static ISet<string> CheckUnused(TranslationService service, HashSet<string> translations)
    {
        var notUsing = new SortedSet<string>();

        foreach (var key in service.MainTranslations.Keys)
        {
            if (!translations.Contains(key) &&
                !key.StartsWith("common.", StringComparison.OrdinalIgnoreCase) &&
                !key.StartsWith("dotnet_", StringComparison.OrdinalIgnoreCase) &&
                !key.StartsWith("validation.", StringComparison.OrdinalIgnoreCase) &&
                !key.StartsWith("rules.simulation.error", StringComparison.OrdinalIgnoreCase))
            {
                notUsing.Add(key);
            }
        }

        if (notUsing.Count > 0)
        {
            Console.WriteLine("Translations not used:");

            foreach (var key in notUsing)
            {
                Console.Write(" * ");
                Console.WriteLine(key);
            }
        }

        return notUsing;
    }

    public static ISet<string> CheckForFile(TranslationService service, string relativeName, HashSet<string> translations)
    {
        if (translations.Count > 0)
        {
            var prefixes = new SortedSet<string>();

            foreach (var key in translations.ToList())
            {
                if (service.MainTranslations.ContainsKey(key))
                {
                    translations.Remove(key);
                }

                var parts = key.Split(".");

                if (parts.Length > 1 && parts[0] != "common" && parts[0] != "validation")
                {
                    prefixes.Add(parts[0]);
                }
            }

            if (HasInvalidPrefixes(prefixes) || translations.Count > 0)
            {
                Console.WriteLine("Errors in file {0}.", relativeName);

                if (HasInvalidPrefixes(prefixes))
                {
                    Console.WriteLine(" * Multiple prefixes found: {0}", string.Join(',', prefixes));
                }

                if (translations.Count > 0)
                {
                    foreach (var key in translations)
                    {
                        Console.Write(" * Missing: ");
                        Console.WriteLine(key);
                    }
                }

                Console.WriteLine();
            }
        }

        return translations;
    }

    private static bool HasInvalidPrefixes(SortedSet<string> prefixes)
    {
        if (prefixes.Count <= 1)
        {
            return false;
        }

        if (AllowedPrefixCombos.Any(x => prefixes.Count == x.Length && x.All(y => prefixes.Contains(y))))
        {
            return false;
        }

        return true;
    }
}