Adding Xetics Helper

lib/helpers/stringMethods.ts

@@ -22,10 +22,10 @@ export function replaceAll(str: string, value: string, replacement: string): str
 * @param size 
 * @param maxLength 
 */
-export function padString(num: number, size: number, maxLength = false) {
+export function padString(num: number, size: number, maxLength = false): string {
 
   let _size = size;
-  if (typeof maxLength === 'boolean' && maxLength) {
+  if (typeof maxLength === "boolean" && maxLength) {
     _size = Math.ceil(Math.log10(size));
   }
 
@@ -53,8 +53,28 @@ export function insert(str: string, index: number, content: string): string {
  * @param str The String,
  * @param char A, used to determine "new words"
  */
-export function camelize(str: string, char = '_') {
-  return replaceAll(str, char, ' ').replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
+export function camelize(str: string, char = "_"): string {
+  return replaceAll(str, char, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
     return index == 0 ? word.toLowerCase() : word.toUpperCase();
-  }).replace(/\s+/g, '');
+  }).replace(/\s+/g, "");
+}
+
+export function limitString(str: string, length: number, limitChars = "..."): {
+  isLimited: boolean,
+  original: string,
+  limited: string,
+} {
+  if (str.length > length) {
+    return {
+      isLimited: true,
+      original: str,
+      limited: str.slice(0, length - limitChars.length) + limitChars.length
+    };
+  } else {
+    return {
+      isLimited: false,
+      original: str,
+      limited: str
+    };
+  }
 }

modules/xetics-lean-connector/src/xetics.functions.ts

@@ -118,6 +118,20 @@ export const getNextJobsIfFinished = exportFunctionToDispatcher(_getNextJobsIfFi
 
 const _adaptJobs = _cacheFunction(__adaptJobs, "_adaptJobs");
 
+/**
+ * Definition of the MES-Task Definition.
+ *
+ * @export
+ * @interface MESTask
+ * @extends {JobDTO}
+ */
+export interface MESTask extends JobDTO {
+  parameters: {
+    [index: string]: any;
+  };
+  operation: string;
+}
+
 /**
  * Internal function, which adapts the format of the given jobs.
  * 
@@ -165,14 +179,7 @@ async function __adaptJobs(jobIds: number[]) {
     }
   };
 
-  const jobsWithParmas: Array<
-    JobDTO & {
-      parameters: {
-        [index: string]: any;
-      };
-      // operation: string;
-    }
-  > = await Promise.all(jobIds.map(async (jobId: number) => {
+  const jobsWithParmas: Array<MESTask> = await Promise.all(jobIds.map(async (jobId: number) => {
     const _job = await JobControllerService.getTrackingJob1({ jobId }) as JobDTO;
 
     // const parameterList = await JobControllerService.getProcessParametersForJob({
@@ -237,6 +244,95 @@ async function __adaptJobs(jobIds: number[]) {
   return jobsWithParmas;
 }
 
+/**
+ *
+ *
+ * @author M.Karkowski
+ * @export
+ * @param {MESTask} job
+ * @param {"qualityParameters"} type
+ * @return {*}  {({
+ *   [index: string]: {
+ *     type: "number" | "string" | "boolean",
+ *     id: number,
+ *     name: string,
+ *   }
+ * })}
+ */
+export function getParameterDefinitions(job: MESTask, type: "qualityParameters"): {
+  [index: string]: {
+    type: "number" | "string" | "boolean",
+    id: number,
+    name: string,
+    index: number,
+    originalType: ".SelectQualityParameter" | ".FloatQualityParameter" | ".TextQualityParameter" | ".BooleanQualityParameter",
+    accsessor: string
+  }
+} {
+  // | "traceabilityParameters"
+  const extractorDict = {
+    ".TextQualityParameter": {
+      type: "string",
+      accessor: "parameterValue"
+    },
+    ".BooleanQualityParameter": {
+      type: "boolean",
+      accessor: "parameterValue"
+    },
+    ".FloatQualityParameter": {
+      type: "string",
+      accessor: "parameterValue"
+    },
+    ".SelectQualityParameter": {
+      type: "string",
+      accessor: "selectedValues"
+    },
+  };
+
+  // const typeDict = {
+  //   qualityParameters: "qualityValue",
+  //   traceabilityParameters: "traceabilityValue"
+  // };
+  // const attribute = typeDict[type];
+
+  const attribute = "qualityValue";
+
+
+  const validClasses = Object.getOwnPropertyNames(extractorDict);
+
+
+  const params: {
+    [index: string]: {
+      type: "number" | "string" | "boolean",
+      id: number,
+      name: string,
+      index: number,
+      originalType: ".SelectQualityParameter" | ".FloatQualityParameter" | ".TextQualityParameter" | ".BooleanQualityParameter",
+      accsessor: string,
+    }
+  } = {};
+
+  if (job[type]) {
+    const orgParams = deepClone(job[type]);
+
+    for (const item of orgParams) {
+
+      if (validClasses.includes(item[attribute]["@class"])) {
+        params[item.name] = {
+          type: extractorDict[item[attribute]["@class"]].type,
+          id: item.id,
+          name: item.name,
+          index: (item as QualityParameterDTO).parameterIndex,
+          originalType: item[attribute]["@class"] as any,
+          accsessor: extractorDict[item[attribute]["@class"]].accessor,
+        };
+      }
+    }
+  }
+
+  return params;
+}
+
 async function _getStationId(station: string | number) {
   let stationId = -1;
   if (typeof station === "string") {

modules/xetics-lean-connector/src/xetics.module.ts

@@ -21,11 +21,11 @@ import { JobDTO, QualityParameterDTO, TraceabilityParameterDTO } from "../genera
 import {
   finishTask,
   getActiveTasksFromMES,
+  getParameterDefinitions,
   getTasksFromMES,
   startTask
 } from "./xetics.functions";
 
-
 /**
  * Definition of the MES-Task Definition.
  *
@@ -73,8 +73,8 @@ export interface IXeticsInterfaceClient {
    * @memberof IXeticsInterfaceClient
    */
   finishCurrentTask(
-    qualityParameters?: QualityParameterDTO[],
-    traceabilityParameters?: TraceabilityParameterDTO[]
+    qualityParameters?: { [index: string]: any },
+    traceabilityParameters?: { [index: string]: any }
   ): Promise<false | {
     jobsOnStation: JobDTO[];
     jobsOfProduct: number;
@@ -285,11 +285,12 @@ export class XeticsInterfaceClient
     paramsHasNoCallback: true
   })
   async finishCurrentTask(
-    qualityParameters: QualityParameterDTO[] = [],
-    traceabilityParameters: TraceabilityParameterDTO[] = []
+    qualityParameters: { [index: string]: any } = {},
+    traceabilityParameters: { [index: string]: any } = {}
   ) {
     // Perform the Finish Operation, if there exists one.
-    if (this.currentTask.getContent()) {
+    const current = this.currentTask.getContent();
+    if (current) {
       // Call the Finish-Task Operation. Use the parameters of the current Task.
       // Returns the sucess of the Operation.
       if (this._logger) {
@@ -299,12 +300,52 @@ export class XeticsInterfaceClient
         );
       }
 
+      // We now want to define the QualityParameters
+      const _qualityParameters: QualityParameterDTO[] = [];
+      const _traceabilityParameters: TraceabilityParameterDTO[] = [];
+
+      // Now we want to get the Definitions for the Parameters
+      const _qualityParametersDefintions = getParameterDefinitions(current, "qualityParameters");
+
+      // Iterate over the Defintions of the Parameters
+      for (const parameter of Object.values(_qualityParametersDefintions)) {
+
+        // For every Parameter we check if the name is present in the
+        // given "qualityParameters" element. If so, we check if the type
+        // matches. 
+        if (parameter.name in qualityParameters && parameter.type === (typeof qualityParameters[parameter.name])) {
+
+          // Parameter name and type matches ==> 
+          // we define a Quality-Parameter-DTO.
+
+          const qualityValue = {
+            "@class": parameter.originalType,
+          };
+
+          // With this "trick" we assign the value.
+          qualityValue[parameter.accsessor] = qualityParameters[parameter.name];
+
+          // Now lets define the Quality parameter
+          _qualityParameters.push(
+            {
+              parameterIndex: parameter.index,
+              id: parameter.id,
+              qualityValue,
+              name: parameter.name,
+              user: this._user
+            } as QualityParameterDTO
+          );
+        }
+      }
+
+      // Now that we have our quality and tracability-parameters
+      // we are able to finish this job:
       const finished = await finishTask(
         this._station,
         this.currentTask.getContent().id,
         this._user,
-        qualityParameters,
-        traceabilityParameters,
+        _qualityParameters,
+        _traceabilityParameters,
       );
 
       // If the task has been sucessfully finished => assign a new Task.