Return method tagged "order" in the handler.
353558
def orders(self):
        
        return [order_cmd for order_cmd in dir(self.handler)
                if getattr(getattr(self.handler, order_cmd), "bot_order", False)]
246593
def orders(order_uuid = nil)
      if order_uuid
        Endpoints::SpecificOrder.new(order_uuid)
      else
        Endpoints::Orders.new
      end
    end
149210
function orderby (args, order) {
    if (this.typecheck) t.typecheck('orderby', [args, order]);
    
    var o = (order&&'string'===typeof order) ? order : '';
    var result = [];

    if ('string'===typeof args) {
        result = o ? [args+' '+o] : [args];
    }
    else if (args instanceof Array) {
        for (var i=0; i < args.length; i++) {
            if ('string'===typeof args[i]) {
                o ? result.push(args[i]+' '+o) : result.push(args[i]);
            }
            else if ('object'===typeof args[i]) {
                var key = Object.keys(args[i])[0];
                result.push(key+' '+args[i][key]);
            }
        }
    }
    else if (args instanceof Object) {
        var key = Object.keys(args)[0];
        result = [key+' '+args[key]];
    }

    return 'order by '+result.join();
}
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)
315761
def order(self, order):
    '''

    '''
    order = order if isinstance(order, Order) else Order(order)

    # ensure order gets attr values the same way the rest of the query does.
    order.object_getattr = self.object_getattr
    self.orders.append(order)
    return self
650179
def ordered_tags(self):
        
        tags = list(self.tags.all())
        return sorted(
            tags,
            key=lambda tag: ((type(tag) != Tag) * 100000) + tag.count(),
            reverse=True
        )
1337698
def get_order(self, codes):
        """"""
        return sorted(codes, key=lambda e: [self.ev2idx.get(e)])
82270
def order(self, field, order=None):
        
        if not order:
            order = ORDER.DESC
        self.url.order = (field, order)
        self.url.set_page(1)
        return self
568467
def fetch(self, order_id, data={}, **kwargs):
        "
        return super(Order, self).fetch(order_id, data, **kwargs)
740003
public Order ORDER(DomainObjectMatch<?> toOrder) {
		DomainObjectMatch<?> delegate = APIAccess.getDelegate(toOrder);
		DomainObjectMatch<?> match = delegate != null ? delegate : toOrder;
		OrderExpression oe = this.queryExecutor.getOrderFor(match);
		Order ret = APIAccess.createOrder(oe);
		QueryRecorder.recordInvocation(this, "ORDER", ret, QueryRecorder.placeHolder(match));
		return ret;
	}
1130581
def query_order(self, status=None, begintime=None, endtime=None):
        
        return self._post(
            'merchant/order/getbyfilter',
            data={
                'status': status,
                'begintime': begintime,
                'endtime': endtime
            }
        )
983029
def placeOrder(self, id, contract, order):
        """"""
        return _swigibpy.EClientSocketBase_placeOrder(self, id, contract, order)
1226286
def order_by(self, order_attribute):
        '''  '''
        to_return = []
        for f in sorted(self.items, key=lambda i: getattr(i, order_attribute)):
            to_return.append(f)
        return to_return
1322337
public static function getOrder()
    {
        $cls = get_called_class();
        return array_key_exists($cls, self::$_order) ? self::$_order[$cls] : "";
    }
513656
@RequestMapping(path = "", method = RequestMethod.GET)
    public Page<Order> getOrder(Pageable pageable) {
        return orderService.getOrders(pageable);
    }
313894
def get_ordering(self, request, queryset, view):
        
        params = view.get_request_feature(view.SORT)
        if params:
            fields = [param.strip() for param in params]
            valid_ordering, invalid_ordering = self.remove_invalid_fields(
                queryset, fields, view
            )

            # if any of the sort fields are invalid, throw an error.
            # else return the ordering
            if invalid_ordering:
                raise ValidationError(
                    "Invalid filter field: %s" % invalid_ordering
                )
            else:
                return valid_ordering

        # No sorting was included
        return self.get_default_ordering(view)
843569
def tag_dict(obj, *args, **kwargs):
    """"""

    if isinstance(obj, OrderedDict):
        return _TaggedOrderedDict(obj, *args, **kwargs)
    else:
        return _TaggedPlainDict(obj, *args, **kwargs)