feat(AutoPublishJob): Add and hook auto publish job.

Author: binh-dam-ibigroup

src/main/java/com/conveyal/datatools/manager/jobs/AutoPublishJob.java

@@ -99,6 +99,7 @@ public void jobLogic() {
             // If validation successful, just execute the feed updating process.
             // FIXME: move method to another class.
             FeedVersionController.publishToExternalResource(latestFeedVersion);
+            LOG.info("Auto-published feed source {} to external resource.", feedSource.id);
         } catch (Exception e) {
             status.fail(
                 String.format("Could not auto-publish feed source %s!", feedSource.name),

src/main/java/com/conveyal/datatools/manager/jobs/ProcessSingleFeedJob.java

@@ -150,6 +150,16 @@ public void jobLogic() {
         ) {
             addNextJob(new AutoDeployJob(feedSource.retrieveProject(), owner));
         }
+
+        // If auto-publish job is enabled (MTC extension required),
+        // create an auto-publish job for feeds that are fetched automatically.
+        if (
+            DataManager.isExtensionEnabled("mtc") &&
+                feedSource.autoPublish &&
+                feedVersion.retrievalMethod == FeedRetrievalMethod.FETCHED_AUTOMATICALLY
+        ) {
+            addNextJob(new AutoPublishJob(feedSource, owner));
+        }
     }
 
     /**

src/main/java/com/conveyal/datatools/manager/models/FeedVersion.java

@@ -407,10 +407,34 @@ private boolean hasFeedVersionExpired() {
      * @return whether high severity error types have been flagged.
      */
     private boolean hasHighSeverityErrorTypes() {
-        Set<String> highSeverityErrorTypes = Stream.of(NewGTFSErrorType.values())
-                .filter(type -> type.priority == Priority.HIGH)
-                .map(NewGTFSErrorType::toString)
-                .collect(Collectors.toSet());
+        return hasSpecificErrorTypes(Stream.of(NewGTFSErrorType.values())
+            .filter(type -> type.priority == Priority.HIGH));
+    }
+
+    /**
+     * Checks for issues that block feed publishing, consistent with UI.
+     */
+    public boolean hasBlockingIssuesForPublishing() {
+        if (this.validationResult.fatalException != null) return true;
+
+        return hasSpecificErrorTypes(Stream.of(
+            NewGTFSErrorType.ILLEGAL_FIELD_VALUE,
+            NewGTFSErrorType.MISSING_COLUMN,
+            NewGTFSErrorType.REFERENTIAL_INTEGRITY,
+            NewGTFSErrorType.SERVICE_WITHOUT_DAYS_OF_WEEK,
+            NewGTFSErrorType.TABLE_MISSING_COLUMN_HEADERS,
+            NewGTFSErrorType.TABLE_IN_SUBDIRECTORY,
+            NewGTFSErrorType.WRONG_NUMBER_OF_FIELDS
+        ));
+    }
+
+    /**
+     * Determines whether this feed has specific error types.
+     */
+    private boolean hasSpecificErrorTypes(Stream<NewGTFSErrorType> errorTypes) {
+        Set<String> highSeverityErrorTypes = errorTypes
+            .map(NewGTFSErrorType::toString)
+            .collect(Collectors.toSet());
         try (Connection connection = GTFS_DATA_SOURCE.getConnection()) {
             String sql = String.format("select distinct error_type from %s.errors", namespace);
             PreparedStatement preparedStatement = connection.prepareStatement(sql);
@@ -427,23 +451,8 @@ private boolean hasHighSeverityErrorTypes() {
             // is invalid for one reason or another.
             return true;
         }
-        return false;
-    }
-
-    /**
-     * Checks for issues that block feed publishing, consistent with UI.
-     */
-    public boolean hasBlockingIssuesForPublishing() {
-        return this.validationResult.fatalException != null;
-        /*
-        if () return true;
-        const errorCounts = version.validationResult.error_counts
-            return errorCounts &&
-                !!(errorCounts.find(ec => BLOCKING_ERROR_TYPES.indexOf(ec.type) !== -1))
-        }
 
-
-         */
+        return false;
     }
 
     @JsonView(JsonViews.UserInterface.class)

src/test/java/com/conveyal/datatools/manager/models/FeedVersionTest.java

@@ -3,13 +3,27 @@
 import com.conveyal.datatools.DatatoolsTest;
 import com.conveyal.datatools.UnitTest;
 import com.conveyal.datatools.manager.persistence.Persistence;
+import com.conveyal.gtfs.error.NewGTFSError;
+import com.conveyal.gtfs.error.NewGTFSErrorType;
+import com.conveyal.gtfs.error.SQLErrorStorage;
+import com.conveyal.gtfs.util.InvalidNamespaceException;
 import com.conveyal.gtfs.validator.ValidationResult;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
+import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.Date;
+import java.util.stream.Stream;
 
+import static com.conveyal.datatools.TestUtils.createFeedVersionFromGtfsZip;
+import static com.conveyal.datatools.manager.DataManager.GTFS_DATA_SOURCE;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.not;
@@ -55,14 +69,41 @@ void canCreateUniqueFeedVersionIDs() {
     }
 
     /**
-     * Detect feeds with blocking issues for publishing.
+     * Detect feeds with fatal exceptions (a blocking issue for publishing).
      */
     @Test
-    void canDetectBlockingIssuesForPublishing() {
+    void canDetectBlockingFatalExceptionsForPublishing() {
         FeedVersion feedVersion1 = new FeedVersion(feedSource);
         feedVersion1.validationResult = new ValidationResult();
         feedVersion1.validationResult.fatalException = "A fatal exception occurred";
 
         assertThat(feedVersion1.hasBlockingIssuesForPublishing(), equalTo(true));
     }
+
+    /**
+     * Detect feeds with blocking error types that prevents publishing, per
+     * https://github.com/ibi-group/datatools-ui/blob/dev/lib/manager/util/version.js#L79.
+     */
+    @ParameterizedTest
+    @EnumSource(value = NewGTFSErrorType.class, names = { 
+        "ILLEGAL_FIELD_VALUE",
+        "MISSING_COLUMN",
+        "REFERENTIAL_INTEGRITY",
+        "SERVICE_WITHOUT_DAYS_OF_WEEK",
+        "TABLE_MISSING_COLUMN_HEADERS",
+        "TABLE_IN_SUBDIRECTORY",
+        "WRONG_NUMBER_OF_FIELDS"
+    })
+    void canDetectBlockingErrorTypesForPublishing(NewGTFSErrorType errorType) throws InvalidNamespaceException, SQLException {
+        FeedVersion feedVersion1 = createFeedVersionFromGtfsZip(feedSource, "bart_old_lite.zip");
+
+        // Add blocking error types to feed version
+        try (Connection connection = GTFS_DATA_SOURCE.getConnection()) {
+            SQLErrorStorage errorStorage = new SQLErrorStorage(connection, feedVersion1.namespace + ".", false);
+            errorStorage.storeError(NewGTFSError.forFeed(errorType, null));
+            errorStorage.commitAndClose();
+        }
+
+        assertThat(feedVersion1.hasBlockingIssuesForPublishing(), equalTo(true));
+    }
 }