Callback for "order-get" command
19108
public function cmdGetOrder()
    {
        $result = $this->getListOrder();
        $this->outputFormat($result);
        $this->outputFormatTableOrder($result);
        $this->output();
    }
108444
def order(self, *args):
    """"""
    # q.order(Employee.name, -Employee.age)
    if not args:
      return self
    orders = []
    o = self.orders
    if o:
      orders.append(o)
    for arg in args:
      if isinstance(arg, model.Property):
        orders.append(datastore_query.PropertyOrder(arg._name, _ASC))
      elif isinstance(arg, datastore_query.Order):
        orders.append(arg)
      else:
        raise TypeError('order() expects a Property or query Order; '
                        'received %r' % arg)
    if not orders:
      orders = None
    elif len(orders) == 1:
      orders = orders[0]
    else:
      orders = datastore_query.CompositeOrder(orders)
    return self.__class__(kind=self.kind, ancestor=self.ancestor,
                          filters=self.filters, orders=orders,
                          app=self.app, namespace=self.namespace,
                          default_options=self.default_options,
                          projection=self.projection, group_by=self.group_by)
639528
function getOrder(account, identifier, callback) {
  validate.address(account);
  validate.identifier(identifier);

  var txRequest = this.remote.requestTx({
    hash: identifier
  });

  txRequest.once('error', callback);
  txRequest.once('transaction', function(response) {
    if (response.TransactionType !== 'OfferCreate'
        && response.TransactionType !== 'OfferCancel') {
      callback(new InvalidRequestError('Invalid parameter: identifier. '
        + 'The transaction corresponding to the given identifier '
        + 'is not an order'));
    } else {
      var options = {
        account: account,
        identifier: identifier
      };
      asyncify(TxToRestConverter.parseOrderFromTx)(response, options, callback);
    }
  });
  txRequest.request();
}
396366
public function get($orderId, array $params = array())
    {
        $endpoint = '/admin/orders/'.$orderId.'.json';
        $response = $this->request($endpoint, 'GET', $params);
        return $this->createObject(Order::class, $response['order']);
    }
866645
function get(command) {
        var commandID;
        if (!command) {
            console.error("Attempting to get a Sort method with a missing required parameter: command");
            return;
        }

        if (typeof command === "string") {
            commandID = command;
        } else {
            commandID = command.getID();
        }
        return _sorts[commandID];
    }
235897
def _get_order_by(self, request):
        
        attr = request.params.get('sort', request.params.get('order_by'))
        if attr is None or not hasattr(self.mapped_class, attr):
            return None
        if request.params.get('dir', '').upper() == 'DESC':
            return desc(getattr(self.mapped_class, attr))
        else:
            return asc(getattr(self.mapped_class, attr))
1052974
def open_orders(self, symbol=None):
        """"""
        api = "order"
        query = {'ordStatus.isTerminated': False }
        if symbol != None:
            query['symbol'] =symbol
        orders = self._curl_bitmex(
            api=api,
            query={'filter': json.dumps(query)},
            verb="GET"
        )
        return orders
890215
def cmd(send, _, args):
    
    apikey = args['config']['api']['ebayapikey']
    categories = get_categories(apikey)
    item = None
    while not item:
        item = get_item(choice(categories), apikey)
    send(item)
11799
def retrieve_order(self, order_id):
        """"""

        response = self.request(E.retrieveOrderSslCertRequest(
            E.id(order_id)
        ))

        return response.as_model(SSLOrder)
983029
def placeOrder(self, id, contract, order):
        """"""
        return _swigibpy.EClientSocketBase_placeOrder(self, id, contract, order)
925773
public function orderBy($order, $append = true, $first = false)
    {
        return $this->command->orderBy($order, $append, $first);
    }
703337
static function fetchListByOrder( $orderID, $asObject = true )
    {
        $db = eZDB::instance();

        $orderID = (int)$orderID;
        $rows = $db->arrayQuery(  "SELECT ezorder_status_history.*, ezorder_status.name AS status_name " .
                                  "FROM ezorder_status_history, ezorder_status " .
                                  "WHERE order_id = $orderID AND" .
                                  "      ezorder_status.status_id = ezorder_status_history.status_id " .
                                  "ORDER BY ezorder_status_history.modified DESC" );

        return eZPersistentObject::handleRows( $rows, 'eZOrderStatusHistory', $asObject );
    }
1184268
def order(self):
        
        from ..resources.orders import Order
        url = self._get_link('order')
        if url:
            resp = self.client.orders.perform_api_call(self.client.orders.REST_READ, url)
            return Order(resp, self.client)
812105
def get_order(self, id, **data):
        
        
        return self.get("/orders/{0}/".format(id), data=data)
1101967
function fetchOrderStatus()
    {
        $statusList = eZOrderStatus::fetchMap( true, true );
        if ( isset( $statusList[$this->StatusID] ) )
        {
            return $statusList[$this->StatusID];
        }
        return false;
    }
542953
function getDrives(command, callback) {
    var child = exec(
        command,
        function (err, stdout, stderr) {
            if (err) return callback(err);
            var drives = stdout.split('\n');

            drives.splice(0, 1);
            drives.splice(-1, 1);

            // Removes ram drives
            drives = drives.filter(function(item){ return item != "none"});
            callback(null, drives);
        }
    );
}
821156
function( json, field, params, callback ){
    field = field || 'id';
    var objectIds = [],
      props;

    if (params.orderByFields && params.orderByFields !== ''){
      var fld = params.orderByFields.split(' ');
      var order = params.orderByFields;
      if (fld[fld.length-1] == 'DESC'){
        order = '-' + params.orderByFields;
      }
      json.features = this.orderBy(json.features, params.orderByFields, order);
    }

    json.features.forEach( function(f){
      props = f.attributes || f.properties;
      objectIds.push( props[ field ] );
    });

    callback( null, {
      objectIdField: field,
      objectIds: objectIds
    });
  }