def process_event(self, event):
        # return event in generic type from websocket

        # if this event in general type it was send from start function and need call firs_copy
        if 'exchange' in event:
            return event

        if event['e'] == 'outboundAccountPosition':
            self.is_last_order_event_completed = True

        if event['e'] == 'executionReport':
            if event['X'] == 'FILLED':
                return
            elif event['x'] == 'CANCELED':
                return Actions.ActionCancel(
                    event['s'],
                    event['p'],
                    event['i'],
                    self.exchange_name,
                    event
                )
            self.last_order_event = event  # store event order_event coz we need in outboundAccountInfo event
            # sometimes can came event executionReport x == filled and x == new together so we need flag
            self.is_last_order_event_completed = False
            return

        elif event['e'] == 'outboundAccountInfo':
            if self.is_last_order_event_completed:
                return

            order_event = self.last_order_event

            if order_event['s'] not in self.pairs:
                return

            if order_event['o'] == 'MARKET':  # if market order, we haven't price and cant calculate quantity
                order_event['p'] = self.connection.get_ticker(symbol=order_event['s'])['lastPrice']

            # part = self.get_part(order_event['s'], order_event['q'], order_event['p'], order_event['S'])

            self.on_balance_update(event)

            # shortcut mean https://github.com/binance-exchange/binance-official-api-docs/blob/master/user-data-stream.md#order-update
            order = Order(order_event['p'],
                          order_event['q'],
                          self.get_part(order_event['s'], order_event['q'], order_event['p'], order_event['S']),
                          order_event['i'],
                          order_event['s'],
                          order_event['S'],
                          order_event['o'],
                          self.exchange_name,
                          order_event['P'])
            return Actions.ActionNewOrder(order,
                                          self.exchange_name,
                                          event)
    def process_event(self, event):
        # self.update_balance()
        self.balance_updated = False

        if event['action'] == "insert":

            check_result = self.check_expected_order(event)
            if check_result:
                return check_result

            data = event['data'][0]
            if data['ordStatus'] == 'New' \
                    or (data['ordStatus'] == 'Filled' and 'ordType' in data):
                if event['data'][0]['execInst'] == 'Close':
                    # order to close position came
                    close_order = event['data'][0]

                    if close_order['ordType'] == 'Market':
                        price = None
                    else:
                        price = close_order['price']

                    return Actions.ActionClosePosition(
                        self.translate(close_order['symbol']),
                        self.translate(close_order['ordType']),
                        price,
                        close_order['orderID'],
                        self.exchange_name,
                        event
                    )
                else:
                    order = self._self_order_to_global(event['data'][0])

                    return Actions.ActionNewOrder(
                        order,
                        self.exchange_name,
                        event)

        elif event['action'] == 'update':
            if 'ordStatus' not in event['data'][0]:
                return
            if event['data'][0]['ordStatus'] == 'Canceled':
                orders = self.socket[event['data'][0]['symbol']].open_orders(clOrdIDPrefix="")
                order = list(filter(lambda o: o['orderID'] == event['data'][0]['orderID'],
                                    orders))[0]
                global_order = self._self_order_to_global(order)
                return Actions.ActionCancel(
                    global_order.symbol,
                    global_order.price,
                    global_order.id,
                    self.exchange_name,
                    event
                )