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,
  m155messages: Array<signalr_process.M155Messages>,
  activeOffsetId: number,
  activeOrigin: number,
  processMessage: string,
  unitMeasure: string,
  canLoadProgram: boolean,
  offsetData: server.Offset
  rapidOverride: number,
  workOverride: number
}
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);
  setQueueStatus(context, status);
  setStartStopQueueEnabled(context, queueEnabled);
  setM155Messsages(context, data: Array<signalr_process.M155Messages>);
  hideM155Messsage(context, Id: number);
  setCurrentOrigin(context, Id: number);
  setCurrentOffsetId(context, Id: number);
  setProcessMessage(context, message: string);
  setUnitMeasure(context, Id: number);
  setCanLoadProgram(context, Id: number);
  setOverrides(context, rapidOverride: number, workOverride: number);
  setOffsetData(context, offsetData: server.Offset)
}

export const processStore = {

  state: {
    currentProgram: null,
    currentProgramName: "",
    currentProgramImage: null,
    _process: new Map<number, signalr_process.ProcessData>(),
    process: [],
    _m155messages: new Map<number, signalr_process.M155Messages>(),
    m155messages: [],
    axes: [],
    running: false,
    selectedProcess: 0,
    queueStatus: 0,
    startStopQueueEnabled: false,
    selectedAxis: 0,
    valueAxisSelected: { interpolated: Object, machine: Object, programmePos: Object, toGo: Object },
    activeOffsetId: 0,
    activeOrigin: 0,
    processMessage: "",
    unitMeasure: "mm",
    canLoadProgram: false,
    workOverride:0,
    rapidOverride:0,
    offsetData : null
  } as RunningProcessModel,
  mutations: {    
    SetCurrentOrigin(store, Id){
      store.activeOrigin = Id;
    }, 
    SetCanLoadProgram(store, val){
      store.canLoadProgram = val;
    }, 
    SetUnitMeasure(store, unit){
      store.unitMeasure = unit;
    },
    SetCurrentOffsetId(store, Id){
      store.activeOffsetId = Id;
    },
    SetProcessMessage(store, message){
      store.processMessage = message;
    },
    SetStartStopQueueEnabled(store, queueEnabled){
      store.startStopQueueEnabled = queueEnabled;
    },
    SetQueueStatus(store, status){
      store.queueStatus = status;
    },
    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;
    },    
    HideM155Messsage(store, processId: number) {
      if(store._m155messages.has(processId)){
        store._m155messages[processId].toDisplay = false;
      }
      store.m155messages = Array.from(store._m155messages.values());
    },  
    setM155Messsages(store, data: Array<signalr_process.M155Messages>){
      
      var iterator = store._m155messages.values();
      let value = iterator.next().value;
      while(value){
        value.toDelete = true;     
        value = iterator.next().value;
      }

      for (let index = 0; index < data.length; index++) {
        let element = data[index];
        element.toDelete = false; 
        element.toDisplay = true; 
        store._m155messages.set(element.process, element);
      }

      //Delete what i have to delete
      iterator = store._m155messages.values();
      value = iterator.next().value;
      while(value){
        if(value.toDelete)
          store._m155messages.delete(value.process);
        value = iterator.next().value;
      }

      store.m155messages = Array.from(store._m155messages.values());
    },
    setOverrides(store, data){
      store.rapidOverride = data.rapidOverride;
      store.workOverride = data.workOverride;
    },
    SetOffsetData(store, data){
      store.offsetData = data
    }
  },
  getters: {
    getCurrentProgramPath: state => {
      return this.state.currentProgram.path}
  }, 
  actions: {   
    
    hideM155Messsage(context, Id){
      context.commit("HideM155Messsage", Id);
    }, 
    setCanLoadProgram(context, val){
      context.commit("SetCanLoadProgram", val);
    }, 
    setCurrentOrigin(context, Id){
      context.commit("SetCurrentOrigin", Id);
    },
    setCurrentOffsetId(context, Id){
      context.commit("SetCurrentOffsetId", Id);
    },
    setProcessMessage(context, message){
      context.commit("SetProcessMessage", message);
    },
    setM155Messsages(context, data){
      context.commit("setM155Messsages", data);
    },
    setStartStopQueueEnabled(context, queueEnabled){
      context.commit("SetStartStopQueueEnabled", queueEnabled);
    },
    setQueueStatus(context, status){
      context.commit("SetQueueStatus", status);
    },
    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);
    },
    setUnitMeasure(context, data){
      context.commit("SetUnitMeasure", data);
    },
    setOverrides(context, rapidOverride, workOverride){
      context.commit("setOverrides", {rapidOverride: rapidOverride, workOverride: workOverride});
    },
    setOffsetData(context, offsetData: server.Offset)
    {
      context.commit("SetOffsetData", offsetData) 
    }

  } as ProcessModelActionsInterface
}

export const processModelActions = processStore.actions as ProcessModelActionsInterface;