@dobot-plus/template 1.0.7 → 1.1.0

package/.dobot/protocol/websocketHandler.ts.txt

@@ -1,234 +0,0 @@
-import i18n from '../utils/i18n'
-import store from '../store'
-import { toolActions } from '../store/actions/toolActions'
-import { userMagamentActions } from '../store/actions/userMagamentActions'
-import { communicator } from './postMessageCenter'
-
-const url = `ws://localhost:8099`
-
-export class WebSocketHandler {
-  private ws: null | WebSocket
-  private promiseObj: any
-  private id: number
-  private timerId: any
-  private timeoutObj: any
-  private timeout: number
-  private serverTimeoutObj: null
-  private isConnect: boolean
-  private tryTimes: number
-
-  constructor() {
-    this.ws = null
-    this.promiseObj = {}
-    this.id = 0
-    this.timerId = null
-    this.timeout = 30000 //30秒发一次心跳
-    this.timeoutObj = null
-    this.serverTimeoutObj = null
-    this.isConnect = false
-    this.contentWs()
-    this.tryTimes = -1
-  }
-
-  private contentWs = () => {
-    if (this.isConnect || this.tryTimes > 3) return
-    this.tryTimes += 1
-
-    this.ws = new WebSocket(url)
-    this.ws.onopen = () => {
-      this.reset().start()
-      this.isConnect = true
-      ;(this.ws as WebSocket).onmessage = (data) => this.onSocketMessage(JSON.parse(data.data))
-    }
-    this.ws.onerror = () => {
-      this.isConnect = false
-      this.contentWs()
-    }
-    this.ws.onclose = () => {
-      this.isConnect = false
-      this.contentWs()
-    }
-  }
-
-  private send = (params: { method: string; data: any }) => {
-    const { data, method } = params
-    const sendData = JSON.stringify({
-      jsonrpc: '2.0',
-      method,
-      id: this.id,
-      data
-    })
-
-    if (this.ws) this.ws.send(sendData)
-    return new Promise((resolve) => {
-      this.promiseObj[this.id] = resolve
-      this.id++
-    })
-  }
-
-  private onSocketMessage = (data: { id: number; method: string; result?: any; data?: any }) => {
-    this.reset().start()
-    this.id = data.id
-    if (this.promiseObj[data.id]) {
-      this.promiseObj[data.id](data.result || data.data)
-      delete this.promiseObj[data.id]
-    }
-    if (data.method === 'heart') return
-    this.messageHandler(data)
-  }
-
-  private reset() {
-    clearTimeout(this.timeoutObj)
-    clearTimeout(this.serverTimeoutObj as any)
-    return this
-  }
-  private start() {
-    if (this.ws) {
-      this.timeoutObj = setTimeout(() => {
-        //这里发送一个心跳，后端收到后，返回一个心跳消息，
-        //onmessage拿到返回的心跳就说明连接正常
-        this.send({ data: 'ping', method: 'heart' })
-        // this.serverTimeoutObj = setTimeout(function () {//如果超过一定时间还没重置，说明后端主动断开了
-        //   this.ws.close();     //如果onclose会执行reconnect，我们执行ws.close()就行了.如果直接执行reconnect 会触发onclose导致重连两次
-        // }, this.timeout)
-      }, this.timeout)
-    }
-  }
-
-  private messageHandler = (data: any) => {
-    let method = data.method
-    if (method) {
-      // 将 highlight_blocks 更改为 highlightBlocks 这样的驼峰样式
-      method = method.replace(/_(\w)/g, (_: any, match: string) => match.toUpperCase()) + 'Handler'
-      if ((this as any)[method]) {
-        ;(this as any)[method](data)
-      } else {
-        throw `没有对应的 ${method} 处理方法, 请进行定义`
-      }
-    } else {
-      console.error('不是自定义 message' + data)
-    }
-  }
-
-  // *******************以下是WebSocket的响应接口********************
-
-  // 初始化, 根据WS的消息调起
-  private initHandler = (data: any) => {
-    const deviceInfo = data.data
-    if (deviceInfo) {
-      store.dispatch(toolActions.setPortIp(deviceInfo.portName))
-    }
-  }
-  private syncJogInPausedHandler = (event: MessageEvent) => {
-    const data = event.data
-    communicator.registerSource(event.data.from || event.data.iframeName, event.source, event.origin)
-    store.dispatch(toolActions.setJogInPaused(data))
-  }
-
-  private syncIPAddressHandler = (data: any) => {
-    const { ip } = data.data
-    if (ip) {
-      store.dispatch(toolActions.setPortIp(ip))
-    }
-  }
-
-  // 同步语言
-  private changeLocaleHandler = (data: any) => {
-    const locale = data.data
-    i18n.changeLanguage(locale.substr(0, 2))
-  }
-  syncExchangeHandler = (event: MessageEvent) => {
-    const deviceStateData = event.data
-    store.dispatch(toolActions.setDeviceStateData(deviceStateData))
-  }
-
-  dobotPlusBlockDataHandler = (event: MessageEvent) => {
-    console.log('websocket dobotPlusBlockDataHandler', event)
-    communicator.registerSource(JSON.parse(event.data).from, event.source, event.origin)
-    const { data, locale, portName } = JSON.parse(event.data)
-    store.dispatch(toolActions.setPortIp(portName))
-    setTimeout(() => {
-      PubSub.publish('dobotPlusBlockData', data)
-    }, 1000)
-    i18n.changeLanguage(locale.substr(0, 2))
-  }
-
-  resetDobotPlusBlockData = (data: any) => {
-    console.log(data)
-    communicator.send({
-      method: 'resetDobotPlusBlockData',
-      data,
-      iframeName: 'alsontech',
-      to: 'blockly'
-    })
-  }
-  syncUserPermissionHandler = (event: MessageEvent) => {
-    console.log('websocket syncUserPermissionHandler', event)
-    communicator.registerSource(event.data.from || event.data.iframeName, event.source, event.origin)
-    const level = JSON.parse(event.data)
-    store.dispatch(userMagamentActions.setCurrentLevel(level))
-  }
-  syncCreditCardInfoHandler = (event: MessageEvent) => {
-    console.log('websocket syncCreditCardInfoHandler', event)
-    communicator.registerSource(event.data.from || event.data.iframeName, event.source, event.origin)
-    store.dispatch(userMagamentActions.setCurrentUserInfo(String(event.data)))
-  }
-  dobotPlusLogout = () => {
-    this.send({
-      method: 'dobotPlusLogout',
-      data: ''
-    })
-  }
-  changeExitLoginTime = (time: any) => {
-    this.send({
-      method: 'changeExitLoginTime',
-      data: time
-    })
-  }
-  sendSkinState = (status: boolean) => {
-    this.send({
-      method: 'sendSkinState',
-      data: status
-    })
-  }
-  // dobot+应用通讯
-  dobotplusQuit = async () => {
-    await this.send({
-      method: 'dobotplusQuit',
-      data: {
-        iframeName: 'dobotplusApp'
-      }
-    })
-  }
-
-  dobotplusCreateProject = async (path: string, projectData: any) => {
-    return this.send({
-      method: 'dobotplusCreateProject',
-      data: { path, projectData }
-    })
-  }
-
-  dobotplusWriteProject = async (path: string, projectData: any) => {
-    return this.send({
-      method: 'dobotplusWriteProject',
-      data: { path, projectData }
-    })
-  }
-
-  dobotplusDeleteProject = async (path: string) => {
-    return this.send({
-      method: 'dobotplusDeleteProject',
-      data: { path }
-    })
-  }
-
-  syncDobotPlusHostHandler = (data: any) => {
-    if (!data.data) return
-    store.dispatch(toolActions.setDobotplusHost(data.data))
-  }
-
-  syncIoDataHandler = (event: MessageEvent) => {
-    const ioData = JSON.parse(event.data)
-    store.dispatch(toolActions.setIoData(ioData))
-  }
-}

package/.dobot/shim.d.ts.txt

@@ -1,3 +0,0 @@
-declare global {
-  var COMPONENT_PATH: string
-}

package/.dobot/store/actions/toolActions.ts.txt

@@ -1,69 +0,0 @@
-import { DeviceState } from '@dobot/store/types'
-
-export const TOOL_ACTIONS_TYPE = {
-  SET_PORT_IP: 'setPortIp',
-  SET_TCP_STATUS: 'setTcpStatus',
-  SET_TCP_INFO: 'setTcpInfo',
-  SET_EXTEND_IO_INDEX: 'setExtendIOData',
-  SET_PORT: 'setPort',
-  SET_ONROBOT_TOOL: 'setOnRobotTool',
-  SET_DEVICE_STATE_DATA: 'setDeviceStateData',
-  SET_PLUGIN_PORT: 'setPluginPort',
-  SET_DOBOTPLUS_HOST: 'setDobotplusHost',
-  SET_IO_DATA: 'setIoData',
-  SET_POINT_DATA: 'setPointData',
-  SET_JOG_IN_PAUSED: 'setJogInPaused'
-}
-
-class ToolActions {
-  setPortIp = (params: string) => ({
-    type: TOOL_ACTIONS_TYPE.SET_PORT_IP,
-    params
-  })
-  setTcpStatus = (params: any) => ({
-    type: TOOL_ACTIONS_TYPE.SET_TCP_STATUS,
-    params
-  })
-  setTcpInfo = (params: any) => ({
-    type: TOOL_ACTIONS_TYPE.SET_TCP_INFO,
-    params
-  })
-  setExtendIOData = (params: any) => ({
-    type: TOOL_ACTIONS_TYPE.SET_EXTEND_IO_INDEX,
-    params
-  })
-  setPort = (params: any) => ({
-    type: TOOL_ACTIONS_TYPE.SET_PORT,
-    params
-  })
-  setOnRobotTool = (params: string[]) => ({
-    type: TOOL_ACTIONS_TYPE.SET_ONROBOT_TOOL,
-    params
-  })
-  setDeviceStateData = (params: DeviceState) => ({
-    type: TOOL_ACTIONS_TYPE.SET_DEVICE_STATE_DATA,
-    params
-  })
-  setPluginPort = (params: DeviceState) => ({
-    type: TOOL_ACTIONS_TYPE.SET_PLUGIN_PORT,
-    params
-  })
-  setDobotplusHost = (params: string) => ({
-    type: TOOL_ACTIONS_TYPE.SET_DOBOTPLUS_HOST,
-    params
-  })
-  setIoData = (params: DeviceState) => ({
-    type: TOOL_ACTIONS_TYPE.SET_IO_DATA,
-    params
-  })
-  setPointData = (params: any[]) => ({
-    type: TOOL_ACTIONS_TYPE.SET_POINT_DATA,
-    params
-  })
-  setJogInPaused = (params: boolean) => ({
-    type: TOOL_ACTIONS_TYPE.SET_JOG_IN_PAUSED,
-    params
-  })
-}
-
-export const toolActions = new ToolActions()

package/.dobot/store/actions/userMagamentActions.ts.txt

@@ -1,25 +0,0 @@
-export const userMagamentActionsType = {
-  SETUSERMODALDATA: 'setUserModalData',
-  SET_PERMISSIONLIST: 'setPermissionList',
-  SET_CURRENT_LEVEL: 'setCurrentLevel',
-  SET_CURRENT_USER_INFO: 'setCurrentUserInfo'
-}
-class UserMagamentActions {
-  setUserModalData = (params: any) => ({
-    type: userMagamentActionsType.SETUSERMODALDATA,
-    params
-  })
-  setPermissionList = (params: any) => ({
-    type: userMagamentActionsType.SET_PERMISSIONLIST,
-    params
-  })
-  setCurrentLevel = (params: any) => ({
-    type: userMagamentActionsType.SET_CURRENT_LEVEL,
-    params
-  })
-  setCurrentUserInfo = (params: any) => ({
-    type: userMagamentActionsType.SET_CURRENT_USER_INFO,
-    params
-  })
-}
-export const userMagamentActions = new UserMagamentActions()

package/.dobot/store/index.ts.txt

@@ -1,7 +0,0 @@
-import { createStore } from 'redux'
-
-import reducers from './reducers'
-
-const store = createStore(reducers)
-
-export default store

package/.dobot/store/reducers/index.ts.txt

@@ -1,8 +0,0 @@
-import { combineReducers } from 'redux'
-import toolReducer from './toolReducer'
-import userMagamentReducer from './userMagamentReducer'
-
-export default combineReducers({
-  toolReducer,
-  userMagamentReducer
-})

package/.dobot/store/reducers/toolReducer.ts.txt

@@ -1,149 +0,0 @@
-import { TOOL_ACTIONS_TYPE } from '../actions/toolActions'
-
-const initialStore = {
-  portData: {
-    ip: '192.168.5.1',
-    port: '22000',
-    isSync: false
-  },
-  tcpStatus: false,
-  tcpInfo: [],
-  extendIoData: [],
-  onRobotTool: [],
-  pluginPort: undefined,
-  dobotplusHost: 'http://localhost:9889',
-  deviceStateData: {
-    prjState: 'stopped'
-  },
-  ioData: {
-    ioList: {
-      input: [...Array(1)].map((item, index) => ({
-        address: index + 1,
-        init: `DI_${index + 1}`,
-        name: `DI_${index + 1}`,
-        editName: '',
-        value: 1,
-        isShow: true,
-        diValue: 0,
-        isDI: false,
-        type: 'Common',
-        configurationStr: '',
-        safeIOKey: 0
-      })),
-      inputSimulation: [...Array(1)].map((item, index) => ({
-        address: index + 1,
-        init: `AD_${index + 1}`,
-        name: `AD_${index + 1}`,
-        editName: '',
-        isShow: true,
-        value: 3.3
-      })),
-      output: [...Array(1)].map((item, index) => ({
-        address: index + 1,
-        init: `DO_${index + 1}`,
-        name: `DO_${index + 1}`,
-        editName: '',
-        value: 0,
-        isShow: true,
-        type: 'Common',
-        configurationStr: '',
-        safeIOKey: 0
-      }))
-    },
-    endEffectorIo: {
-      input: [...Array(1)].map((item, index) => ({
-        address: index + 17,
-        init: `DI_${index + 1}`,
-        name: `DI_${index + 1}`,
-        editName: '',
-        value: 1,
-        isShow: true,
-        diValue: 0,
-        isDI: false
-      })),
-      output: [...Array(1)].map((item, index) => ({
-        address: index + 17,
-        init: `DO_${index + 1}`,
-        name: `DO_${index + 1}`,
-        editName: '',
-        value: 1,
-        isShow: true
-      }))
-    },
-    isShowInputAll: true,
-    isShowOutputAll: true,
-    ioAO: [0, 0],
-    ioAI: [0, 0],
-    ioAIUnit: { mode1: 0, mode2: 0 },
-    ioAOUnit: { mode1: 0, mode2: 0 },
-    endAIUnit: { mode1: 0, mode2: 0, mode3: 0, mode4: 0 },
-    endAI: [0, 0, 0, 0],
-    toolMode: { mode1: 1, mode2: 1 },
-    ioData: {}
-  },
-  pointData: [],
-  jogInPaused: false
-}
-
-const toolReducer = (state = initialStore, action: { type: string; params: any }) => {
-  switch (action.type) {
-    case TOOL_ACTIONS_TYPE.SET_PORT_IP: {
-      return Object.assign({}, state, {
-        portData: {
-          ip: action.params,
-          port: state.portData.port,
-          isSync: true
-        }
-      })
-    }
-    case TOOL_ACTIONS_TYPE.SET_PORT: {
-      return Object.assign({}, state, {
-        portData: {
-          ip: state.portData.ip,
-          port: action.params,
-          isSync: true
-        }
-      })
-    }
-    case TOOL_ACTIONS_TYPE.SET_TCP_STATUS: {
-      return Object.assign({}, state, { tcpStatus: action.params })
-    }
-    case TOOL_ACTIONS_TYPE.SET_TCP_INFO: {
-      return Object.assign({}, state, { tcpInfo: action.params })
-    }
-    case TOOL_ACTIONS_TYPE.SET_EXTEND_IO_INDEX: {
-      const newData = action.params.map((item: any) => {
-        return {
-          name: item.name,
-          DONumber: item.doNumber,
-          DOStart: item.doStart,
-          DINumber: item.diNumber,
-          DIStart: item.diStart
-        }
-      })
-      return Object.assign({}, state, { extendIoData: newData })
-    }
-    case TOOL_ACTIONS_TYPE.SET_ONROBOT_TOOL: {
-      return Object.assign({}, state, { onRobotTool: action.params })
-    }
-    case TOOL_ACTIONS_TYPE.SET_DEVICE_STATE_DATA: {
-      return Object.assign({}, state, { deviceStateData: action.params })
-    }
-    case TOOL_ACTIONS_TYPE.SET_PLUGIN_PORT: {
-      return Object.assign({}, state, { pluginPort: action.params })
-    }
-    case TOOL_ACTIONS_TYPE.SET_DOBOTPLUS_HOST:
-      return Object.assign({}, state, { dobotplusHost: action.params })
-    case TOOL_ACTIONS_TYPE.SET_IO_DATA: {
-      return Object.assign({}, state, { deviceStateData: action.params })
-    }
-    case TOOL_ACTIONS_TYPE.SET_POINT_DATA:
-      return Object.assign({}, state, { pointData: action.params })
-    case TOOL_ACTIONS_TYPE.SET_JOG_IN_PAUSED:
-      return Object.assign({}, state, { jogInPaused: action.params })
-    default:
-      return state
-  }
-}
-
-export default toolReducer

package/.dobot/store/reducers/userMagamentReducer.ts.txt

@@ -1,35 +0,0 @@
-import { userMagamentActionsType } from '../actions/userMagamentActions'
-import { userMagamentState } from '@dobot/store/types'
-
-const initialStore: userMagamentState = {
-  userModalData: {
-    show: false
-  },
-  permissionList: [
-    [1, 'TR_LEVEL_1'],
-    [2, 'TR_LEVEL_2'],
-    [3, 'TR_LEVEL_3']
-  ],
-  currentLevel: 0,
-  currentUserInfo: ''
-}
-const userMagamentReducer = (state = initialStore, action: { type: string; params: any }) => {
-  switch (action.type) {
-    case userMagamentActionsType.SETUSERMODALDATA: {
-      return Object.assign({}, state, { userModalData: action.params })
-    }
-    case userMagamentActionsType.SET_PERMISSIONLIST: {
-      return Object.assign({}, state, { permissionList: action.params })
-    }
-    case userMagamentActionsType.SET_CURRENT_LEVEL: {
-      return Object.assign({}, state, { currentLevel: action.params })
-    }
-    case userMagamentActionsType.SET_CURRENT_USER_INFO: {
-      return Object.assign({}, state, { currentUserInfo: action.params })
-    }
-    default:
-      return state
-  }
-}
-
-export default userMagamentReducer