Phrase Connector, AI Translator, and Integrity Check and more

cli/src/main/java/com/box/l10n/mojito/cli/command/GithubCreatePRCommand.java

@@ -0,0 +1,154 @@
+package com.box.l10n.mojito.cli.command;
+
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+import com.box.l10n.mojito.cli.console.ConsoleWriter;
+import com.box.l10n.mojito.github.GithubClient;
+import com.box.l10n.mojito.github.GithubClients;
+import com.box.l10n.mojito.github.GithubException;
+import java.io.IOException;
+import java.util.List;
+import org.fusesource.jansi.Ansi;
+import org.kohsuke.github.GHIssueState;
+import org.kohsuke.github.GHPullRequest;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Scope;
+import org.springframework.stereotype.Component;
+
+@Component
+@Scope("prototype")
+@Parameters(
+    commandNames = {"github-pr-create"},
+    commandDescription = "Create a Github PR")
+public class GithubCreatePRCommand extends Command {
+
+  @Autowired GithubClients githubClients;
+
+  @Qualifier("ansiCodeEnabledFalse")
+  @Autowired
+  ConsoleWriter consoleWriter;
+
+  @Parameter(
+      names = {"--owner", "-o"},
+      required = true,
+      arity = 1,
+      description = "The Github repository owner")
+  String owner;
+
+  @Parameter(
+      names = {"--repository", "-r"},
+      required = true,
+      arity = 1,
+      description = "The Github repository name")
+  String repository;
+
+  @Parameter(
+      names = {"--title"},
+      required = true,
+      arity = 1,
+      description = "The PR title")
+  String title;
+
+  @Parameter(
+      names = {"--head"},
+      required = true,
+      arity = 1,
+      description = "The PR head")
+  String head;
+
+  @Parameter(
+      names = {"--base"},
+      required = true,
+      arity = 1,
+      description = "The PR base")
+  String base;
+
+  @Parameter(
+      names = {"--body"},
+      required = false,
+      arity = 1,
+      description = "The PR body")
+  String body;
+
+  @Parameter(
+      names = {"--reviewers"},
+      required = false,
+      variableArity = true,
+      description = "The PR reviewers")
+  List<String> reviewers;
+
+  @Parameter(
+      names = {"--enable-auto-merge"},
+      required = false,
+      arity = 1,
+      description = "Enable auto-merge with the specified method")
+  EnableAutoMergeType enableAutoMerge = EnableAutoMergeType.NONE;
+
+  @Parameter(
+      names = {"--labels"},
+      required = false,
+      variableArity = true,
+      description = "The PR labels")
+  List<String> labels;
+
+  @Parameter(
+      names = {"--also-close-prefixed"},
+      description =
+          "Closes all PRs that start with the specified prefix. Use this to manage PRs that are part of a batch or related by a common feature.",
+      required = false)
+  String alsoClosePrefixed = null;
+
+  enum EnableAutoMergeType {
+    SQUASH,
+    MERGE,
+    NONE
+  }
+
+  @Override
+  public boolean shouldShowInCommandList() {
+    return false;
+  }
+
+  @Override
+  protected void execute() throws CommandException {
+    try {
+
+      GithubClient githubClient = githubClients.getClient(owner);
+
+      if (alsoClosePrefixed != null) {
+        closePRPrefixedWith(githubClient, alsoClosePrefixed);
+      }
+
+      GHPullRequest pr = githubClient.createPR(repository, title, head, base, body, reviewers);
+
+      consoleWriter.a("PR created: ").fg(Ansi.Color.CYAN).a(pr.getHtmlUrl().toString()).println();
+      if (!EnableAutoMergeType.NONE.equals(enableAutoMerge)) {
+        githubClient.enableAutoMerge(pr, GithubClient.AutoMergeType.SQUASH);
+      }
+
+      githubClient.addLabelsToPR(pr, labels);
+
+    } catch (GithubException e) {
+      throw new CommandException(e);
+    }
+  }
+
+  void closePRPrefixedWith(GithubClient githubClient, String alsoClosePrefixed) {
+    githubClient.listPR(repository, GHIssueState.OPEN).stream()
+        .filter(pr -> pr.getTitle().startsWith(alsoClosePrefixed))
+        .forEach(
+            pullRequest -> {
+              try {
+                consoleWriter
+                    .a("Closing: ")
+                    .fg(Ansi.Color.CYAN)
+                    .a(pullRequest.getHtmlUrl().toString())
+                    .println();
+                pullRequest.close();
+              } catch (IOException e) {
+                throw new CommandException(e);
+              }
+            });
+  }
+}

cli/src/main/java/com/box/l10n/mojito/cli/command/GithubGetInstallationTokenCommand.java

@@ -4,9 +4,6 @@
 import com.beust.jcommander.Parameters;
 import com.box.l10n.mojito.cli.console.ConsoleWriter;
 import com.box.l10n.mojito.github.GithubClients;
-import java.io.IOException;
-import java.security.NoSuchAlgorithmException;
-import java.security.spec.InvalidKeySpecException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.annotation.Scope;
@@ -50,7 +47,7 @@ protected void execute() throws CommandException {
       consoleWriter
           .a(githubClients.getClient(owner).getGithubAppInstallationToken(repository).getToken())
           .print();
-    } catch (IOException | NoSuchAlgorithmException | InvalidKeySpecException e) {
+    } catch (Exception e) {
       throw new CommandException(e);
     }
   }

cli/src/main/java/com/box/l10n/mojito/cli/command/ImportLocalizedAssetCommand.java

@@ -11,17 +11,16 @@
 import com.box.l10n.mojito.rest.client.LocaleClient;
 import com.box.l10n.mojito.rest.client.RepositoryClient;
 import com.box.l10n.mojito.rest.client.exception.AssetNotFoundException;
-import com.box.l10n.mojito.rest.client.exception.PollableTaskException;
 import com.box.l10n.mojito.rest.entity.Asset;
 import com.box.l10n.mojito.rest.entity.ImportLocalizedAssetBody;
 import com.box.l10n.mojito.rest.entity.ImportLocalizedAssetBody.StatusForEqualTarget;
 import com.box.l10n.mojito.rest.entity.Locale;
 import com.box.l10n.mojito.rest.entity.Repository;
 import java.nio.file.Path;
 import java.util.Collection;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import org.fusesource.jansi.Ansi;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -72,6 +71,22 @@ public class ImportLocalizedAssetCommand extends Command {
       description = Param.REPOSITORY_LOCALES_MAPPING_DESCRIPTION)
   String localeMappingParam;
 
+  @Parameter(
+      names = {"-lmt", "--locale-mapping-type"},
+      arity = 1,
+      required = false,
+      description =
+          "Specifies how to handle locale mappings when used with --locale-mapping. "
+              + "MAP_ONLY processes only the locales explicitly specified in the mapping. "
+              + "WITH_REPOSITORY generates a basic mapping from the repository's locales and "
+              + "supplements it with the provided mapping, potentially overriding existing entries.")
+  LocaleMappingType localeMappingTypeParam = LocaleMappingType.WITH_REPOSITORY;
+
+  enum LocaleMappingType {
+    MAP_ONLY,
+    WITH_REPOSITORY
+  }
+
   @Parameter(
       names = {Param.FILE_TYPE_LONG, Param.FILE_TYPE_SHORT},
       variableArity = true,
@@ -124,6 +139,12 @@ public class ImportLocalizedAssetCommand extends Command {
       converter = ImportLocalizedAssetBodyStatusForEqualTargetConverter.class)
   StatusForEqualTarget statusForEqualTarget = StatusForEqualTarget.APPROVED;
 
+  @Parameter(
+      names = {"--continue-on-error"},
+      arity = 0,
+      description = "Continue import on errors")
+  boolean continueOnError = false;
+
   @Autowired AssetClient assetClient;
 
   @Autowired LocaleClient localeClient;
@@ -152,6 +173,7 @@ public void execute() throws CommandException {
         .println(2);
 
     repository = commandHelper.findRepositoryByName(repositoryParam);
+
     commandDirectories = new CommandDirectories(sourceDirectoryParam, targetDirectoryParam);
     inverseLocaleMapping = localeMappingHelper.getInverseLocaleMapping(localeMappingParam);
 
@@ -163,15 +185,37 @@ public void execute() throws CommandException {
             sourcePathFilterRegex,
             directoriesIncludePatterns,
             directoriesExcludePatterns)) {
-      for (Locale locale : getLocalesForImport()) {
-        doImportFileMatch(sourceFileMatch, locale);
-      }
+
+      List<ImportLocalizedAssetBody> list =
+          getLocalesForImport().stream()
+              .map(locale -> doImportFileMatch(sourceFileMatch, locale))
+              .filter(Objects::nonNull)
+              .toList();
+
+      list.forEach(
+          importLocalizedAssetForContent -> {
+            try {
+              commandHelper.waitForPollableTask(
+                  importLocalizedAssetForContent.getPollableTask().getId());
+            } catch (CommandException e) {
+              if (continueOnError) {
+                consoleWriter
+                    .a("   Error while importing: ")
+                    .fg(Ansi.Color.RED)
+                    .a(sourceFileMatch.getPath().toString())
+                    .println();
+              } else {
+                throw e;
+              }
+            }
+          });
     }
 
     consoleWriter.fg(Ansi.Color.GREEN).newLine().a("Finished").println(2);
   }
 
-  protected void doImportFileMatch(FileMatch fileMatch, Locale locale) throws CommandException {
+  protected ImportLocalizedAssetBody doImportFileMatch(FileMatch fileMatch, Locale locale)
+      throws CommandException {
     try {
       logger.info("Importing for locale: {}", locale.getBcp47Tag());
       Path targetPath = getTargetPath(fileMatch, locale);
@@ -185,56 +229,64 @@ protected void doImportFileMatch(FileMatch fileMatch, Locale locale) throws Comm
       Asset assetByPathAndRepositoryId =
           assetClient.getAssetByPathAndRepositoryId(fileMatch.getSourcePath(), repository.getId());
 
-      ImportLocalizedAssetBody importLocalizedAssetForContent =
-          assetClient.importLocalizedAssetForContent(
-              assetByPathAndRepositoryId.getId(),
-              locale.getId(),
-              commandHelper.getFileContent(targetPath),
-              statusForEqualTarget,
-              fileMatch.getFileType().getFilterConfigIdOverride(),
-              commandHelper.getFilterOptionsOrDefaults(
-                  fileMatch.getFileType(), filterOptionsParam));
-
+      String fileContent;
       try {
-        commandHelper.waitForPollableTask(importLocalizedAssetForContent.getPollableTask().getId());
-      } catch (PollableTaskException e) {
-        throw new CommandException(e.getMessage(), e.getCause());
+        fileContent = commandHelper.getFileContent(targetPath);
+      } catch (Exception e) {
+        if (continueOnError) {
+          if (!commandHelper.getFileContent(fileMatch.getPath()).isBlank()) {
+            consoleWriter
+                .a("   Missing file, skipping: ")
+                .fg(Ansi.Color.YELLOW)
+                .a(targetPath.toString())
+                .println();
+          }
+          return null;
+        } else {
+          throw e;
+        }
       }
+      return assetClient.importLocalizedAssetForContent(
+          assetByPathAndRepositoryId.getId(),
+          locale.getId(),
+          fileContent,
+          statusForEqualTarget,
+          fileMatch.getFileType().getFilterConfigIdOverride(),
+          commandHelper.getFilterOptionsOrDefaults(fileMatch.getFileType(), filterOptionsParam));
     } catch (AssetNotFoundException ex) {
-      throw new CommandException(
-          "No asset for file [" + fileMatch.getPath() + "] into repo [" + repositoryParam + "]",
-          ex);
+      if (continueOnError) {
+        consoleWriter
+            .a("   Asset not found: ")
+            .fg(Ansi.Color.YELLOW)
+            .a(fileMatch.getPath().toString())
+            .println();
+      } else {
+        throw new CommandException(
+            "No asset for file [" + fileMatch.getPath() + "] into repo [" + repositoryParam + "]",
+            ex);
+      }
     }
+    return null;
   }
 
   public Collection<Locale> getLocalesForImport() {
     Collection<Locale> sortedRepositoryLocales =
         commandHelper.getSortedRepositoryLocales(repository).values();
-    filterLocalesWithMapping(sortedRepositoryLocales);
-    return sortedRepositoryLocales;
-  }
-
-  private void filterLocalesWithMapping(Collection<Locale> locales) {
-
-    if (inverseLocaleMapping != null) {
-      Iterator<Locale> iterator = locales.iterator();
-      while (iterator.hasNext()) {
-        Locale l = iterator.next();
-        if (!inverseLocaleMapping.containsKey(l.getBcp47Tag())) {
-          iterator.remove();
-        }
-      }
+    if (LocaleMappingType.MAP_ONLY.equals(localeMappingTypeParam) && inverseLocaleMapping != null) {
+      sortedRepositoryLocales =
+          sortedRepositoryLocales.stream()
+              .filter(l -> inverseLocaleMapping.containsKey(l.getBcp47Tag()))
+              .toList();
     }
+    return sortedRepositoryLocales;
   }
 
   private Path getTargetPath(FileMatch fileMatch, Locale locale) throws CommandException {
 
-    String targetLocale;
+    String targetLocale = locale.getBcp47Tag();
 
-    if (inverseLocaleMapping != null) {
+    if (inverseLocaleMapping != null && inverseLocaleMapping.containsKey(locale.getBcp47Tag())) {
       targetLocale = inverseLocaleMapping.get(locale.getBcp47Tag());
-    } else {
-      targetLocale = locale.getBcp47Tag();
     }
 
     logger.info("processing locale for import: {}", targetLocale);