pause and repeat task steps

groupTasks/groups/production1/index.json

@@ -22,7 +22,8 @@
     {
       "name": "Bild zu Label konvertieren",
       "onFinish": "pause",
-      "undoPossible": false,
+      "undoPossible": true,
+      "repeatPossible": true,
       "scriptPath": "test1.py",
       "parameters": [
         {
@@ -47,15 +48,41 @@
     },
     {
       "name": "Label drucken",
-      "onFinish": "pause",
+      "onFinish": "next",
       "undoPossible": false,
+      "repeatPossible": false,
+      "scriptPath": "test2.py",
+      "parameters": []
+    },
+    {
+      "name": "Label drucken1",
+      "onFinish": "next",
+      "undoPossible": false,
+      "repeatPossible": false,
+      "scriptPath": "test2.py",
+      "parameters": []
+    },
+    {
+      "name": "Label drucken2",
+      "onFinish": "next",
+      "undoPossible": false,
+      "repeatPossible": false,
+      "scriptPath": "test2.py",
+      "parameters": []
+    },
+    {
+      "name": "Label drucken3",
+      "onFinish": "next",
+      "undoPossible": false,
+      "repeatPossible": false,
       "scriptPath": "test2.py",
       "parameters": []
     },
     {
       "name": "Label 1",
-      "onFinish": "pause",
+      "onFinish": "next",
       "undoPossible": false,
+      "repeatPossible": false,
       "scriptPath": "test2.py",
       "parameters": [
         {
@@ -70,7 +97,8 @@
       "name": "Label 2",
       "onFinish": "pause",
       "undoPossible": false,
-      "scriptPath": "test2.py",
+      "repeatPossible": true,
+      "scriptPath": "test3.py",
       "parameters": []
     }
   ]

groupTasks/groups/production1/test1.py

@@ -10,6 +10,15 @@ time.sleep(3)
 labelformat = sys.argv[1]
 kiste = sys.argv[2]
 
+
+if len(sys.argv) >= 5:
+    undo = sys.argv[4]
+
+    if undo == "--undo":
+        print("finish undo")
+        sys.exit(0)
+
+
 print("hello this is test1")
 
 if labelformat is None or kiste is None:

groupTasks/groups/production1/test3.py

@@ -0,0 +1,5 @@
+import sys
+
+print("hello")
+
+sys.exit(0)

groupTasks/groups/roese/index.json

@@ -6,6 +6,7 @@
           "name": "Haha",
           "onFinish": "pause",
           "undoPossible": false,
+          "repeatPossible": false,
           "scriptPath": "haha.py"
         }
       ]

groupTasks/groups/testa/index.json

@@ -6,6 +6,7 @@
       "name": "Test1",
       "onFinish": "pause",
       "undoPossible": false,
+      "repeatPossible": false,
       "scriptPath": "",
       "parameters": []
     },
@@ -13,6 +14,7 @@
       "name": "Test2",
       "onFinish": "nextStep",
       "undoPossible": false,
+      "repeatPossible": false,
       "scriptPath": "",
       "parameters": []
     },
@@ -20,6 +22,7 @@
       "name": "Test3",
       "onFinish": "nextStep",
       "undoPossible": false,
+      "repeatPossible": false,
       "scriptPath": "",
       "parameters": []
     },
@@ -27,6 +30,7 @@
       "name": "Test3",
       "onFinish": "nextStep",
       "undoPossible": false,
+      "repeatPossible": false,
       "scriptPath": "",
       "parameters": []
     },
@@ -34,6 +38,7 @@
       "name": "Test3",
       "onFinish": "nextStep",
       "undoPossible": false,
+      "repeatPossible": false,
       "scriptPath": "",
       "parameters": []
     }

grouptasks_lang_log_messages.json

@@ -102,5 +102,31 @@
                 "message": "%userId% hat die Prüfung auf Änderungen in den Kategoriengruppen angefordert. Ergebnis: %result%"
             }
         ]
+    },
+    {
+        "id": 8,
+        "languages": [
+            {
+                "lang": "en",
+                "message": "%userId% has executed action %action% on step %taskStepId% of %groupTaskId%"
+            },
+            {
+                "lang": "de",
+                "message": "%userId% hat Aktion %action% auf Schritt %taskStepId% von %groupTaskId% ausgeführt"
+            }
+        ]
+    },
+    {
+        "id": 9,
+        "languages": [
+            {
+                "lang": "en",
+                "message": "System has started step %step% of %groupTaskId%"
+            },
+            {
+                "lang": "de",
+                "message": "System hat Schritt %step% von %groupTaskId% gestartet"
+            }
+        ]
     }
 ]

modules/grouptasks/grouptasks.go

@@ -296,6 +296,7 @@ func existsGroup(category string, groupsList []structs.Group) bool {
 const (
 	RunGroupTaskStartTypeNormal   = 0
 	RunGroupTaskStartTypeTryAgain = 1
+	RunGroupTaskStartTypeUndo     = 2
 )
 
 type RunGroupTaskArgs struct {
@@ -320,7 +321,14 @@ type FoundFile struct {
 	FileName string
 }
 
-func ResumeTaskFromPause(userId string, body map[string]interface{}) {
+const (
+	UserActionTaskStepResume = 0
+	UserActionTaskStepUndo   = 1
+	UserActionTaskStepRepeat = 2
+)
+
+func HandleUserActionTaskStep(userId string, body map[string]interface{}) {
+	action := uint8(body["action"].(float64))
 	groupTaskId := body["groupTaskId"].(string)
 	category := body["category"].(string)
 	groupId := body["groupId"].(string)
@@ -331,36 +339,94 @@ func ResumeTaskFromPause(userId string, body map[string]interface{}) {
 
 	database.DB.Where("id = ?", taskStepId).Find(&dbGroupTaskStep)
 
-	// set step to finished
 	groupTaskStep := structs.GroupTaskSteps{
 		Id:            taskStepId,
 		CreatorUserId: userId,
 		GroupTasksId:  groupTaskId,
 		Step:          step,
-		Status:        utils.GroupTasksStatusFinished,
+	}
-		Inputs:        dbGroupTaskStep.Inputs,
+
-		Log:           dbGroupTaskStep.Log,
+	nextStep := step
-		Files:         dbGroupTaskStep.Files,
+
+	if action == UserActionTaskStepResume {
+		groupTaskStep.Status = utils.GroupTasksStatusFinished
+		groupTaskStep.Inputs = dbGroupTaskStep.Inputs
+		groupTaskStep.Log = dbGroupTaskStep.Log
+		groupTaskStep.Files = dbGroupTaskStep.Files
+		groupTaskStep.StartedAt = dbGroupTaskStep.StartedAt
+		groupTaskStep.EndedAt = dbGroupTaskStep.EndedAt
+
+		nextStep = step + 1
+
+		logger.AddGroupTasksLog(structs.LogMessage{
+			Id:   8,
+			Type: utils.LogTypeInfo,
+			Messages: []structs.LogData{
+				{Type: "userId", Value: userId},
+				{Type: "action", Value: "resume"},
+				{Type: "taskStepId", Value: taskStepId},
+				{Type: "groupTaskId", Value: groupTaskId},
+			},
+		})
+	} else {
+		groupTaskStep.Status = utils.GroupTasksStatusRunning
 	}
 
 	updateGroupTaskSteps(groupTaskStep)
 
-	// set group task to runnning
+	categoryGroup := GetCategoryGroupTaskByCategoryAndGroupId(category, groupId)
+
+	// last step onFinish was set to pause so the resume is the confirmation to finish the group task
+	if int(nextStep) > len(categoryGroup.Tasks) {
+		groupTaskFinished(groupTaskId)
+		return
+	}
+
 	updateGroupTask(groupTaskId, structs.GroupTasks{
-		Status:           utils.GroupTasksStatusRunning,
+		CurrentTasksStep: nextStep,
-		CurrentTasksStep: step + 1,
 	})
 
-	// run next task step
+	runGroupTaskArgs := RunGroupTaskArgs{
-	go RunGroupTask(RunGroupTaskArgs{
 		CreatorUserId: userId,
 		StartType:     RunGroupTaskStartTypeNormal,
 		GroupTaskId:   groupTaskId,
 		Category:      category,
 		GroupId:       groupId,
-		Step:          step + 1,
+		Step:          nextStep,
 		TaskStepId:    taskStepId,
+	}
+
+	if action == UserActionTaskStepRepeat {
+		runGroupTaskArgs.StartType = RunGroupTaskStartTypeTryAgain
+
+		logger.AddGroupTasksLog(structs.LogMessage{
+			Id:   8,
+			Type: utils.LogTypeInfo,
+			Messages: []structs.LogData{
+				{Type: "userId", Value: userId},
+				{Type: "action", Value: "repeat"},
+				{Type: "taskStepId", Value: taskStepId},
+				{Type: "groupTaskId", Value: groupTaskId},
+			},
 		})
+	} else if action == UserActionTaskStepUndo {
+		runGroupTaskArgs.StartType = RunGroupTaskStartTypeUndo
+		runGroupTaskArgs.TaskInputs = dbGroupTaskStep.Inputs
+
+		logger.AddGroupTasksLog(structs.LogMessage{
+			Id:   8,
+			Type: utils.LogTypeInfo,
+			Messages: []structs.LogData{
+				{Type: "userId", Value: userId},
+				{Type: "action", Value: "undo"},
+				{Type: "taskStepId", Value: taskStepId},
+				{Type: "groupTaskId", Value: groupTaskId},
+			},
+		})
+	}
+
+	// run next task step
+	go RunGroupTask(runGroupTaskArgs)
 }
 
 func RunGroupTask(args RunGroupTaskArgs) {
@@ -375,7 +441,6 @@ func RunGroupTask(args RunGroupTaskArgs) {
 		StartedAt:     time.Now(),
 	}
 
-	// task type
 	if args.StartType == RunGroupTaskStartTypeNormal {
 		groupTaskStep.Id = uuid.New().String()
 
@@ -385,7 +450,7 @@ func RunGroupTask(args RunGroupTaskArgs) {
 			Cmd:  utils.SentCmdNewGroupTaskStep,
 			Body: groupTaskStep,
 		})
-	} else if args.StartType == RunGroupTaskStartTypeTryAgain {
+	} else {
 		groupTaskStep.Id = args.TaskStepId
 
 		updateGroupTaskSteps(groupTaskStep)
@@ -443,6 +508,11 @@ func RunGroupTask(args RunGroupTaskArgs) {
 		for _, taskParameterInput := range taskParameterInputs {
 			commandArgs = append(commandArgs, taskParameterInput.Value)
 		}
+
+		// append undo as last arg to script
+		if args.StartType == RunGroupTaskStartTypeUndo {
+			commandArgs = append(commandArgs, "--undo")
+		}
 	}
 
 	// create running task folder
@@ -527,6 +597,7 @@ func RunGroupTask(args RunGroupTaskArgs) {
 	groupTaskStep.Log = cmdLog
 	groupTaskStep.EndedAt = time.Now()
 
+	if args.StartType != RunGroupTaskStartTypeUndo {
 		// looking for files which are created by the scripts
 		var foundFiles []FoundFile
 
@@ -603,12 +674,11 @@ func RunGroupTask(args RunGroupTaskArgs) {
 				groupTaskStep.Files = string(marshaledTaskFiles)
 			}
 		}
+	}
 
 	// update group task step
-
 	updateGroupTaskSteps(groupTaskStep)
 
-	if int(args.Step) < len(categoryGroup.Tasks) {
 	if groupTaskStep.Status == utils.GroupTasksStatusFailed {
 		// set group task to failed
 		updateGroupTask(groupTaskStep.GroupTasksId, structs.GroupTasks{
@@ -624,39 +694,98 @@ func RunGroupTask(args RunGroupTaskArgs) {
 			},
 		})
 	} else {
+		prevStartType := args.StartType
 		args.StartType = RunGroupTaskStartTypeNormal
-			args.Step = args.Step + 1
 
 		if categoryGroup.Tasks[args.Step-1].OnFinish == "pause" {
-				groupTaskStep.Status = utils.GroupTasksStatusPaused
+			status := utils.GroupTasksStatusPaused
+
+			if prevStartType == RunGroupTaskStartTypeUndo {
+				status = utils.GroupTasksStatusUndoEnded
+				groupTaskStep.Inputs = " "
+				groupTaskStep.Files = " "
+
+				logger.AddGroupTasksLog(structs.LogMessage{
+					Id:   2,
+					Type: utils.LogTypeInfo,
+					Messages: []structs.LogData{
+						{Type: "groupTaskId", Value: groupTaskStep.GroupTasksId},
+						{Type: "status", Value: "Undo ended"},
+					},
+				})
+
+				logger.AddGroupTasksLog(structs.LogMessage{
+					Id:   5,
+					Type: utils.LogTypeInfo,
+					Messages: []structs.LogData{
+						{Type: "taskStepId", Value: groupTaskStep.Id},
+						{Type: "groupTaskId", Value: groupTaskStep.GroupTasksId},
+						{Type: "status", Value: "Undo ended"},
+					},
+				})
+			} else {
+				logger.AddGroupTasksLog(structs.LogMessage{
+					Id:   2,
+					Type: utils.LogTypeInfo,
+					Messages: []structs.LogData{
+						{Type: "groupTaskId", Value: groupTaskStep.GroupTasksId},
+						{Type: "status", Value: "paused"},
+					},
+				})
+
+				logger.AddGroupTasksLog(structs.LogMessage{
+					Id:   5,
+					Type: utils.LogTypeInfo,
+					Messages: []structs.LogData{
+						{Type: "taskStepId", Value: groupTaskStep.Id},
+						{Type: "groupTaskId", Value: groupTaskStep.GroupTasksId},
+						{Type: "status", Value: "paused"},
+					},
+				})
+			}
+
+			groupTaskStep.Status = status
 
 			updateGroupTaskSteps(groupTaskStep)
 			updateGroupTask(groupTaskStep.GroupTasksId, structs.GroupTasks{
-					Status: utils.GroupTasksStatusPaused,
+				Status: status,
 			})
 		} else {
-				updateGroupTask(groupTaskStep.GroupTasksId, structs.GroupTasks{
+			args.Step = args.Step + 1
-					CurrentTasksStep: args.Step,
-				})
-			}
 
-			if categoryGroup.Tasks[args.Step-1].OnFinish != "pause" {
+			if int(args.Step-1) < len(categoryGroup.Tasks) {
 				// clear task parameters, because otherwise the next task would have the parameters from the previous task
 				args.TaskInputs = ""
 
+				updateGroupTask(groupTaskStep.GroupTasksId, structs.GroupTasks{
+					CurrentTasksStep: args.Step,
+				})
+
+				logger.AddGroupTasksLog(structs.LogMessage{
+					Id:   9,
+					Type: utils.LogTypeInfo,
+					Messages: []structs.LogData{
+						{Type: "groupTaskId", Value: groupTaskStep.GroupTasksId},
+						{Type: "step", Value: utils.MarshalJson(args.Step)},
+					},
+				})
+
 				RunGroupTask(args)
+			} else {
+				groupTaskFinished(groupTaskStep.GroupTasksId)
+			}
 		}
-			log.Warn().Msgf("onFinish %v", categoryGroup.Tasks[args.Step-1].OnFinish)
 
 	}
-	} else {
+}
-		// set group task to finished
+
-		updateGroupTask(groupTaskStep.GroupTasksId, structs.GroupTasks{
+func groupTaskFinished(groupTasksId string) {
+	updateGroupTask(groupTasksId, structs.GroupTasks{
 		Status:  utils.GroupTasksStatusFinished,
 		EndedAt: time.Now(),
 	})
 
-		if err = os.RemoveAll(config.Cfg.FolderPaths.GroupTasksRunningTasks + groupTaskStep.GroupTasksId + "/"); err != nil {
+	if err := os.RemoveAll(config.Cfg.FolderPaths.GroupTasksRunningTasks + groupTasksId + "/"); err != nil {
 		log.Error().Msgf("Failed to delete running task folder %s", err.Error())
 	}
 
@@ -664,12 +793,11 @@ func RunGroupTask(args RunGroupTaskArgs) {
 		Id:   2,
 		Type: utils.LogTypeInfo,
 		Messages: []structs.LogData{
-				{Type: "groupTaskId", Value: groupTaskStep.GroupTasksId},
+			{Type: "groupTaskId", Value: groupTasksId},
 			{Type: "status", Value: "finished"},
 		},
 	})
 }
-}
 
 // Updates group task and send it to websocket users
 func updateGroupTask(groupTasksId string, updates structs.GroupTasks) structs.GroupTasks {

modules/structs/grouptasks.go

@@ -61,6 +61,7 @@ type Task struct {
 	Name           string          `json:"name"`
 	OnFinish       string          `json:"onFinish"`
 	UndoPossible   bool            `json:"undoPossible"`
+	RepeatPossible bool            `json:"repeatPossible"`
 	ScriptPath     string          `json:"scriptPath"`
 	Parameters     []TaskParameter `json:"parameters"` // same as task inputs
 }

modules/utils/globals.go

@@ -82,7 +82,7 @@ const (
 	ReceivedCmdScannersUseScanners                       = 15
 	ReceivedCmdScannersDisconnectScanner                 = 16
 	ReceivedCmdGroupTasksCheckingForCategoryGroupChanges = 17
-	ReceivedCmdTaskResumeFromPauseTaskStep               = 18
+	ReceivedCmdHandleUserActionTaskStep                  = 18
 )
 
 const (
@@ -92,6 +92,7 @@ const (
 	GroupTasksStatusFailed        uint8 = 4
 	GroupTasksStatusInputRequired uint8 = 5
 	GroupTasksStatusPaused        uint8 = 6
+	GroupTasksStatusUndoEnded     uint8 = 7
 )
 
 var (

socketserver/hub.go

@@ -369,8 +369,8 @@ func RunHub() {
 
 				grouptasks.LookingForCategoryGroupChanges(data.Conn.Locals("userId").(string))
 				break
-			case utils.ReceivedCmdTaskResumeFromPauseTaskStep:
+			case utils.ReceivedCmdHandleUserActionTaskStep:
-				grouptasks.ResumeTaskFromPause(data.Conn.Locals("userId").(string), receivedMessage.Body)
+				grouptasks.HandleUserActionTaskStep(data.Conn.Locals("userId").(string), receivedMessage.Body)
 				break
 
 			default: