@jumoo/processing 17.4.3-prerelease.6 → 17.4.3-prerelease.7

package/dist/api/types.gen.d.ts

@@ -89,6 +89,7 @@ export type PipelineRunStatus = {
     cancelRequested: boolean;
     progress: PipelineRunProgress;
     startedBy?: string | null;
+    startedByName?: string | null;
     created?: string | null;
     modified?: string | null;
     scheduledFor?: string | null;

package/dist/lang/files/en.d.ts

@@ -16,10 +16,28 @@ declare const _default: {
     jumooProcConflict: {
         headline: string;
         message: string;
+        headlineRunning: string;
+        messageRunning: string;
+        headlineQueued: string;
+        messageQueued: string;
+        headlineWaiting: string;
+        messageWaiting: string;
+        headlineScheduled: string;
+        messageScheduled: string;
         status: string;
         startedBy: string;
-        started: string;
+        queued: string;
+        lastActivity: string;
+        waitingSince: string;
+        scheduledFor: string;
         progress: string;
+        stateQueued: string;
+        stateRunning: string;
+        stateScheduled: string;
+        stateWaiting: string;
+        stateCompleted: string;
+        stateFailed: string;
+        stateCancelled: string;
     };
     jumooProcBackground: {
         completed: string;

package/dist/lang/files/en.js

@@ -14,12 +14,30 @@ export default {
         stack: 'Stack',
     },
     jumooProcConflict: {
-        headline: 'Already running',
-        message: 'Another process is already running for this target. Wait for it to finish, or cancel it, then try again.',
+        headline: 'Already in progress',
+        message: 'Another process is already in progress for this target. Wait for it to finish, or cancel it, then try again.',
+        headlineRunning: 'Already running',
+        messageRunning: 'Another process is already running for this target. Wait for it to finish, or cancel it, then try again.',
+        headlineQueued: 'Already queued',
+        messageQueued: 'Another process for this target is queued and will start shortly. Wait for it to finish, or cancel it, then try again.',
+        headlineWaiting: 'Waiting to continue',
+        messageWaiting: 'Another process for this target is paused and waiting to continue. Finish or cancel it, then try again.',
+        headlineScheduled: 'Already scheduled',
+        messageScheduled: 'Another process for this target is scheduled. Cancel it, or wait for it to run, then try again.',
         status: 'Status',
         startedBy: 'Started by',
-        started: 'Started',
+        queued: 'Queued',
+        lastActivity: 'Last activity',
+        waitingSince: 'Waiting since',
+        scheduledFor: 'Scheduled for',
         progress: 'Progress',
+        stateQueued: 'Queued',
+        stateRunning: 'Running',
+        stateScheduled: 'Scheduled',
+        stateWaiting: 'Waiting',
+        stateCompleted: 'Completed',
+        stateFailed: 'Failed',
+        stateCancelled: 'Cancelled',
     },
     jumooProcBackground: {
         completed: 'This process has completed in the background',

package/dist/pipeline/pipeline.element.d.ts

@@ -61,6 +61,13 @@ export declare class JumooPipelineElement extends UmbLitElement {
     private onLastAction;
     render(): import("lit-html").TemplateResult<1>;
     private renderConflict;
+    /**
+     * @description the time worth showing for the holder: when it was queued, when it last
+     * moved, how long it has been paused, or when it is due.
+     * @param holder the holder's status.
+     * @returns the label key and the time, or undefined when there is nothing to show.
+     */
+    private conflictTime;
     private renderDebug;
     private renderStatus;
     private renderBackground;

package/dist/pipeline/pipeline.element.js

@@ -7,6 +7,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { css, customElement, html, nothing, property, state, } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { PipelineStatus, JUMOO_PROCESSING_CONTEXT, } from '@jumoo/processing';
+import { PipelineRunState } from '../api/index.js';
+/**
+ * @description the suffix on the conflict panel's headline and message keys for the holder's
+ * status. A holder that isn't moving or waiting gets the general wording.
+ * @param status the holder's status.
+ * @returns the key suffix.
+ */
+function conflictSuffix(status) {
+    switch (status) {
+        case PipelineRunState.RUNNING:
+        case PipelineRunState.QUEUED:
+        case PipelineRunState.WAITING:
+        case PipelineRunState.SCHEDULED:
+            return status;
+        default:
+            return '';
+    }
+}
 /**
  * @property {string} processor - the processor to use for the pipeline
  * @property {string} strategy - the strategy to use for the pipeline
@@ -156,49 +174,65 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
     }
     renderConflict(conflict) {
         const holder = conflict.holder;
+        const suffix = holder ? conflictSuffix(holder.status) : '';
+        const time = holder ? this.conflictTime(holder) : undefined;
+        const dateFormat = {
+            dateStyle: 'medium',
+            timeStyle: 'short',
+        };
         return html `<div class="conflict">
 			<div class="header">
 				<uui-icon name="icon-alert"></uui-icon>
-				<h3>
-					<umb-localize key="jumooProcConflict_headline">Already running</umb-localize>
-				</h3>
+				<h3>${this.localize.term(`jumooProcConflict_headline${suffix}`)}</h3>
 			</div>
-			<p>
-				<umb-localize key="jumooProcConflict_message">
-					Another process is already running for this target. Wait for it to finish, or
-					cancel it, then try again.
-				</umb-localize>
-			</p>
+			<p>${this.localize.term(`jumooProcConflict_message${suffix}`)}</p>
 			${holder
             ? html `<dl>
 							<dt><umb-localize key="jumooProcConflict_status">Status</umb-localize></dt>
-							<dd>${holder.status}</dd>
-							${holder.startedBy
+							<dd>${this.localize.term(`jumooProcConflict_state${holder.status}`)}</dd>
+							${holder.startedByName
                 ? html `<dt>
 												<umb-localize key="jumooProcConflict_startedBy"
 													>Started by</umb-localize
 												>
 											</dt>
-											<dd>${holder.startedBy}</dd>`
+											<dd>${holder.startedByName}</dd>`
                 : nothing}
-							${holder.created
+							${time
+                ? html `<dt>${this.localize.term(time.label)}</dt>
+											<dd>${this.localize.date(time.value, dateFormat)}</dd>`
+                : nothing}
+							${holder.status === PipelineRunState.RUNNING
                 ? html `<dt>
-												<umb-localize key="jumooProcConflict_started"
-													>Started</umb-localize
+												<umb-localize key="jumooProcConflict_progress"
+													>Progress</umb-localize
 												>
 											</dt>
-											<dd>
-												${this.localize.date(holder.created, { dateStyle: 'medium', timeStyle: 'short' })}
-											</dd>`
+											<dd>${Math.round(holder.progress.percentage)}%</dd>`
                 : nothing}
-							<dt>
-								<umb-localize key="jumooProcConflict_progress">Progress</umb-localize>
-							</dt>
-							<dd>${Math.round(holder.progress.percentage)}%</dd>
 						</dl>`
             : nothing}
 		</div>`;
     }
+    /**
+     * @description the time worth showing for the holder: when it was queued, when it last
+     * moved, how long it has been paused, or when it is due.
+     * @param holder the holder's status.
+     * @returns the label key and the time, or undefined when there is nothing to show.
+     */
+    conflictTime(holder) {
+        const pick = (label, value) => value ? { label: `jumooProcConflict_${label}`, value } : undefined;
+        switch (holder.status) {
+            case PipelineRunState.QUEUED:
+                return pick('queued', holder.created);
+            case PipelineRunState.WAITING:
+                return pick('waitingSince', holder.modified);
+            case PipelineRunState.SCHEDULED:
+                return pick('scheduledFor', holder.scheduledFor);
+            default:
+                return pick('lastActivity', holder.modified ?? holder.created);
+        }
+    }
     renderDebug() {
         return this.debug
             ? html `<div><pre>${JSON.stringify(this.state, null, 1)}</pre></div>`

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jumoo/processing",
 	"licence": "custom",
-	"version": "17.4.3-prerelease.6",
+	"version": "17.4.3-prerelease.7",
 	"type": "module",
 	"description": "Jumoo processing library",
 	"exports": {