cms_thermo_active/Step/wwwroot/src/store/runningProcess.store.ts

export interface RunningProcessModel {
  process: Array<signalr_process.ProcessData>,
  axes: Array<signalr_process.AxisData>,
  running: boolean,
  selectedProcess: number,
  selectedAxis: number,
  valueAxisSelected: signalr_process.AxisValueData,
  currentProgram: any,
  currentProgramImage: any
}
export interface ProcessModelActionsInterface {
  removeAllProcess(context);
  addProcess(context, process: signalr_process.ProcessData);
  removeProcess(context, process: signalr_process.ProcessData);
  isRunning(context, status: boolean);
  checkRemove(context, keys: Array<number>);
  selectProcess(context, processId: number);
  selectAxis(context, axisId: number);
  setAxes(context, data: signalr_process.AxisData[]);
  setValueAxisSelected(context, data: signalr_process.AxisValueData);
  setCurrentProgram(context,data);
  setCurrentProgramImage(context, image);
  setCurrentProgramName(context, name);
}


export const processStore = {

  state: {
    currentProgram: null,
    currentProgramName: "",
    currentProgramImage: null,
    _process: new Map<number, signalr_process.ProcessData>(),
    process: [],
    axes: [],
    running: false,
    selectedProcess: 0,
    selectedAxis: 0,
    valueAxisSelected: { interpolated: Object, machine: Object, programmePos: Object, toGo: Object }
  } as RunningProcessModel,
  mutations: {
    SetCurrentProgram(store, data){
      store.currentProgram = data;
    },
    SetCurrentProgramImage(store, image){
      store.currentProgramImage = image;
    },
    SetCurrentProgramName(store, name){
      store.currentProgramName= name;
    },
    SetValueAxisSelected(store, data: signalr_process.AxisValueData) {
      store.valueAxisSelected = data;
    },
    SetAxes(store, data: signalr_process.AxisData[]) {
      store.axes = data;
    },
    AddProcess(store, process: signalr_process.ProcessData) {
      store._process.set(process.id, process);
      store.process = Array.from(store._process.values());
    },
    RemoveProcess(store, process: signalr_process.ProcessData) {
      if (store._process.has(process.id))
        store._process.delete(process.id);

      store.process = Array.from(store._process.values());
    },
    RemoveAllProcess(store) {
      store._process.clear();
      store.process = [];
    },
    Running(store, value) {
      store.running = value;
    },
    checkRemoveProcess(store, keys: Array<number>) {
      let removed = false;

      let ak = Array.from((store._process as Map<number, signalr_process.ProcessData>).keys());
      for (const index in ak) {
        if (keys.indexOf(ak[index]) < 0) { store._process.delete(ak[index]); removed = true; }
      }


      if (removed)
        store.process = Array.from(store._process.values());
    },
    selectProcess(store, processId: number) {
      store.selectedProcess = processId;
    },
    selectAxis(store, axisId: number) {
      store.selectedAxis = axisId;
    }
  },
  actions: {
    setCurrentProgram(context,data){
      context.commit("SetCurrentProgram", data);
    },
    setCurrentProgramImage(context,image){
      context.commit("SetCurrentProgramImage", image);
    },
    setCurrentProgramName(context,name){
      context.commit("SetCurrentProgramName", name);
    },
    setValueAxisSelected(context, data: signalr_process.AxisValueData) {
      context.commit("SetValueAxisSelected", data);
    },
    isRunning(context, status: boolean) {
      context.commit("Running", status)
    },
    addProcess(context, process) {
      context.commit("AddProcess", process);
    },
    removeProcess(context, process) {
      context.commit("RemoveProcess", process);
    },
    removeAllProcess(context) {
      context.commit("RemoveAllProcess");
    },
    checkRemove(context, keys: Array<number>) {
      context.commit("checkRemoveProcess", keys);
    },
    selectProcess(context, processId: number) {
      context.commit("selectProcess", processId);
    },
    selectAxis(context, axisId: number) {
      context.commit("selectAxis", axisId);
    },
    setAxes(context, data: signalr_process.AxisData[]) {
      context.commit("SetAxes", data);
    }

  } as ProcessModelActionsInterface
}

export const processModelActions = processStore.actions as ProcessModelActionsInterface;