> getNonRetryableExceptions() {
+ return Collections.emptySet(); // No need to track specific exceptions
+ }
+
+}
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryPolicyProcessor.java b/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryPolicyProcessor.java
new file mode 100644
index 000000000000..1775684c8f33
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryPolicyProcessor.java
@@ -0,0 +1,93 @@
+package com.dotcms.jobs.business.error;
+
+import com.dotcms.jobs.business.processor.ExponentialBackoffRetryPolicy;
+import com.dotcms.jobs.business.processor.JobProcessor;
+import com.dotcms.jobs.business.processor.NoRetryPolicy;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import javax.enterprise.context.ApplicationScoped;
+import javax.inject.Inject;
+
+/**
+ * Processes retry policies for job processors. This class is responsible for interpreting retry
+ * policy annotations on job processor classes and creating appropriate RetryStrategy instances.
+ */
+@ApplicationScoped
+public class RetryPolicyProcessor {
+
+ private NoRetryStrategy noRetryStrategy;
+
+ /**
+ * Default constructor required for CDI proxy creation.
+ */
+ public RetryPolicyProcessor() {
+ // Default constructor for CDI
+ }
+
+ @Inject
+ public RetryPolicyProcessor(NoRetryStrategy noRetryStrategy) {
+ this.noRetryStrategy = noRetryStrategy;
+ }
+
+ /**
+ * Processes the retry policy for a given job processor class.
+ *
+ * Currently supports ExponentialBackoffRetryPolicy and NoRetryPolicy.
+ *
+ * @param processorClass The class of the job processor to process.
+ * @return A RetryStrategy based on the annotation present on the processor class, or null if no
+ * supported annotation is found.
+ *
+ * @see ExponentialBackoffRetryPolicy
+ * @see NoRetryPolicy
+ */
+ public RetryStrategy processRetryPolicy(Class processorClass) {
+
+ // Check for NoRetryPolicy
+ if (processorClass.isAnnotationPresent(NoRetryPolicy.class)) {
+ return noRetryStrategy;
+ }
+
+ // Check for ExponentialBackoffRetryPolicy
+ if (processorClass.isAnnotationPresent(ExponentialBackoffRetryPolicy.class)) {
+ return processExponentialBackoffPolicy(
+ processorClass.getAnnotation(ExponentialBackoffRetryPolicy.class)
+ );
+ }
+
+ return null;
+ }
+
+ /**
+ * Processes an ExponentialBackoffRetryPolicy annotation and creates an
+ * ExponentialBackoffRetryStrategy based on its parameters.
+ *
+ * @param policy The ExponentialBackoffRetryPolicy annotation to process
+ * @return An ExponentialBackoffRetryStrategy configured based on the annotation
+ */
+ private RetryStrategy processExponentialBackoffPolicy(ExponentialBackoffRetryPolicy policy) {
+
+ final long initialDelay = policy.initialDelay() != -1 ? policy.initialDelay()
+ : RetryStrategyProducer.DEFAULT_RETRY_STRATEGY_INITIAL_DELAY;
+ final long maxDelay = policy.maxDelay() != -1 ? policy.maxDelay() :
+ RetryStrategyProducer.DEFAULT_RETRY_STRATEGY_MAX_DELAY;
+ final double backoffFactor = policy.backoffFactor() != -1 ? policy.backoffFactor()
+ : RetryStrategyProducer.DEFAULT_RETRY_STRATEGY_BACK0FF_FACTOR;
+ final int maxRetries = policy.maxRetries() != -1 ? policy.maxRetries()
+ : RetryStrategyProducer.DEFAULT_RETRY_STRATEGY_MAX_RETRIES;
+
+ Set> nonRetryableExceptions = new HashSet<>(
+ Arrays.asList(policy.nonRetryableExceptions())
+ );
+
+ return new ExponentialBackoffRetryStrategy(
+ initialDelay,
+ maxDelay,
+ backoffFactor,
+ maxRetries,
+ nonRetryableExceptions
+ );
+ }
+
+}
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategy.java b/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategy.java
index 23f54600de02..256172478224 100644
--- a/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategy.java
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategy.java
@@ -35,25 +35,25 @@ public interface RetryStrategy {
int maxRetries();
/**
- * Determines whether a given exception is retryable according to this strategy.
+ * Determines whether a given exception is not retryable according to this strategy.
*
* @param exceptionClass The class of the exception to check.
- * @return true if the exception is retryable, false otherwise.
+ * @return true if the exception is not retryable, false otherwise.
*/
- boolean isRetryableException(Class exceptionClass);
+ boolean isNonRetryableException(Class exceptionClass);
/**
- * Adds an exception class to the set of retryable exceptions.
+ * Adds an exception class to the set of non retryable exceptions.
*
- * @param exceptionClass The exception class to be considered retryable.
+ * @param exceptionClass The exception class to be considered non retryable.
*/
- void addRetryableException(Class exceptionClass);
+ void addNonRetryableException(Class exceptionClass);
/**
- * Returns an unmodifiable set of the currently registered retryable exceptions.
+ * Returns an unmodifiable set of the currently registered non retryable exceptions.
*
- * @return An unmodifiable set of retryable exception classes.
+ * @return An unmodifiable set of non retryable exception classes.
*/
- Set> getRetryableExceptions();
+ Set> getNonRetryableExceptions();
}
\ No newline at end of file
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategyProducer.java b/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategyProducer.java
index 2b9452d66713..f91b9a6755c9 100644
--- a/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategyProducer.java
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/error/RetryStrategyProducer.java
@@ -1,5 +1,6 @@
package com.dotcms.jobs.business.error;
+import com.dotcms.jobs.business.processor.DefaultRetryStrategy;
import com.dotmarketing.util.Config;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Produces;
@@ -38,6 +39,7 @@ public class RetryStrategyProducer {
* @return An ExponentialBackoffRetryStrategy instance configured with the default values.
*/
@Produces
+ @DefaultRetryStrategy
public RetryStrategy produceDefaultRetryStrategy() {
return new ExponentialBackoffRetryStrategy(
DEFAULT_RETRY_STRATEGY_INITIAL_DELAY,
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/DefaultRetryStrategy.java b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/DefaultRetryStrategy.java
new file mode 100644
index 000000000000..82802b95c6b9
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/DefaultRetryStrategy.java
@@ -0,0 +1,23 @@
+package com.dotcms.jobs.business.processor;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+/**
+ * Qualifier annotation to identify the default retry strategy implementation.
+ */
+@Qualifier
+@Retention(RUNTIME)
+@Target({TYPE, METHOD, FIELD, PARAMETER})
+@Documented
+public @interface DefaultRetryStrategy {
+
+}
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/ExponentialBackoffRetryPolicy.java b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/ExponentialBackoffRetryPolicy.java
new file mode 100644
index 000000000000..4e31497fda55
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/ExponentialBackoffRetryPolicy.java
@@ -0,0 +1,66 @@
+package com.dotcms.jobs.business.processor;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation to specify an exponential backoff retry policy for job processors. This annotation
+ *
+ * should be applied at the class level to define the retry behavior for the entire job processor.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface ExponentialBackoffRetryPolicy {
+
+ /**
+ * Specifies the maximum number of retry attempts.
+ *
+ * If set to -1, the value will be taken from the configuration property
+ * 'DEFAULT_RETRY_STRATEGY_MAX_RETRIES'.
+ *
+ * @return the maximum number of retries, or -1 to use the config value
+ */
+ int maxRetries() default -1;
+
+ /**
+ * Specifies the initial delay between retry attempts in milliseconds.
+ *
+ * If set to -1, the value will be taken from the configuration property
+ * 'DEFAULT_RETRY_STRATEGY_INITIAL_DELAY'.
+ *
+ * @return the initial delay in milliseconds, or -1 to use the config value
+ */
+ long initialDelay() default -1;
+
+ /**
+ * Specifies the maximum delay between retry attempts in milliseconds.
+ *
+ * If set to -1, the value will be taken from the configuration property
+ * 'DEFAULT_RETRY_STRATEGY_MAX_DELAY'.
+ *
+ * @return the maximum delay in milliseconds, or -1 to use the config value
+ */
+ long maxDelay() default -1;
+
+ /**
+ * Specifies the factor by which the delay increases with each retry attempt.
+ *
+ * If set to -1, the value will be taken from the configuration property
+ * 'DEFAULT_RETRY_STRATEGY_BACK0FF_FACTOR'.
+ *
+ * @return the backoff factor, or -1 to use the config value
+ */
+ double backoffFactor() default -1;
+
+ /**
+ * Specifies the exception types that should not be retried. If an empty array is provided, all
+ * exceptions will be considered retryable.
+ *
+ * @return an array of Throwable classes representing non-retryable exceptions
+ */
+ Class[] nonRetryableExceptions() default {};
+}
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/NoRetryPolicy.java b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/NoRetryPolicy.java
new file mode 100644
index 000000000000..527805fba76f
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/NoRetryPolicy.java
@@ -0,0 +1,28 @@
+package com.dotcms.jobs.business.processor;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation to explicitly specify that a job processor should not retry failed jobs.
+ * This provides a more semantic way to indicate no-retry behavior compared to setting
+ * maxRetries=0 in ExponentialBackoffRetryPolicy.
+ *
+ *
Usage example:
+ *
+ * {@literal @}NoRetryPolicy
+ * {@literal @}Queue("myQueue")
+ * public class MyJobProcessor implements JobProcessor {
+ * // Implementation
+ * }
+ *
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface NoRetryPolicy {
+ // No elements needed - presence of annotation is sufficient
+}
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/FailJob.java b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/FailSuccessJob.java
similarity index 69%
rename from dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/FailJob.java
rename to dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/FailSuccessJob.java
index a70a4a4103b6..ae34091b2bbd 100644
--- a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/FailJob.java
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/FailSuccessJob.java
@@ -6,13 +6,14 @@
import com.dotmarketing.exception.DotRuntimeException;
import java.util.Map;
-@Queue("fail")
-public class FailJob implements JobProcessor {
+@Queue("failSuccess")
+public class FailSuccessJob implements JobProcessor {
@Override
public void process(Job job) {
-
- throw new DotRuntimeException( "Failed job !");
+ if (job.parameters().containsKey("fail")) {
+ throw new DotRuntimeException("Failed job !");
+ }
}
@Override
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/ImportContentletsProcessor.java b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/ImportContentletsProcessor.java
new file mode 100644
index 000000000000..5c586ee62a59
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/ImportContentletsProcessor.java
@@ -0,0 +1,728 @@
+package com.dotcms.jobs.business.processor.impl;
+
+import com.dotcms.contenttype.model.type.ContentType;
+import com.dotcms.jobs.business.error.JobCancellationException;
+import com.dotcms.jobs.business.error.JobProcessingException;
+import com.dotcms.jobs.business.error.JobValidationException;
+import com.dotcms.jobs.business.job.Job;
+import com.dotcms.jobs.business.processor.Cancellable;
+import com.dotcms.jobs.business.processor.ExponentialBackoffRetryPolicy;
+import com.dotcms.jobs.business.processor.JobProcessor;
+import com.dotcms.jobs.business.processor.NoRetryPolicy;
+import com.dotcms.jobs.business.processor.Queue;
+import com.dotcms.jobs.business.util.JobUtil;
+import com.dotcms.repackage.com.csvreader.CsvReader;
+import com.dotcms.rest.api.v1.temp.DotTempFile;
+import com.dotmarketing.beans.Host;
+import com.dotmarketing.business.APILocator;
+import com.dotmarketing.db.HibernateUtil;
+import com.dotmarketing.exception.DotDataException;
+import com.dotmarketing.exception.DotHibernateException;
+import com.dotmarketing.exception.DotSecurityException;
+import com.dotmarketing.portlets.contentlet.action.ImportAuditUtil;
+import com.dotmarketing.util.AdminLogger;
+import com.dotmarketing.util.FileUtil;
+import com.dotmarketing.util.ImportUtil;
+import com.dotmarketing.util.Logger;
+import com.google.common.hash.Hashing;
+import com.liferay.portal.model.User;
+import com.liferay.portal.util.Constants;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.LongConsumer;
+
+/**
+ * Processor implementation for handling content import operations in dotCMS. This class provides
+ * functionality to import content from CSV files, with support for both preview and publish
+ * operations, as well as multilingual content handling.
+ *
+ * The processor implements both {@link JobProcessor} and {@link Cancellable} interfaces to
+ * provide job processing and cancellation capabilities. It's annotated with {@link Queue} to
+ * specify the queue name and {@link ExponentialBackoffRetryPolicy} to define retry behavior.
+ *
+ * Key features:
+ *
+ * - Support for both preview and publish operations
+ * - Multilingual content import capabilities
+ * - Progress tracking during import
+ * - Cancellation support
+ * - Validation of import parameters and content
+ *
+ *
+ * @see JobProcessor
+ * @see Cancellable
+ * @see Queue
+ * @see ExponentialBackoffRetryPolicy
+ */
+@Queue("importContentlets")
+@NoRetryPolicy
+public class ImportContentletsProcessor implements JobProcessor, Cancellable {
+
+ private static final String PARAMETER_LANGUAGE = "language";
+ private static final String PARAMETER_FIELDS = "fields";
+ private static final String PARAMETER_USER_ID = "userId";
+ private static final String PARAMETER_SITE_IDENTIFIER = "siteIdentifier";
+ private static final String PARAMETER_SITE_NAME = "siteName";
+ private static final String PARAMETER_CONTENT_TYPE = "contentType";
+ private static final String PARAMETER_WORKFLOW_ACTION_ID = "workflowActionId";
+ private static final String PARAMETER_CMD = Constants.CMD;
+ private static final String CMD_PREVIEW = com.dotmarketing.util.Constants.PREVIEW;
+ private static final String CMD_PUBLISH = com.dotmarketing.util.Constants.PUBLISH;
+
+ private static final String LANGUAGE_CODE_HEADER = "languageCode";
+ private static final String COUNTRY_CODE_HEADER = "countryCode";
+
+ /**
+ * Flag to track cancellation requests for the current import operation.
+ */
+ private final AtomicBoolean cancellationRequested = new AtomicBoolean(false);
+
+ /**
+ * Storage for metadata about the import operation results.
+ */
+ private Map resultMetadata = new HashMap<>();
+
+ /**
+ * Processes a content import job. This method serves as the main entry point for the import
+ * operation and handles both preview and publish modes.
+ *
+ * The method performs the following steps:
+ *
+ * - Validates the input parameters and retrieves the necessary user information
+ * - Retrieves and validates the import file
+ * - Sets up progress tracking
+ * - Executes either preview or publish operation based on the command
+ * - Ensures proper progress updates throughout the process
+ *
+ *
+ * @param job The job containing import parameters and configuration
+ * @throws JobProcessingException if any error occurs during processing
+ */
+ @Override
+ public void process(final Job job) throws JobProcessingException {
+
+ final String command = getCommand(job);
+
+ final User user;
+ try {
+ user = getUser(job);
+ } catch (Exception e) {
+ Logger.error(this, "Error retrieving user", e);
+ throw new JobProcessingException(job.id(), "Error retrieving user", e);
+ }
+
+ Logger.info(this, String.format("Processing import contentlets job [%s], "
+ + "with command [%s] and user [%s]", job.id(), command, user.getUserId()));
+
+ // Retrieving the import file
+ Optional tempFile = JobUtil.retrieveTempFile(job);
+ if (tempFile.isEmpty()) {
+ Logger.error(this.getClass(), "Unable to retrieve the import file. Quitting the job.");
+ throw new JobValidationException(job.id(), "Unable to retrieve the import file.");
+ }
+
+ // Validate the job has the required data
+ validate(job);
+
+ final var language = getLanguage(job);
+ final var fileToImport = tempFile.get().file;
+ final long totalLines = totalLines(job, fileToImport);
+ final Charset charset = language == -1 ?
+ Charset.defaultCharset() : FileUtil.detectEncodeType(fileToImport);
+
+ // Create a progress callback function
+ final var progressTracker = job.progressTracker().orElseThrow(
+ () -> new JobProcessingException(job.id(), "Progress tracker not found")
+ );
+ final LongConsumer progressCallback = processedLines -> {
+ float progressPercentage = (float) processedLines / totalLines;
+ // This ensures the progress is between 0.0 and 1.0
+ progressTracker.updateProgress(Math.min(1.0f, Math.max(0.0f, progressPercentage)));
+ };
+
+ if (CMD_PREVIEW.equals(command)) {
+ handlePreview(job, language, fileToImport, charset, user, progressCallback);
+ } else if (CMD_PUBLISH.equals(command)) {
+ handlePublish(job, language, fileToImport, charset, user, progressCallback);
+ }
+
+ if (!cancellationRequested.get()) {
+ // Ensure the progress is at 100% when the job is done
+ progressTracker.updateProgress(1.0f);
+ }
+ }
+
+ /**
+ * Handles cancellation requests for the import operation. When called, it marks the operation
+ * for cancellation.
+ *
+ * @param job The job to be cancelled
+ * @throws JobCancellationException if any error occurs during cancellation
+ */
+ @Override
+ public void cancel(Job job) throws JobCancellationException {
+
+ Logger.info(this.getClass(), "Job cancellation requested: " + job.id());
+ cancellationRequested.set(true);
+
+ final var importId = jobIdToLong(job.id());
+ ImportAuditUtil.cancelledImports.put(importId, Calendar.getInstance().getTime());
+ }
+
+ /**
+ * Retrieves metadata about the import operation results.
+ *
+ * @param job The job whose metadata is being requested
+ * @return A map containing result metadata, or an empty map if no metadata is available
+ */
+ @Override
+ public Map getResultMetadata(Job job) {
+
+ if (resultMetadata.isEmpty()) {
+ return Collections.emptyMap();
+ }
+
+ return resultMetadata;
+ }
+
+ /**
+ * Handles the preview phase of content import. This method analyzes the CSV file and provides
+ * information about potential issues without actually importing the content.
+ *
+ * @param job The import job configuration
+ * @param language The target language for import
+ * @param fileToImport The CSV file to be imported
+ * @param charset The character encoding of the import file
+ * @param user The user performing the import
+ * @param progressCallback Callback for tracking import progress
+ */
+ private void handlePreview(final Job job, long language, final File fileToImport,
+ final Charset charset, final User user, final LongConsumer progressCallback) {
+
+ try {
+ try (Reader reader = new BufferedReader(
+ new InputStreamReader(new FileInputStream(fileToImport), charset))) {
+
+ CsvReader csvReader = createCsvReader(reader);
+ CsvHeaderInfo headerInfo = processHeadersBasedOnLanguage(job, language, csvReader);
+
+ final var previewResult = generatePreview(job, user,
+ headerInfo.headers, csvReader, headerInfo.languageCodeColumn,
+ headerInfo.countryCodeColumn, progressCallback);
+ resultMetadata = new HashMap<>(previewResult);
+ }
+ } catch (Exception e) {
+
+ try {
+ HibernateUtil.rollbackTransaction();
+ } catch (DotHibernateException he) {
+ Logger.error(this, he.getMessage(), he);
+ }
+
+ final var errorMessage = "An error occurred when analyzing the CSV file.";
+ Logger.error(this, errorMessage, e);
+ throw new JobProcessingException(job.id(), errorMessage, e);
+ }
+ }
+
+ /**
+ * Handles the publish phase of content import. This method performs the actual content import
+ * operation, creating or updating content based on the CSV file.
+ *
+ * @param job The import job configuration
+ * @param language The target language for import
+ * @param fileToImport The CSV file to be imported
+ * @param charset The character encoding of the import file
+ * @param user The user performing the import
+ * @param progressCallback Callback for tracking import progress
+ */
+ private void handlePublish(final Job job, long language, final File fileToImport,
+ final Charset charset, final User user, final LongConsumer progressCallback) {
+
+ AdminLogger.log(
+ ImportContentletsProcessor.class, "process",
+ "Importing Contentlets", user
+ );
+
+ try {
+ try (Reader reader = new BufferedReader(
+ new InputStreamReader(new FileInputStream(fileToImport), charset))) {
+
+ CsvReader csvReader = createCsvReader(reader);
+ CsvHeaderInfo headerInfo = readPublishHeaders(language, csvReader);
+
+ final var importResults = processFile(job, user, headerInfo.headers, csvReader,
+ headerInfo.languageCodeColumn, headerInfo.countryCodeColumn,
+ progressCallback);
+ resultMetadata = new HashMap<>(importResults);
+ }
+ } catch (Exception e) {
+
+ try {
+ HibernateUtil.rollbackTransaction();
+ } catch (DotHibernateException he) {
+ Logger.error(this, he.getMessage(), he);
+ }
+
+ final var errorMessage = "An error occurred when importing the CSV file.";
+ Logger.error(this, errorMessage, e);
+ throw new JobProcessingException(job.id(), errorMessage, e);
+ } finally {
+ final var importId = jobIdToLong(job.id());
+ ImportAuditUtil.cancelledImports.remove(importId);
+ }
+ }
+
+ /**
+ * Reads and analyzes the content of the CSV import file to determine potential errors,
+ * inconsistencies or warnings, and provide the user with useful information regarding the
+ * contents of the file.
+ *
+ * @param job - The {@link Job} being processed.
+ * @param user - The {@link User} performing this action.
+ * @param csvHeaders - The headers that make up the CSV file.
+ * @param csvReader - The actual data contained in the CSV file.
+ * @param languageCodeHeaderColumn - The column name containing the language code.
+ * @param countryCodeHeaderColumn - The column name containing the country code.
+ * @param progressCallback - The callback function to update the progress of the job.
+ * @throws DotDataException An error occurred when analyzing the CSV file.
+ */
+ private Map> generatePreview(final Job job, final User user,
+ final String[] csvHeaders, final CsvReader csvReader,
+ final int languageCodeHeaderColumn, int countryCodeHeaderColumn,
+ final LongConsumer progressCallback) throws DotDataException {
+
+ final var currentSiteId = getSiteIdentifier(job);
+ final var currentSiteName = getSiteName(job);
+ final var contentType = getContentType(job);
+ final var fields = getFields(job);
+ final var language = getLanguage(job);
+ final var workflowActionId = getWorkflowActionId(job);
+ final var httpReq = JobUtil.generateMockRequest(user, currentSiteName);
+
+ Logger.info(this, "-------- Starting Content Import Preview -------- ");
+ Logger.info(this, String.format("-> Content Type ID: %s", contentType));
+
+ return ImportUtil.importFile(0L, currentSiteId, contentType, fields, true,
+ (language == -1), user, language, csvHeaders, csvReader, languageCodeHeaderColumn,
+ countryCodeHeaderColumn, workflowActionId, httpReq, progressCallback);
+ }
+
+ /**
+ * Executes the content import process after the review process has been run and displayed to
+ * the user.
+ *
+ * @param job - The {@link Job} being processed.
+ * @param user - The {@link User} performing this action.
+ * @param csvHeaders - The headers that make up the CSV file.
+ * @param csvReader - The actual data contained in the CSV file.
+ * @param languageCodeHeaderColumn - The column name containing the language code.
+ * @param countryCodeHeaderColumn - The column name containing the country code.
+ * @param progressCallback - The callback function to update the progress of the job.
+ * @return The status of the content import performed by dotCMS. This provides information
+ * regarding inconsistencies, errors, warnings and/or precautions to the user.
+ * @throws DotDataException An error occurred when importing the CSV file.
+ */
+ private Map> processFile(final Job job, final User user,
+ final String[] csvHeaders, final CsvReader csvReader,
+ final int languageCodeHeaderColumn, final int countryCodeHeaderColumn,
+ final LongConsumer progressCallback) throws DotDataException {
+
+ final var currentSiteId = getSiteIdentifier(job);
+ final var currentSiteName = getSiteName(job);
+ final var contentType = getContentType(job);
+ final var fields = getFields(job);
+ final var language = getLanguage(job);
+ final var workflowActionId = getWorkflowActionId(job);
+ final var httpReq = JobUtil.generateMockRequest(user, currentSiteName);
+ final var importId = jobIdToLong(job.id());
+
+ Logger.info(this, "-------- Starting Content Import Process -------- ");
+ Logger.info(this, String.format("-> Content Type ID: %s", contentType));
+
+ return ImportUtil.importFile(importId, currentSiteId, contentType, fields, false,
+ (language == -1), user, language, csvHeaders, csvReader, languageCodeHeaderColumn,
+ countryCodeHeaderColumn, workflowActionId, httpReq, progressCallback);
+ }
+
+ /**
+ * Retrieve the command from the job parameters
+ *
+ * @param job input job
+ * @return the command from the job parameters, if not found, return the default value "preview"
+ */
+ private String getCommand(final Job job) {
+
+ if (!job.parameters().containsKey(PARAMETER_CMD)) {
+ return CMD_PREVIEW;
+ }
+
+ return (String) job.parameters().get(PARAMETER_CMD);
+ }
+
+ /**
+ * Retrieve the user from the job parameters
+ *
+ * @param job input job
+ * @return the user from the job parameters
+ * @throws DotDataException if an error occurs during the user retrieval
+ * @throws DotSecurityException if we don't have the necessary permissions to retrieve the user
+ */
+ private User getUser(final Job job) throws DotDataException, DotSecurityException {
+ final var userId = (String) job.parameters().get(PARAMETER_USER_ID);
+ return APILocator.getUserAPI().loadUserById(userId);
+ }
+
+ /**
+ * Retrieves the site identifier from the job parameters.
+ *
+ * @param job The job containing the parameters
+ * @return The site identifier string, or null if not present in parameters
+ */
+ private String getSiteIdentifier(final Job job) {
+ return (String) job.parameters().get(PARAMETER_SITE_IDENTIFIER);
+ }
+
+ /**
+ * Retrieves the site name from the job parameters.
+ *
+ * @param job The job containing the parameters
+ * @return The site name string, or null if not present in parameters
+ */
+ private String getSiteName(final Job job) {
+ return (String) job.parameters().get(PARAMETER_SITE_NAME);
+ }
+
+ /**
+ * Retrieves the content type from the job parameters.
+ *
+ * @param job The job containing the parameters
+ * @return The content type string, or null if not present in parameters
+ */
+ private String getContentType(final Job job) {
+ return (String) job.parameters().get(PARAMETER_CONTENT_TYPE);
+ }
+
+ /**
+ * Retrieves the workflow action ID from the job parameters.
+ *
+ * @param job The job containing the parameters
+ * @return The workflow action ID string, or null if not present in parameters
+ */
+ private String getWorkflowActionId(final Job job) {
+ return (String) job.parameters().get(PARAMETER_WORKFLOW_ACTION_ID);
+ }
+
+ /**
+ * Retrieves the language setting from the job parameters. Handles both string and long
+ * parameter types.
+ *
+ * @param job The job containing the parameters
+ * @return The language ID as a long, or -1 if not specified
+ */
+ private long getLanguage(final Job job) {
+
+ if (!job.parameters().containsKey(PARAMETER_LANGUAGE)
+ || job.parameters().get(PARAMETER_LANGUAGE) == null) {
+ return -1;
+ }
+
+ final Object language = job.parameters().get(PARAMETER_LANGUAGE);
+
+ if (language instanceof String) {
+ return Long.parseLong((String) language);
+ }
+
+ return (long) language;
+ }
+
+ /**
+ * Retrieves the fields array from the job parameters.
+ *
+ * @param job The job containing the parameters
+ * @return An array of field strings, or an empty array if no fields are specified
+ */
+ public String[] getFields(final Job job) {
+
+ if (!job.parameters().containsKey(PARAMETER_FIELDS)
+ || job.parameters().get(PARAMETER_FIELDS) == null) {
+ return new String[0];
+ }
+
+ final var fields = job.parameters().get(PARAMETER_FIELDS);
+ if (fields instanceof List) {
+ return ((List) fields).toArray(new String[0]);
+ }
+
+ return (String[]) fields;
+ }
+
+ /**
+ * Validates the job parameters and content type. Performs security checks to prevent
+ * unauthorized host imports.
+ *
+ * @param job The job to validate
+ * @throws JobValidationException if validation fails
+ * @throws JobProcessingException if an error occurs during content type validation
+ */
+ private void validate(final Job job) {
+
+ if (getContentType(job) != null && getContentType(job).isEmpty()) {
+ Logger.error(this.getClass(), "A Content Type is required");
+ throw new JobValidationException(job.id(), "A Content Type is required");
+ } else if (getWorkflowActionId(job) != null && getWorkflowActionId(job).isEmpty()) {
+ Logger.error(this.getClass(), "Workflow action type is required");
+ throw new JobValidationException(job.id(), "Workflow action type is required");
+ }
+
+ // Security measure to prevent invalid attempts to import a host.
+ try {
+ final ContentType hostContentType = APILocator.getContentTypeAPI(
+ APILocator.systemUser()).find(Host.HOST_VELOCITY_VAR_NAME
+ );
+ final boolean isHost = (hostContentType.id().equals(getContentType(job)));
+ if (isHost) {
+ Logger.error(this, "Invalid attempt to import a host.");
+ throw new JobValidationException(job.id(), "Invalid attempt to import a host.");
+ }
+ } catch (DotSecurityException | DotDataException e) {
+ throw new JobProcessingException(job.id(), "Error validating content type", e);
+ }
+ }
+
+ /**
+ * Utility method to convert a job ID to a long value for internal processing. Uses FarmHash for
+ * efficient hash generation and distribution.
+ *
+ * @param jobId The string job identifier
+ * @return A long value representing the job ID
+ */
+ public static long jobIdToLong(final String jobId) {
+
+ // Use FarmHash for good distribution and speed
+ long hashValue = Hashing.farmHashFingerprint64()
+ .hashString(jobId, StandardCharsets.UTF_8).asLong();
+
+ // Ensure the value is positive (in the upper half of the bigint range)
+ return Math.abs(hashValue);
+ }
+
+ /**
+ * Count the number of lines in the file
+ *
+ * @param dotTempFile temporary file
+ * @return the number of lines in the file
+ */
+ private Long totalLines(final Job job, final File dotTempFile) {
+
+ long totalCount;
+ try (BufferedReader reader = new BufferedReader(new FileReader(dotTempFile))) {
+ totalCount = reader.lines().count();
+ if (totalCount == 0) {
+ Logger.info(this.getClass(),
+ "No lines in CSV import file: " + dotTempFile.getName());
+ }
+ } catch (Exception e) {
+ Logger.error(this.getClass(),
+ "Error calculating total lines in CSV import file: " + e.getMessage());
+ throw new JobProcessingException(job.id(),
+ "Error calculating total lines in CSV import file", e);
+ }
+
+ return totalCount;
+ }
+
+ /**
+ * Reads and processes headers for publishing operation.
+ *
+ * @param language The target language for import
+ * @param csvreader The CSV reader containing the file data
+ * @return CsvHeaderInfo containing processed header information
+ * @throws IOException if an error occurs reading the CSV file
+ */
+ private CsvHeaderInfo readPublishHeaders(long language, CsvReader csvreader)
+ throws IOException {
+ if (language == -1 && csvreader.readHeaders()) {
+ return findLanguageColumnsInHeaders(csvreader.getHeaders());
+ }
+ return new CsvHeaderInfo(null, -1, -1);
+ }
+
+ /**
+ * Locates language-related columns in CSV headers.
+ *
+ * @param headers Array of CSV header strings
+ * @return CsvHeaderInfo containing the positions of language and country code columns
+ */
+ private CsvHeaderInfo findLanguageColumnsInHeaders(String[] headers) {
+
+ int languageCodeColumn = -1;
+ int countryCodeColumn = -1;
+
+ for (int column = 0; column < headers.length; ++column) {
+ if (headers[column].equals(LANGUAGE_CODE_HEADER)) {
+ languageCodeColumn = column;
+ }
+ if (headers[column].equals(COUNTRY_CODE_HEADER)) {
+ countryCodeColumn = column;
+ }
+ if (languageCodeColumn != -1 && countryCodeColumn != -1) {
+ break;
+ }
+ }
+
+ return new CsvHeaderInfo(headers, languageCodeColumn, countryCodeColumn);
+ }
+
+ /**
+ * Creates a CSV reader with appropriate configuration for import operations.
+ *
+ * @param reader The source reader for CSV content
+ * @return A configured CsvReader instance
+ */
+ private CsvReader createCsvReader(final Reader reader) {
+ CsvReader csvreader = new CsvReader(reader);
+ csvreader.setSafetySwitch(false);
+ return csvreader;
+ }
+
+ /**
+ * Processes CSV headers based on the specified language configuration.
+ *
+ * @param job The current import job
+ * @param language The target language for import
+ * @param csvReader The CSV reader to process headers from
+ * @return CsvHeaderInfo containing processed header information
+ * @throws IOException if an error occurs reading the CSV file
+ */
+ private CsvHeaderInfo processHeadersBasedOnLanguage(final Job job, final long language,
+ final CsvReader csvReader) throws IOException {
+ if (language != -1) {
+ validateLanguage(job, language);
+ return new CsvHeaderInfo(null, -1, -1);
+ }
+
+ return processMultilingualHeaders(job, csvReader);
+ }
+
+ /**
+ * Validates the language configuration for import operations.
+ *
+ * @param job The current import job
+ * @param language The language identifier to validate
+ */
+ private void validateLanguage(Job job, long language) {
+ if (language == 0) {
+ final var errorMessage = "Please select a valid Language.";
+ Logger.error(this, errorMessage);
+ throw new JobValidationException(job.id(), errorMessage);
+ }
+ }
+
+ /**
+ * Processes headers for multilingual content imports.
+ *
+ * @param job The current import job
+ * @param csvReader The CSV reader to process headers from
+ * @return CsvHeaderInfo containing processed multilingual header information
+ * @throws IOException if an error occurs reading the CSV file
+ */
+ private CsvHeaderInfo processMultilingualHeaders(final Job job, final CsvReader csvReader)
+ throws IOException {
+
+ if (getFields(job).length == 0) {
+ final var errorMessage =
+ "A key identifying the different Language versions of the same "
+ + "content must be defined when importing multilingual files.";
+ Logger.error(this, errorMessage);
+ throw new JobValidationException(job.id(), errorMessage);
+ }
+
+ if (!csvReader.readHeaders()) {
+ final var errorMessage = "An error occurred when attempting to read the CSV file headers.";
+ Logger.error(this, errorMessage);
+ throw new JobProcessingException(job.id(), errorMessage);
+ }
+
+ String[] headers = csvReader.getHeaders();
+ return findLanguageColumns(job, headers);
+ }
+
+ /**
+ * Locates language-related columns in CSV headers.
+ *
+ * @param headers Array of CSV header strings
+ * @return CsvHeaderInfo containing the positions of language and country code columns
+ */
+ private CsvHeaderInfo findLanguageColumns(Job job, String[] headers)
+ throws JobProcessingException {
+
+ int languageCodeColumn = -1;
+ int countryCodeColumn = -1;
+
+ for (int column = 0; column < headers.length; ++column) {
+ if (headers[column].equals(LANGUAGE_CODE_HEADER)) {
+ languageCodeColumn = column;
+ }
+ if (headers[column].equals(COUNTRY_CODE_HEADER)) {
+ countryCodeColumn = column;
+ }
+ if (languageCodeColumn != -1 && countryCodeColumn != -1) {
+ break;
+ }
+ }
+
+ validateLanguageColumns(job, languageCodeColumn, countryCodeColumn);
+ return new CsvHeaderInfo(headers, languageCodeColumn, countryCodeColumn);
+ }
+
+ /**
+ * Performs validation of language columns for multilingual imports.
+ *
+ * @param job The current import job
+ * @param languageCodeColumn The index of the language code column
+ * @param countryCodeColumn The index of the country code column
+ * @throws JobValidationException if the required language columns are not found
+ */
+ private void validateLanguageColumns(Job job, int languageCodeColumn, int countryCodeColumn)
+ throws JobProcessingException {
+ if (languageCodeColumn == -1 || countryCodeColumn == -1) {
+ final var errorMessage = "languageCode and countryCode fields are mandatory in the CSV "
+ + "file when importing multilingual content.";
+ Logger.error(this, errorMessage);
+ throw new JobValidationException(job.id(), errorMessage);
+ }
+ }
+
+ /**
+ * Container class for CSV header information, particularly for handling language-related
+ * columns in multilingual imports.
+ */
+ private static class CsvHeaderInfo {
+
+ final String[] headers;
+ final int languageCodeColumn;
+ final int countryCodeColumn;
+
+ CsvHeaderInfo(String[] headers, int languageCodeColumn, int countryCodeColumn) {
+ this.headers = headers;
+ this.languageCodeColumn = languageCodeColumn;
+ this.countryCodeColumn = countryCodeColumn;
+ }
+ }
+
+}
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/LargeFileReader.java b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/LargeFileReader.java
index a0f4025f5f66..36245a0c4ba6 100644
--- a/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/LargeFileReader.java
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/processor/impl/LargeFileReader.java
@@ -6,15 +6,13 @@
import com.dotcms.jobs.business.processor.JobProcessor;
import com.dotcms.jobs.business.processor.ProgressTracker;
import com.dotcms.jobs.business.processor.Queue;
+import com.dotcms.jobs.business.util.JobUtil;
import com.dotcms.rest.api.v1.temp.DotTempFile;
-import com.dotcms.rest.api.v1.temp.TempFileAPI;
-import com.dotmarketing.business.APILocator;
import com.dotmarketing.exception.DotRuntimeException;
import com.dotmarketing.util.Logger;
import io.vavr.control.Try;
import java.io.BufferedReader;
import java.io.FileReader;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -36,7 +34,7 @@ public void process(Job job) {
Logger.info(this.getClass(), "Processing job: " + job.id());
Map params = job.parameters();
- Optional tempFile = tempFile(params);
+ Optional tempFile = JobUtil.retrieveTempFile(job);
if (tempFile.isEmpty()) {
Logger.error(this.getClass(), "Unable to retrieve the temporary file. Quitting the job.");
throw new DotRuntimeException("Unable to retrieve the temporary file.");
@@ -181,36 +179,6 @@ Optional linesParam(Map params) {
return Optional.of(nLines);
}
- /**
- * Retrieve the temporary file from the parameters
- *
- * @param params input parameters
- * @return the temporary file
- */
- Optional tempFile(Map params) {
- // Extract parameters
- String tempFileId = (String) params.get("tempFileId");
-
- final Object requestFingerPrintRaw = params.get("requestFingerPrint");
- if (!(requestFingerPrintRaw instanceof String)) {
- Logger.error(this.getClass(),
- "Parameter 'requestFingerPrint' is required and must be a string.");
- return Optional.empty();
- }
- final String requestFingerPrint = (String) requestFingerPrintRaw;
-
- // Retrieve the temporary file
- final TempFileAPI tempFileAPI = APILocator.getTempFileAPI();
- final Optional tempFile = tempFileAPI.getTempFile(List.of(requestFingerPrint),
- tempFileId);
- if (tempFile.isEmpty()) {
- Logger.error(this.getClass(), "Temporary file not found: " + tempFileId);
- return Optional.empty();
- }
-
- return tempFile;
- }
-
/**
* Provide metadata for the job result.
* @param job The job for which to provide metadata.
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueue.java b/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueue.java
index 45cdebfabcf9..af9d434bfcb7 100644
--- a/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueue.java
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueue.java
@@ -76,6 +76,36 @@ JobPaginatedResult getCompletedJobs(String queueName, LocalDateTime startDate,
*/
JobPaginatedResult getJobs(int page, int pageSize) throws JobQueueDataException;
+ /**
+ * Retrieves a list of active jobs, meaning jobs that are currently being processed.
+ *
+ * @param page The page number (for pagination).
+ * @param pageSize The number of items per page.
+ * @return A result object containing the list of active jobs and pagination information.
+ * @throws JobQueueDataException if there's a data storage error while fetching the jobs
+ */
+ JobPaginatedResult getActiveJobs(int page, int pageSize) throws JobQueueDataException;
+
+ /**
+ * Retrieves a list of completed jobs.
+ *
+ * @param page The page number (for pagination).
+ * @param pageSize The number of items per page.
+ * @return A result object containing the list of completed jobs and pagination information.
+ * @throws JobQueueDataException if there's a data storage error while fetching the jobs
+ */
+ JobPaginatedResult getCompletedJobs(int page, int pageSize) throws JobQueueDataException;
+
+ /**
+ * Retrieves a list of canceled jobs.
+ *
+ * @param page The page number (for pagination).
+ * @param pageSize The number of items per page.
+ * @return A result object containing the list of canceled jobs and pagination information.
+ * @throws JobQueueDataException if there's a data storage error while fetching the jobs
+ */
+ JobPaginatedResult getCanceledJobs(int page, int pageSize) throws JobQueueDataException;
+
/**
* Retrieves a list of failed jobs.
*
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueueProducer.java b/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueueProducer.java
index 1596e9fb17d6..431b40fc33e5 100644
--- a/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueueProducer.java
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/queue/JobQueueProducer.java
@@ -3,6 +3,7 @@
import com.dotmarketing.util.Config;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Produces;
+import javax.inject.Named;
/**
* This class is responsible for producing the JobQueue implementation used in the application. It
@@ -22,17 +23,16 @@ public class JobQueueProducer {
*
* @return A JobQueue instance
*/
+ @Named("queueProducer")
@Produces
- @ApplicationScoped
public JobQueue produceJobQueue() {
if (JOB_QUEUE_IMPLEMENTATION_TYPE.equals("postgres")) {
return new PostgresJobQueue();
}
- throw new IllegalStateException(
- "Unknown job queue implementation type: " + JOB_QUEUE_IMPLEMENTATION_TYPE
- );
+ throw new IllegalStateException("Unknown job queue implementation type: " + JOB_QUEUE_IMPLEMENTATION_TYPE);
+
}
}
\ No newline at end of file
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/queue/PostgresJobQueue.java b/dotCMS/src/main/java/com/dotcms/jobs/business/queue/PostgresJobQueue.java
index 37bb0fa9ac1e..dfc179106563 100644
--- a/dotCMS/src/main/java/com/dotcms/jobs/business/queue/PostgresJobQueue.java
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/queue/PostgresJobQueue.java
@@ -75,7 +75,7 @@ public class PostgresJobQueue implements JobQueue {
+ "ORDER BY priority DESC, created_at ASC LIMIT 1 FOR UPDATE SKIP LOCKED) "
+ "RETURNING *";
- private static final String GET_ACTIVE_JOBS_QUERY =
+ private static final String GET_ACTIVE_JOBS_QUERY_FOR_QUEUE =
"WITH total AS (SELECT COUNT(*) AS total_count " +
" FROM job WHERE queue_name = ? AND state IN (?, ?) " +
"), " +
@@ -85,7 +85,7 @@ public class PostgresJobQueue implements JobQueue {
") " +
"SELECT p.*, t.total_count FROM total t LEFT JOIN paginated_data p ON true";
- private static final String GET_COMPLETED_JOBS_QUERY =
+ private static final String GET_COMPLETED_JOBS_QUERY_FOR_QUEUE =
"WITH total AS (SELECT COUNT(*) AS total_count " +
" FROM job WHERE queue_name = ? AND state = ? AND completed_at BETWEEN ? AND ? " +
"), " +
@@ -95,15 +95,15 @@ public class PostgresJobQueue implements JobQueue {
") " +
"SELECT p.*, t.total_count FROM total t LEFT JOIN paginated_data p ON true";
- private static final String GET_FAILED_JOBS_QUERY =
+ private static final String GET_JOBS_QUERY_BY_STATE =
"WITH total AS (" +
" SELECT COUNT(*) AS total_count FROM job " +
- " WHERE state = ? " +
+ " WHERE state IN $??$ " +
"), " +
"paginated_data AS (" +
" SELECT * " +
- " FROM job WHERE state = ? " +
- " ORDER BY updated_at DESC " +
+ " FROM job WHERE state IN $??$ " +
+ " ORDER BY $ORDER_BY$ DESC " +
" LIMIT ? OFFSET ? " +
") " +
"SELECT p.*, t.total_count " +
@@ -152,6 +152,9 @@ public class PostgresJobQueue implements JobQueue {
private static final String COLUMN_TOTAL_COUNT = "total_count";
+ private static final String REPLACE_TOKEN_PARAMETERS = "$??$";
+ private static final String REPLACE_TOKEN_ORDER_BY = "$ORDER_BY$";
+
/**
* Jackson mapper configuration and lazy initialized instance.
*/
@@ -246,7 +249,7 @@ public JobPaginatedResult getActiveJobs(final String queueName, final int page,
try {
DotConnect dc = new DotConnect();
- dc.setSQL(GET_ACTIVE_JOBS_QUERY);
+ dc.setSQL(GET_ACTIVE_JOBS_QUERY_FOR_QUEUE);
dc.addParam(queueName);
dc.addParam(JobState.PENDING.name());
dc.addParam(JobState.RUNNING.name());
@@ -258,8 +261,10 @@ public JobPaginatedResult getActiveJobs(final String queueName, final int page,
return jobPaginatedResult(page, pageSize, dc);
} catch (DotDataException e) {
- Logger.error(this, "Database error while fetching active jobs", e);
- throw new JobQueueDataException("Database error while fetching active jobs", e);
+ Logger.error(this,
+ "Database error while fetching active jobs by queue", e);
+ throw new JobQueueDataException(
+ "Database error while fetching active jobs by queue", e);
}
}
@@ -271,7 +276,7 @@ public JobPaginatedResult getCompletedJobs(final String queueName,
try {
DotConnect dc = new DotConnect();
- dc.setSQL(GET_COMPLETED_JOBS_QUERY);
+ dc.setSQL(GET_COMPLETED_JOBS_QUERY_FOR_QUEUE);
dc.addParam(queueName);
dc.addParam(JobState.COMPLETED.name());
dc.addParam(Timestamp.valueOf(startDate));
@@ -285,8 +290,10 @@ public JobPaginatedResult getCompletedJobs(final String queueName,
return jobPaginatedResult(page, pageSize, dc);
} catch (DotDataException e) {
- Logger.error(this, "Database error while fetching completed jobs", e);
- throw new JobQueueDataException("Database error while fetching completed jobs", e);
+ Logger.error(this,
+ "Database error while fetching completed jobs by queue", e);
+ throw new JobQueueDataException(
+ "Database error while fetching completed jobs by queue", e);
}
}
@@ -307,13 +314,92 @@ public JobPaginatedResult getJobs(final int page, final int pageSize)
}
}
+ @Override
+ public JobPaginatedResult getActiveJobs(final int page, final int pageSize)
+ throws JobQueueDataException {
+
+ try {
+
+ var query = GET_JOBS_QUERY_BY_STATE
+ .replace(REPLACE_TOKEN_PARAMETERS, "(?, ?)")
+ .replace(REPLACE_TOKEN_ORDER_BY, "created_at");
+
+ DotConnect dc = new DotConnect();
+ dc.setSQL(query);
+ dc.addParam(JobState.PENDING.name());
+ dc.addParam(JobState.RUNNING.name());
+ dc.addParam(JobState.PENDING.name()); // Repeated for paginated_data CTE
+ dc.addParam(JobState.RUNNING.name());
+ dc.addParam(pageSize);
+ dc.addParam((page - 1) * pageSize);
+
+ return jobPaginatedResult(page, pageSize, dc);
+ } catch (DotDataException e) {
+ Logger.error(this, "Database error while fetching active jobs", e);
+ throw new JobQueueDataException("Database error while fetching active jobs", e);
+ }
+ }
+
+ @Override
+ public JobPaginatedResult getCompletedJobs(final int page, final int pageSize)
+ throws JobQueueDataException {
+
+ try {
+
+ var query = GET_JOBS_QUERY_BY_STATE
+ .replace(REPLACE_TOKEN_PARAMETERS, "(?)")
+ .replace(REPLACE_TOKEN_ORDER_BY, "completed_at");
+
+ DotConnect dc = new DotConnect();
+ dc.setSQL(query);
+ dc.addParam(JobState.COMPLETED.name());
+ dc.addParam(JobState.COMPLETED.name()); // Repeated for paginated_data CTE
+ dc.addParam(pageSize);
+ dc.addParam((page - 1) * pageSize);
+
+ return jobPaginatedResult(page, pageSize, dc);
+ } catch (DotDataException e) {
+ Logger.error(this, "Database error while fetching completed jobs", e);
+ throw new JobQueueDataException("Database error while fetching completed jobs", e);
+ }
+ }
+
+ @Override
+ public JobPaginatedResult getCanceledJobs(final int page, final int pageSize)
+ throws JobQueueDataException {
+
+ try {
+
+ var query = GET_JOBS_QUERY_BY_STATE
+ .replace(REPLACE_TOKEN_PARAMETERS, "(?)")
+ .replace(REPLACE_TOKEN_ORDER_BY, "completed_at");
+
+ DotConnect dc = new DotConnect();
+ dc.setSQL(query);
+ dc.addParam(JobState.CANCELED.name());
+ dc.addParam(JobState.CANCELED.name()); // Repeated for paginated_data CTE
+ dc.addParam(pageSize);
+ dc.addParam((page - 1) * pageSize);
+
+ return jobPaginatedResult(page, pageSize, dc);
+ } catch (DotDataException e) {
+ Logger.error(this, "Database error while fetching cancelled jobs", e);
+ throw new JobQueueDataException("Database error while fetching cancelled jobs", e);
+ }
+ }
+
@Override
public JobPaginatedResult getFailedJobs(final int page, final int pageSize)
throws JobQueueDataException {
try {
+
+ var query = GET_JOBS_QUERY_BY_STATE
+ .replace(REPLACE_TOKEN_PARAMETERS, "(?)")
+ .replace(REPLACE_TOKEN_ORDER_BY, "updated_at");
+
DotConnect dc = new DotConnect();
- dc.setSQL(GET_FAILED_JOBS_QUERY);
+ dc.setSQL(query);
dc.addParam(JobState.FAILED.name());
dc.addParam(JobState.FAILED.name()); // Repeated for paginated_data CTE
dc.addParam(pageSize);
diff --git a/dotCMS/src/main/java/com/dotcms/jobs/business/util/JobUtil.java b/dotCMS/src/main/java/com/dotcms/jobs/business/util/JobUtil.java
new file mode 100644
index 000000000000..6a6ec3650e4e
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/jobs/business/util/JobUtil.java
@@ -0,0 +1,105 @@
+package com.dotcms.jobs.business.util;
+
+import com.dotcms.api.web.HttpServletRequestThreadLocal;
+import com.dotcms.jobs.business.job.Job;
+import com.dotcms.mock.request.FakeHttpRequest;
+import com.dotcms.mock.request.MockHeaderRequest;
+import com.dotcms.mock.request.MockSessionRequest;
+import com.dotcms.rest.api.v1.temp.DotTempFile;
+import com.dotcms.rest.api.v1.temp.TempFileAPI;
+import com.dotmarketing.business.APILocator;
+import com.dotmarketing.util.Logger;
+import com.dotmarketing.util.UtilMethods;
+import com.dotmarketing.util.WebKeys;
+import com.liferay.portal.model.User;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * Utility class for job-related operations.
+ */
+public class JobUtil {
+
+ private JobUtil() {
+ throw new IllegalStateException("Utility class");
+ }
+
+ /**
+ * Retrieves the temporary file associated with the given job.
+ *
+ * @param job The job containing the temporary file information in its parameters.
+ * @return An Optional containing the DotTempFile if found, or an empty Optional if not found or
+ * if an error occurs.
+ */
+ public static Optional retrieveTempFile(final Job job) {
+
+ if (job == null) {
+ Logger.error(JobUtil.class, "Job cannot be null");
+ return Optional.empty();
+ }
+
+ Map params = job.parameters();
+ if (params == null) {
+ Logger.error(JobUtil.class, "Job parameters cannot be null");
+ return Optional.empty();
+ }
+
+ // Extract parameters
+ String tempFileId = (String) params.get("tempFileId");
+ if (tempFileId == null) {
+ Logger.error(JobUtil.class, "Parameter 'tempFileId' is required");
+ return Optional.empty();
+ }
+
+ final Object requestFingerPrintRaw = params.get("requestFingerPrint");
+ if (!(requestFingerPrintRaw instanceof String)) {
+ Logger.error(JobUtil.class,
+ "Parameter 'requestFingerPrint' is required and must be a string.");
+ return Optional.empty();
+ }
+ final String requestFingerPrint = (String) requestFingerPrintRaw;
+
+ // Retrieve the temporary file
+ final TempFileAPI tempFileAPI = APILocator.getTempFileAPI();
+ final Optional tempFile = tempFileAPI.getTempFile(
+ List.of(requestFingerPrint), tempFileId
+ );
+ if (tempFile.isEmpty()) {
+ Logger.error(JobUtil.class, "Temporary file not found: " + tempFileId);
+ }
+
+ return tempFile;
+ }
+
+ /**
+ * Utility method to create or retrieve an HttpServletRequest when needed from job processors.
+ * Uses thread-local request if available, otherwise creates a mock request with the specified
+ * user and site information.
+ *
+ * @param user The user performing the import
+ * @param siteName The name of the site for the import
+ * @return An HttpServletRequest instance configured for the import operation
+ */
+ public static HttpServletRequest generateMockRequest(final User user, final String siteName) {
+
+ if (null != HttpServletRequestThreadLocal.INSTANCE.getRequest()) {
+ return HttpServletRequestThreadLocal.INSTANCE.getRequest();
+ }
+
+ final HttpServletRequest requestProxy = new MockSessionRequest(
+ new MockHeaderRequest(
+ new FakeHttpRequest(siteName, "/").request(),
+ "referer",
+ "https://" + siteName + "/fakeRefer")
+ .request());
+ requestProxy.setAttribute(WebKeys.CMS_USER, user);
+ requestProxy.getSession().setAttribute(WebKeys.CMS_USER, user);
+ requestProxy.setAttribute(com.liferay.portal.util.WebKeys.USER_ID,
+ UtilMethods.extractUserIdOrNull(user));
+
+ return requestProxy;
+ }
+
+}
diff --git a/dotCMS/src/main/java/com/dotcms/rendering/velocity/viewtools/content/BinaryMap.java b/dotCMS/src/main/java/com/dotcms/rendering/velocity/viewtools/content/BinaryMap.java
index ea132e8392e3..68148e147cd4 100644
--- a/dotCMS/src/main/java/com/dotcms/rendering/velocity/viewtools/content/BinaryMap.java
+++ b/dotCMS/src/main/java/com/dotcms/rendering/velocity/viewtools/content/BinaryMap.java
@@ -1,5 +1,6 @@
package com.dotcms.rendering.velocity.viewtools.content;
+import com.fasterxml.jackson.annotation.JsonIgnore;
import java.io.File;
import java.io.Serializable;
import java.util.Map;
@@ -254,9 +255,10 @@ public String getThumbnailUri(Integer width, Integer height, String background){
}
/**
- * This is the underneath Java File. Becareful when working with this object as you can manipulate it.
+ * This is the underneath Java File. Be careful when working with this object as you can manipulate it.
* @return the file
*/
+ @JsonIgnore
public File getFile() {
return Sneaky.sneak(()->content.getBinary(field.variable()));
}
diff --git a/dotCMS/src/main/java/com/dotcms/rest/CountView.java b/dotCMS/src/main/java/com/dotcms/rest/CountView.java
new file mode 100644
index 000000000000..7ae65cf1ebc8
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/rest/CountView.java
@@ -0,0 +1,18 @@
+package com.dotcms.rest;
+
+/**
+ * This class encapsulates a single count
+ * @author jsanca
+ */
+public class CountView {
+
+ private int count;
+
+ public CountView(final int count) {
+ this.count = count;
+ }
+
+ public int getCount() {
+ return count;
+ }
+}
diff --git a/dotCMS/src/main/java/com/dotcms/rest/ResponseEntityCountView.java b/dotCMS/src/main/java/com/dotcms/rest/ResponseEntityCountView.java
new file mode 100644
index 000000000000..b12a8ecf7b90
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/rest/ResponseEntityCountView.java
@@ -0,0 +1,11 @@
+package com.dotcms.rest;
+
+/**
+ * This class encapsulates the {@link javax.ws.rs.core.Response} object to include the expected Integer and related
+ * @author jsanca
+ */
+public class ResponseEntityCountView extends ResponseEntityView {
+ public ResponseEntityCountView(final CountView entity) {
+ super(entity);
+ }
+}
diff --git a/dotCMS/src/main/java/com/dotcms/rest/api/v1/analytics/content/ContentAnalyticsResource.java b/dotCMS/src/main/java/com/dotcms/rest/api/v1/analytics/content/ContentAnalyticsResource.java
index f966d2653433..ca36973aad2c 100644
--- a/dotCMS/src/main/java/com/dotcms/rest/api/v1/analytics/content/ContentAnalyticsResource.java
+++ b/dotCMS/src/main/java/com/dotcms/rest/api/v1/analytics/content/ContentAnalyticsResource.java
@@ -5,13 +5,11 @@
import com.dotcms.analytics.model.ResultSetItem;
import com.dotcms.analytics.track.collectors.WebEventsCollectorServiceFactory;
import com.dotcms.analytics.track.matchers.UserCustomDefinedRequestMatcher;
-import com.dotcms.cdi.CDIUtils;
import com.dotcms.rest.InitDataObject;
import com.dotcms.rest.ResponseEntityStringView;
import com.dotcms.rest.WebResource;
import com.dotcms.rest.annotation.NoCache;
import com.dotcms.util.DotPreconditions;
-import com.dotmarketing.business.APILocator;
import com.dotmarketing.util.Logger;
import com.dotmarketing.util.UUIDUtil;
import com.google.common.annotations.VisibleForTesting;
@@ -21,8 +19,11 @@
import io.swagger.v3.oas.annotations.media.ExampleObject;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
-import org.glassfish.jersey.server.JSONP;
-
+import java.io.Serializable;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.Consumes;
@@ -31,12 +32,7 @@
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
-import java.io.Serializable;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
+import org.glassfish.jersey.server.JSONP;
/**
* Resource class that exposes endpoints to query content analytics data.
@@ -47,6 +43,7 @@
* @author Jose Castro
* @since Sep 13th, 2024
*/
+
@Path("/v1/analytics/content")
@Tag(name = "Content Analytics",
description = "Endpoints that exposes information related to how dotCMS content is accessed and interacted with by users.")
@@ -57,13 +54,7 @@ public class ContentAnalyticsResource {
private final WebResource webResource;
private final ContentAnalyticsAPI contentAnalyticsAPI;
- @SuppressWarnings("unused")
- public ContentAnalyticsResource() {
- this(CDIUtils.getBean(ContentAnalyticsAPI.class).orElseGet(APILocator::getContentAnalyticsAPI));
- }
-
- //@Inject
- @VisibleForTesting
+ @Inject
public ContentAnalyticsResource(final ContentAnalyticsAPI contentAnalyticsAPI) {
this(new WebResource(), contentAnalyticsAPI);
}
@@ -98,7 +89,7 @@ public ContentAnalyticsResource(final WebResource webResource,
" \"measures\": [\n" +
" \"request.count\"\n" +
" ],\n" +
- " \"orders\": \"request.count DESC\",\n" +
+ " \"order\": \"request.count DESC\",\n" +
" \"dimensions\": [\n" +
" \"request.url\",\n" +
" \"request.pageId\",\n" +
diff --git a/dotCMS/src/main/java/com/dotcms/rest/api/v1/content/ContentReferenceView.java b/dotCMS/src/main/java/com/dotcms/rest/api/v1/content/ContentReferenceView.java
new file mode 100644
index 000000000000..8b7c0e4d99b5
--- /dev/null
+++ b/dotCMS/src/main/java/com/dotcms/rest/api/v1/content/ContentReferenceView.java
@@ -0,0 +1,36 @@
+package com.dotcms.rest.api.v1.content;
+
+import com.dotmarketing.portlets.containers.model.Container;
+import com.dotmarketing.portlets.containers.model.ContainerView;
+import com.dotmarketing.portlets.htmlpageasset.model.IHTMLPage;
+
+/**
+ * This class is used to represent a reference to a content item.
+ * @author
+ */
+public class ContentReferenceView {
+
+ private final IHTMLPage page;
+ private final ContainerView container;
+ private final String personaName;
+
+ public ContentReferenceView(final IHTMLPage page,
+ final ContainerView container,
+ final String personaName) {
+ this.page = page;
+ this.container = container;
+ this.personaName = personaName;
+ }
+
+ public IHTMLPage getPage() {
+ return page;
+ }
+
+ public ContainerView getContainer() {
+ return container;
+ }
+
+ public String getPersonaName() {
+ return personaName;
+ }
+}
diff --git a/dotCMS/src/main/java/com/dotcms/rest/api/v1/content/ContentResource.java b/dotCMS/src/main/java/com/dotcms/rest/api/v1/content/ContentResource.java
index 4c32c168a307..7a237dedf344 100644
--- a/dotCMS/src/main/java/com/dotcms/rest/api/v1/content/ContentResource.java
+++ b/dotCMS/src/main/java/com/dotcms/rest/api/v1/content/ContentResource.java
@@ -6,9 +6,11 @@
import com.dotcms.mock.response.MockHttpResponse;
import com.dotcms.rendering.velocity.viewtools.content.util.ContentUtils;
import com.dotcms.rest.AnonymousAccess;
+import com.dotcms.rest.CountView;
import com.dotcms.rest.InitDataObject;
import com.dotcms.rest.MapToContentletPopulator;
import com.dotcms.rest.ResponseEntityContentletView;
+import com.dotcms.rest.ResponseEntityCountView;
import com.dotcms.rest.ResponseEntityView;
import com.dotcms.rest.WebResource;
import com.dotcms.rest.annotation.NoCache;
@@ -26,12 +28,15 @@
import com.dotmarketing.exception.DotDataException;
import com.dotmarketing.exception.DotSecurityException;
import com.dotmarketing.portlets.categories.model.Category;
+import com.dotmarketing.portlets.containers.model.Container;
+import com.dotmarketing.portlets.containers.model.ContainerView;
import com.dotmarketing.portlets.contentlet.business.ContentletAPI;
import com.dotmarketing.portlets.contentlet.business.DotContentletValidationException;
import com.dotmarketing.portlets.contentlet.model.Contentlet;
import com.dotmarketing.portlets.contentlet.model.ContentletVersionInfo;
import com.dotmarketing.portlets.contentlet.model.IndexPolicy;
import com.dotmarketing.portlets.contentlet.transform.DotTransformerBuilder;
+import com.dotmarketing.portlets.htmlpageasset.model.IHTMLPage;
import com.dotmarketing.portlets.languagesmanager.model.Language;
import com.dotmarketing.portlets.structure.model.ContentletRelationships;
import com.dotmarketing.portlets.structure.model.Relationship;
@@ -50,14 +55,8 @@
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.vavr.Lazy;
import io.vavr.control.Try;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.function.LongSupplier;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
+import org.glassfish.jersey.server.JSONP;
+
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.Consumes;
@@ -72,7 +71,15 @@
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
-import org.glassfish.jersey.server.JSONP;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.LongSupplier;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
/**
* Version 1 of the Content resource, to interact and retrieve contentlets
@@ -84,6 +91,7 @@ public class ContentResource {
private final WebResource webResource;
private final ContentletAPI contentletAPI;
private final IdentifierAPI identifierAPI;
+ private final LanguageWebAPI languageWebAPI;
private final Lazy isDefaultContentToDefaultLanguageEnabled = Lazy.of(
() -> Config.getBooleanProperty("DEFAULT_CONTENT_TO_DEFAULT_LANGUAGE", false));
@@ -93,17 +101,20 @@ public ContentResource() {
this(new WebResource(),
APILocator.getContentletAPI(),
- APILocator.getIdentifierAPI());
+ APILocator.getIdentifierAPI(),
+ WebAPILocator.getLanguageWebAPI());
}
@VisibleForTesting
public ContentResource(final WebResource webResource,
final ContentletAPI contentletAPI,
- final IdentifierAPI identifierAPI) {
+ final IdentifierAPI identifierAPI,
+ final LanguageWebAPI languageWebAPI) {
this.webResource = webResource;
this.contentletAPI = contentletAPI;
this.identifierAPI = identifierAPI;
+ this.languageWebAPI = languageWebAPI;
}
/**
@@ -139,7 +150,7 @@ public final ResponseEntityContentletView saveDraft(@Context final HttpServletRe
final long languageId = LanguageUtil.getLanguageId(language);
final PageMode mode = PageMode.get(request);
final Contentlet contentlet = this.getContentlet(inode, identifier, languageId,
- () -> WebAPILocator.getLanguageWebAPI().getLanguage(request).getId(), contentForm,
+ () -> this.languageWebAPI.getLanguage(request).getId(), contentForm,
initDataObject.getUser(), mode);
if (UtilMethods.isSet(indexPolicy)) {
contentlet.setIndexPolicy(IndexPolicy.parseIndexPolicy(indexPolicy));
@@ -284,7 +295,6 @@ public Response getContent(@Context HttpServletRequest request,
Logger.debug(this, () -> "Finding the contentlet: " + inodeOrIdentifier);
- final LanguageWebAPI languageWebAPI = WebAPILocator.getLanguageWebAPI();
final LongSupplier sessionLanguageSupplier = ()-> languageWebAPI.getLanguage(request).getId();
final PageMode mode = PageMode.get(request);
final long testLangId = LanguageUtil.getLanguageId(language);
@@ -301,6 +311,84 @@ public Response getContent(@Context HttpServletRequest request,
WorkflowHelper.getInstance().contentletToMap(contentlet))).build();
}
+ /**
+ * Retrieves the count of a Contentlet based on the identifier
+ * If the contentlet exist or not, does not matter, the count will be returned
+ *
+ * @param request The current {@link HttpServletRequest} instance.
+ * @param response The current {@link HttpServletResponse} instance.
+ *
+ * @return The {@link ResponseEntityCountView}
+ */
+ @GET
+ @Path("/{identifier}/references/count")
+ @Produces(MediaType.APPLICATION_JSON)
+ public ResponseEntityCountView getAllContentletReferencesCount(
+ @Context HttpServletRequest request,
+ @Context final HttpServletResponse response,
+ @PathParam("identifier") final String identifier
+ ) throws DotDataException {
+
+ new WebResource.InitBuilder(this.webResource)
+ .requestAndResponse(request, response)
+ .requiredAnonAccess(AnonymousAccess.READ)
+ .init();
+
+ Logger.debug(this, () -> "Finding the counts for contentlet id: " + identifier);
+ final Optional count = this.contentletAPI.getAllContentletReferencesCount(identifier);
+
+ if (!count.isPresent()) {
+ throw new DoesNotExistException("The contentlet with identifier " + identifier + " does not exist");
+ }
+
+ return new ResponseEntityCountView(new CountView(count.get()));
+ }
+
+ /**
+ * Retrieves the references of a Contentlet based on the identifier
+ * If the contentlet does not exist, 404
+ *
+ * @param request The current {@link HttpServletRequest} instance.
+ * @param response The current {@link HttpServletResponse} instance.
+ *
+ * @return The {@link ResponseEntityView>}
+ */
+ @GET
+ @Path("/{inodeOrIdentifier}/references")
+ @Produces(MediaType.APPLICATION_JSON)
+ public ResponseEntityView> getContentletReferences(
+ @Context HttpServletRequest request,
+ @Context final HttpServletResponse response,
+ @PathParam("inodeOrIdentifier") final String inodeOrIdentifier,
+ @DefaultValue("") @QueryParam("language") final String language
+ ) throws DotDataException, DotSecurityException {
+
+ final User user = new WebResource.InitBuilder(this.webResource)
+ .requestAndResponse(request, response)
+ .requiredAnonAccess(AnonymousAccess.READ)
+ .init().getUser();
+
+ Logger.debug(this, () -> "Finding the references for contentlet id: " + inodeOrIdentifier);
+
+ final LongSupplier sessionLanguageSupplier = ()-> languageWebAPI.getLanguage(request).getId();
+ final PageMode mode = PageMode.get(request);
+ final long testLangId = LanguageUtil.getLanguageId(language);
+ final long languageId = testLangId <=0 ? sessionLanguageSupplier.getAsLong() : testLangId;
+
+ final Contentlet contentlet = this.resolveContentletOrFallBack(inodeOrIdentifier, mode, languageId, user);
+
+ final List> references = this.contentletAPI.getContentletReferences(contentlet, user, mode.respectAnonPerms);
+ final List contentReferenceViews = Objects.nonNull(references)?
+ references.stream()
+ .map(reference -> new ContentReferenceView(
+ (IHTMLPage) reference.get("page"),
+ new ContainerView((Container) reference.get("container")),
+ (String) reference.get("personaName")))
+ .collect(Collectors.toList()):
+ List.of();
+ return new ResponseEntityView<>(contentReferenceViews);
+ }
+
@GET
@Path("/_canlock/{inodeOrIdentifier}")
@Produces(MediaType.APPLICATION_JSON)
@@ -317,7 +405,7 @@ public Response canLockContent(@Context HttpServletRequest request, @Context fin
final PageMode mode = PageMode.get(request);
final long testLangId = LanguageUtil.getLanguageId(language);
- final long languageId = testLangId <=0 ? WebAPILocator.getLanguageWebAPI().getLanguage(request).getId() : testLangId;
+ final long languageId = testLangId <=0 ? this.languageWebAPI.getLanguage(request).getId() : testLangId;
final Contentlet contentlet = this.resolveContentletOrFallBack(inodeOrIdentifier, mode, languageId, user);
@@ -463,7 +551,7 @@ public Response pullRelated(@Context final HttpServletRequest request,
", limit: " + pullRelatedForm.getLimit() + ", offset: " + pullRelatedForm.getOffset() + ", orderby: " + pullRelatedForm.getOrderBy());
final User user = initData.getUser();
- final Language language = WebAPILocator.getLanguageWebAPI().getLanguage(request);
+ final Language language = this.languageWebAPI.getLanguage(request);
final long langId = UtilMethods.isSet(pullRelatedForm.getCondition())
&& pullRelatedForm.getCondition().contains("languageId") ? -1 : language.getId();
final String tmDate = request.getSession (false) != null?
@@ -500,4 +588,7 @@ public Response pullRelated(@Context final HttpServletRequest request,
Logger.debug(this, ()-> "The field:" + pullRelatedForm.getFieldVariable() + " is not a relationship");
throw new IllegalArgumentException("The field:" + pullRelatedForm.getFieldVariable() + " is not a relationship");
}
+
+
+
}
diff --git a/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobParams.java b/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobParams.java
index 16737ceae606..f95c7e606373 100644
--- a/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobParams.java
+++ b/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobParams.java
@@ -25,7 +25,7 @@ public class JobParams {
private String jsonParams;
@FormDataParam("params")
- private Map params;
+ private Map params;
public InputStream getFileInputStream() {
return fileInputStream;
@@ -47,17 +47,14 @@ public void setJsonParams(String jsonParams) {
this.jsonParams = jsonParams;
}
- public Map getParams() throws JsonProcessingException {
- if (null == params) {
- if (null == jsonParams){
- throw new IllegalArgumentException("Job Params must be passed as a json object in the params field.");
- }
+ public Map getParams() throws JsonProcessingException {
+ if (null == params && (null != jsonParams && !jsonParams.isEmpty())) {
params = new ObjectMapper().readValue(jsonParams, Map.class);
}
return params;
}
- public void setParams(Map params) {
+ public void setParams(Map params) {
this.params = params;
}
diff --git a/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueHelper.java b/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueHelper.java
index cf990ad0fac9..1902207ce186 100644
--- a/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueHelper.java
+++ b/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueHelper.java
@@ -12,11 +12,13 @@
import com.dotcms.rest.api.v1.temp.DotTempFile;
import com.dotcms.rest.api.v1.temp.TempFileAPI;
import com.dotmarketing.business.APILocator;
+import com.dotmarketing.business.web.WebAPILocator;
import com.dotmarketing.exception.DoesNotExistException;
import com.dotmarketing.exception.DotDataException;
import com.dotmarketing.util.Logger;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.google.common.annotations.VisibleForTesting;
+import com.liferay.portal.model.User;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.time.format.DateTimeFormatter;
@@ -114,24 +116,81 @@ public JobQueueHelper(JobQueueManagerAPI jobQueueManagerAPI, JobProcessorScanner
*/
@VisibleForTesting
void registerProcessor(final String queueName, final Class processor){
- jobQueueManagerAPI.registerProcessor(queueName.toLowerCase(), processor);
+ jobQueueManagerAPI.registerProcessor(queueName, processor);
}
/**
- * creates a job
- * @param queueName
- * @param form
- * @return jobId
- * @throws JsonProcessingException
- * @throws DotDataException
+ * Creates a job
+ *
+ * @param queueName The name of the queue
+ * @param form The request form with the job parameters
+ * @param user The user requesting to create the job
+ * @param request The request object
+ * @return jobId The ID of the created job
+ * @throws JsonProcessingException If there is an error processing the request form parameters
+ * @throws DotDataException If there is an error creating the job
*/
- String createJob(String queueName, JobParams form, HttpServletRequest request)
- throws JsonProcessingException, DotDataException {
+ String createJob(final String queueName, final JobParams form, final User user,
+ final HttpServletRequest request) throws JsonProcessingException, DotDataException {
+
+ final HashMap in;
+
+ final var parameters = form.getParams();
+ if (parameters != null) {
+ in = new HashMap<>(parameters);
+ } else {
+ in = new HashMap<>();
+ }
- final HashMap in = new HashMap<>(form.getParams());
handleUploadIfPresent(form, in, request);
+ return createJob(queueName, in, user, request);
+ }
+
+ /**
+ * Creates a job with the given parameters
+ *
+ * @param queueName The name of the queue
+ * @param parameters The job parameters
+ * @param user The user requesting to create the job
+ * @param request The request object
+ * @return jobId The ID of the created job
+ * @throws DotDataException If there is an error creating the job
+ */
+ String createJob(final String queueName, final Map parameters, final User user,
+ final HttpServletRequest request) throws DotDataException {
+
+ final HashMap in;
+ if (parameters != null) {
+ in = new HashMap<>(parameters);
+ } else {
+ in = new HashMap<>();
+ }
+ return createJob(queueName, in, user, request);
+ }
+
+ /**
+ * Creates a job with the given parameters
+ *
+ * @param queueName The name of the queue
+ * @param parameters The job parameters
+ * @param user The user requesting to create the job
+ * @param request The request object
+ * @return jobId The ID of the created job
+ * @throws DotDataException If there is an error creating the job
+ */
+ private String createJob(final String queueName, final HashMap parameters,
+ final User user, final HttpServletRequest request) throws DotDataException {
+
+ // Get the current host and include it in the job params
+ final var currentHost = WebAPILocator.getHostWebAPI().getCurrentHostNoThrow(request);
+ parameters.put("siteName", currentHost.getHostname());
+ parameters.put("siteIdentifier", currentHost.getIdentifier());
+
+ // Including the user id in the job params
+ parameters.put("userId", user.getUserId());
+
try {
- return jobQueueManagerAPI.createJob(queueName.toLowerCase(), Map.copyOf(in));
+ return jobQueueManagerAPI.createJob(queueName, Map.copyOf(parameters));
} catch (JobProcessorNotFoundException e) {
Logger.error(this.getClass(), "Error creating job", e);
throw new DoesNotExistException(e.getMessage());
@@ -179,25 +238,41 @@ void watchJob(String jobId, Consumer watcher) {
* @return JobPaginatedResult
* @throws DotDataException if there's an error fetching the jobs
*/
+ JobPaginatedResult getActiveJobs(String queueName, int page, int pageSize) {
+ try {
+ return jobQueueManagerAPI.getActiveJobs(queueName, page, pageSize);
+ } catch (JobQueueDataException e) {
+ Logger.error(this.getClass(), "Error fetching active jobs", e);
+ }
+ return JobPaginatedResult.builder().build();
+ }
+
+ /**
+ * Retrieves a list of jobs.
+ *
+ * @param page The page number
+ * @param pageSize The number of jobs per page
+ * @return A result object containing the list of jobs and pagination information.
+ */
JobPaginatedResult getJobs(int page, int pageSize) {
try {
return jobQueueManagerAPI.getJobs(page, pageSize);
- } catch (DotDataException e){
+ } catch (DotDataException e) {
Logger.error(this.getClass(), "Error fetching jobs", e);
}
return JobPaginatedResult.builder().build();
}
/**
- * Retrieves a list of jobs.
- * @param page The page number
+ * Retrieves a list of active jobs, meaning jobs that are currently being processed.
+ *
+ * @param page The page number
* @param pageSize The number of jobs per page
- * @return JobPaginatedResult
- * @throws DotDataException if there's an error fetching the jobs
+ * @return A result object containing the list of active jobs and pagination information.
*/
- JobPaginatedResult getActiveJobs(String queueName, int page, int pageSize) {
+ JobPaginatedResult getActiveJobs(int page, int pageSize) {
try {
- return jobQueueManagerAPI.getActiveJobs(queueName.toLowerCase(), page, pageSize);
+ return jobQueueManagerAPI.getActiveJobs(page, pageSize);
} catch (JobQueueDataException e) {
Logger.error(this.getClass(), "Error fetching active jobs", e);
}
@@ -205,11 +280,43 @@ JobPaginatedResult getActiveJobs(String queueName, int page, int pageSize) {
}
/**
- * Retrieves a list of completed jobs for a specific queue within a date range.
+ * Retrieves a list of completed jobs
+ *
+ * @param page The page number
+ * @param pageSize The number of jobs per page
+ * @return A result object containing the list of completed jobs and pagination information.
+ */
+ JobPaginatedResult getCompletedJobs(int page, int pageSize) {
+ try {
+ return jobQueueManagerAPI.getCompletedJobs(page, pageSize);
+ } catch (JobQueueDataException e) {
+ Logger.error(this.getClass(), "Error fetching completed jobs", e);
+ }
+ return JobPaginatedResult.builder().build();
+ }
+
+ /**
+ * Retrieves a list of canceled jobs
+ *
+ * @param page The page number
+ * @param pageSize The number of jobs per page
+ * @return A result object containing the list of canceled jobs and pagination information.
+ */
+ JobPaginatedResult getCanceledJobs(int page, int pageSize) {
+ try {
+ return jobQueueManagerAPI.getCanceledJobs(page, pageSize);
+ } catch (JobQueueDataException e) {
+ Logger.error(this.getClass(), "Error fetching canceled jobs", e);
+ }
+ return JobPaginatedResult.builder().build();
+ }
+
+ /**
+ * Retrieves a list of failed jobs
+ *
* @param page The page number
* @param pageSize The number of jobs per page
* @return A result object containing the list of completed jobs and pagination information.
- * @throws JobQueueDataException if there's an error fetching the jobs
*/
JobPaginatedResult getFailedJobs(int page, int pageSize) {
try {
@@ -217,7 +324,7 @@ JobPaginatedResult getFailedJobs(int page, int pageSize) {
} catch (JobQueueDataException e) {
Logger.error(this.getClass(), "Error fetching failed jobs", e);
}
- return JobPaginatedResult.builder().build();
+ return JobPaginatedResult.builder().build();
}
/**
diff --git a/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueResource.java b/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueResource.java
index fc15b93c9714..c298d24d50a6 100644
--- a/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueResource.java
+++ b/dotCMS/src/main/java/com/dotcms/rest/api/v1/job/JobQueueResource.java
@@ -1,6 +1,5 @@
package com.dotcms.rest.api.v1.job;
-import com.dotcms.cdi.CDIUtils;
import com.dotcms.jobs.business.job.Job;
import com.dotcms.jobs.business.job.JobPaginatedResult;
import com.dotcms.rest.ResponseEntityView;
@@ -14,6 +13,7 @@
import java.io.IOException;
import java.util.Map;
import java.util.Set;
+import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.BeanParam;
import javax.ws.rs.Consumes;
@@ -26,7 +26,6 @@
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
import org.glassfish.jersey.media.sse.EventOutput;
import org.glassfish.jersey.media.sse.OutboundEvent;
import org.glassfish.jersey.media.sse.SseFeature;
@@ -38,8 +37,9 @@ public class JobQueueResource {
private final JobQueueHelper helper;
- public JobQueueResource() {
- this(new WebResource(), CDIUtils.getBean(JobQueueHelper.class).orElseThrow(()->new IllegalStateException("JobQueueHelper Bean not found")));
+ @Inject
+ public JobQueueResource(final JobQueueHelper helper) {
+ this(new WebResource(), helper);
}
@VisibleForTesting
@@ -52,118 +52,108 @@ public JobQueueResource(WebResource webResource, JobQueueHelper helper) {
@Path("/{queueName}")
@Consumes(MediaType.MULTIPART_FORM_DATA)
@Produces(MediaType.APPLICATION_JSON)
- public Response createJob(
+ public ResponseEntityView createJob(
@Context HttpServletRequest request,
@PathParam("queueName") String queueName,
@BeanParam JobParams form) throws JsonProcessingException, DotDataException {
- new WebResource.InitBuilder(webResource)
+ final var initDataObject = new WebResource.InitBuilder(webResource)
.requiredBackendUser(true)
.requiredFrontendUser(false)
.requestAndResponse(request, null)
.rejectWhenNoUser(true)
.init();
- final String jobId = helper.createJob(queueName, form, request);
- return Response.ok(new ResponseEntityView<>(jobId)).build();
+ final String jobId = helper.createJob(queueName, form, initDataObject.getUser(), request);
+ return new ResponseEntityView<>(jobId);
+ }
+
+ @POST
+ @Path("/{queueName}")
+ @Consumes(MediaType.APPLICATION_JSON)
+ @Produces(MediaType.APPLICATION_JSON)
+ public ResponseEntityView createJob(
+ @Context HttpServletRequest request,
+ @PathParam("queueName") String queueName,
+ Map parameters) throws DotDataException {
+ final var initDataObject = new WebResource.InitBuilder(webResource)
+ .requiredBackendUser(true)
+ .requiredFrontendUser(false)
+ .requestAndResponse(request, null)
+ .rejectWhenNoUser(true)
+ .init();
+ final String jobId = helper.createJob(
+ queueName, parameters, initDataObject.getUser(), request);
+ return new ResponseEntityView<>(jobId);
}
@GET
@Path("/queues")
@Produces(MediaType.APPLICATION_JSON)
public ResponseEntityView> getQueues(@Context HttpServletRequest request) {
- new WebResource.InitBuilder(webResource)
+ new WebResource.InitBuilder(webResource)
.requiredBackendUser(true)
.requiredFrontendUser(false)
.requestAndResponse(request, null)
.rejectWhenNoUser(true)
.init();
- return new ResponseEntityView<>(helper.getQueueNames());
+ return new ResponseEntityView<>(helper.getQueueNames());
}
@GET
@Path("/{jobId}/status")
@Produces(MediaType.APPLICATION_JSON)
- public ResponseEntityView getJobStatus(@Context HttpServletRequest request, @PathParam("jobId") String jobId)
+ public ResponseEntityView getJobStatus(@Context HttpServletRequest request,
+ @PathParam("jobId") String jobId)
throws DotDataException {
- new WebResource.InitBuilder(webResource)
+ new WebResource.InitBuilder(webResource)
.requiredBackendUser(true)
.requiredFrontendUser(false)
.requestAndResponse(request, null)
.rejectWhenNoUser(true)
.init();
- Job job = helper.getJob(jobId);
- return new ResponseEntityView<>(job);
+ Job job = helper.getJob(jobId);
+ return new ResponseEntityView<>(job);
}
@POST
@Path("/{jobId}/cancel")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.WILDCARD)
- public ResponseEntityView cancelJob(@Context HttpServletRequest request, @PathParam("jobId") String jobId)
- throws DotDataException {
- new WebResource.InitBuilder(webResource)
- .requiredBackendUser(true)
- .requiredFrontendUser(false)
- .requestAndResponse(request, null)
- .rejectWhenNoUser(true)
- .init();
- helper.cancelJob(jobId);
- return new ResponseEntityView<>("Job cancelled successfully");
- }
-
- @GET
- @Produces(MediaType.APPLICATION_JSON)
- public ResponseEntityView listJobs(@Context HttpServletRequest request,
- @QueryParam("page") @DefaultValue("1") int page,
- @QueryParam("pageSize") @DefaultValue("20") int pageSize) {
- new WebResource.InitBuilder(webResource)
+ public ResponseEntityView cancelJob(@Context HttpServletRequest request,
+ @PathParam("jobId") String jobId) throws DotDataException {
+ new WebResource.InitBuilder(webResource)
.requiredBackendUser(true)
.requiredFrontendUser(false)
.requestAndResponse(request, null)
.rejectWhenNoUser(true)
.init();
- final JobPaginatedResult result = helper.getJobs(page, pageSize);
- return new ResponseEntityView<>(result);
+ helper.cancelJob(jobId);
+ return new ResponseEntityView<>("Cancellation request successfully sent to job " + jobId);
}
@GET
@Path("/{queueName}/active")
@Produces(MediaType.APPLICATION_JSON)
- public ResponseEntityView activeJobs(@Context HttpServletRequest request, @PathParam("queueName") String queueName,
- @QueryParam("page") @DefaultValue("1") int page,
- @QueryParam("pageSize") @DefaultValue("20") int pageSize) {
- new WebResource.InitBuilder(webResource)
- .requiredBackendUser(true)
- .requiredFrontendUser(false)
- .requestAndResponse(request, null)
- .rejectWhenNoUser(true)
- .init();
- final JobPaginatedResult result = helper.getActiveJobs(queueName, page, pageSize);
- return new ResponseEntityView<>(result);
- }
-
- @GET
- @Path("/failed")
- @Produces(MediaType.APPLICATION_JSON)
- public ResponseEntityView
+
[](https://github.com/dotCMS/core/actions/workflows/cicd_2-merge-queue.yml)
diff --git a/bom/application/pom.xml b/bom/application/pom.xml
index dff2a3a7481c..16b6750564ac 100644
--- a/bom/application/pom.xml
+++ b/bom/application/pom.xml
@@ -1154,6 +1154,19 @@