How to use the 0x.js.ZeroEx.getOrderHashHex function in 0x

submitOrder ({commit, state, dispatch}, order) {
    // console.log('hier?')
    console.log(order)

    if (typeof order === 'string') order = JSON.parse(order)
    // {
    //   try {
    //     ZeroEx.isValidSignature(order)
    //   } catch (error) {
    //     console.error(error)
    //     dispatch('addNotification', {type: 'error', 'text': 'Order failed, check log for details'})
    //   }
    // }
    try {
      var orderHash = ZeroEx.getOrderHashHex(order)
      console.log('HASH', orderHash)
      return zeroEx.signOrderHashAsync(orderHash, state.addresses[0]).then((ecSignature) => {
        const signedOrder = {
          ...order,
          ecSignature
        }
        // console.log(signedOrder)
        // commit('ADD_ORDER', signedOrder)
        return axios.post('/order/new', signedOrder).then((results) => {
          // console.log(results)
          dispatch('pageServer')
          dispatch('addNotification', {type: 'success', 'text': 'Order Added'})
        }).catch((error) => {
          dispatch('addNotification', {type: 'error', 'text': 'Order failed, check log for details'})
          console.error(error)
        })

predicate: (data, cb) => {
    let result = validator.validate(data.payload, orderSchema);
    if (!result.valid) {
      return cb('Invalid Order', result.errors);
    }

    let order: SignedOrder = data.payload;
    let orderHex = ZeroEx.getOrderHashHex(order);
    let validSignature = ZeroEx.isValidSignature(orderHex, order.ecSignature, order.maker)
    if (!validSignature) {
      return cb('Invalid Order Signature', order.ecSignature);
    }

    // TODO validateOrderFillableOrThrowAsync with an Infura/Local Provider
    cb(null, data);
  }
};

//   logger.log('debug', `Order ${orderHash} is not fillable`);
    // }
    // const isValidSig = await ZeroEx.isValidSignature(
    //   orderHash,
    //   possibleOrder.ecSignature,
    //   possibleOrder.maker
    // );
    // if (!isValidSig) {
    //   logger.log('debug', `Invalid signature for order: ${orderHash}`);
    //   const e = {
    //     code: 1005,
    //     message: 'Invalid signature',
    //   };
    // }

    const orderHash = ZeroEx.getOrderHashHex(signedOrder);
    const takerTokenRemainingAmount = await this.getRemainingTakerAmount(
      orderHash,
      signedOrder.takerTokenAmount
    );
    const addedOrder = await this.repository.addOrder(
      orderHash,
      takerTokenRemainingAmount,
      signedOrder
    );
    const {
      baseToken,
      quoteToken,
    } = await this.repository.getBaseTokenAndQuoteTokenFromMakerAndTaker(
      addedOrder.takerTokenAddress,
      addedOrder.makerTokenAddress
    );

public success(data): CreateOrderSuccessResult {
    let correlationId: string = uuid.v4();
    let orderHashHex = ZeroEx.getOrderHashHex(data);
    let orderHash = orderHashHex.split('0x')[1];
    data.id = orderHash;
    let command: Command = {
      'command': 'createOrder',
      'aggregateId': orderHash,
      'id': correlationId,
      'payload': data
    }

    this._msgbus.emitCommand(command);
    return { id: correlationId };
  }

async watchOrder(order: SignedOrder) {
    const orderHash = ZeroEx.getOrderHashHex(order);
    console.log(orderHash);
    if (this.watchedOrders.has(orderHash)) {
      return;
    }
    this.watchedOrders.add(orderHash);
    return await this.zeroEx.orderStateWatcher.addOrder(order);
  }

})
      return
    }

    try {
      JSON.parse(this.state.order)
    } catch (e) {
      this.setState({
        error: 'Order must be in JSON format i.e. {\'key\':\'value\',...}'
      })
      return
    }

    try {
      let calculatedOrderHash =
      ZeroEx.getOrderHashHex(JSON.parse(this.state.order))
      if (ZeroEx.isValidOrderHash(this.state.hash)) {
        if (calculatedOrderHash === this.state.hash) {
          this.setState({success: true})
        } else {
          this.setState({
            error: 'The hash does not match the order.'
          })
        }
      } else {
        this.setState({
          error: 'The hash should look be in the following format 0x4jdsf...'
        })
      }
    } catch (e) {
      this.setState({
        error: 'Order must conform to the 0x message format (see: https://0xproject.com/wiki#Message-Format)'

async function createOrderEnvironmentValuesAsync(url: string) {
    const httpClient = new HttpClient(url);
    const orders = await httpClient.getOrdersAsync();
    const orderIfExists = _.head(orders);
    if (!_.isUndefined(orderIfExists)) {
        return [
            createEnvironmentValue('order', JSON.stringify(orderIfExists)),
            createEnvironmentValue('orderMaker', orderIfExists.maker),
            createEnvironmentValue('orderTaker', orderIfExists.taker),
            createEnvironmentValue('orderFeeRecipient', orderIfExists.feeRecipient),
            createEnvironmentValue('orderHash', ZeroEx.getOrderHashHex(orderIfExists)),
        ];
    } else {
        logUtils.log(`${chalk.red(`No orders from /orders found`)}`);
        return [
            createEnvironmentValue('order', ''),
            createEnvironmentValue('orderMaker', ''),
            createEnvironmentValue('orderTaker', ''),
            createEnvironmentValue('orderFeeRecipient', ''),
            createEnvironmentValue('orderHash', ''),
        ];
    }
}
function getContractAddresses(networkId: number) {

private async handleOrderAddedEvent(orderAddedEvent: OrderEvent) {
    const { type, payload } = orderAddedEvent;
    const signedOrder = deserializeSignedOrder(orderAddedEvent.payload.order as any);
    const orderHash = ZeroEx.getOrderHashHex(orderAddedEvent.payload.order);
    this.log(
      'debug',
      `OrderWatcher: New order added, adding to active watcher ${orderHash}`,
      orderAddedEvent
    );
    this.watchOrder(signedOrder);
  }