taobao.logistics.online.cancel 取消物流订单接口
        
        调此接口取消发货的订单，重新选择物流公司发货。前提是物流公司未揽收货物。对未发货和已经被物流公司揽收的物流订单，是不能取消的。
761782
def cancel(self, tid, session):
        ''''''
        request = TOPRequest('taobao.logistics.online.cancel')
        request['tid'] = tid
        self.create(self.execute(request, session), fields = ['is_success','modify_time','recreated_order_id'], models = {'modify_time':TOPDate})
        return self
1205167
def cancel_order(self, order_id, stock):
        
        url_fragment = 'venues/{venue}/stocks/{stock}/orders/{order_id}'.format(
            venue=self.venue,
            stock=stock,
            order_id=order_id,
        )
        url = urljoin(self.base_url, url_fragment)
        return self.session.delete(url).json()
585254
def build_request_cancelar_transacao numero_transacao
      # Montar os parâmetros para consulta
      params = {
        operacao: {
          codigo_estabelecimento: SuperpayApi.estabelecimento,
          numero_transacao: numero_transacao,
          operacao: 2,
        }
      }
      # Adiciona as configurações de login
      params.merge! SuperpayApi.login
    end
305018
def QA_SU_save_stock_terminated(client=DATABASE):
    '''
    
    '''

    # 🛠todo 已经失效从wind 资讯里获取
    # 这个函数已经失效
    print("！！！ tushare 这个函数已经失效！！！")
    df = QATs.get_terminated()
    #df = QATs.get_suspended()
    print(
        " Get stock terminated from tushare,stock count is %d  (终止上市股票列表)" %
        len(df)
    )
    coll = client.stock_terminated
    client.drop_collection(coll)
    json_data = json.loads(df.reset_index().to_json(orient='records'))
    coll.insert(json_data)
    print(" 保存终止上市股票列表 到 stock_terminated collection， OK")
1101135
def get(self, date, page_no=1, page_size=40, fields=[]):
        ''''''
        request = TOPRequest('taobao.taobaoke.items.get')
        request['date'] = date
        request['page_no'] = page_no
        request['page_size'] = page_size
        if not fields:
            fields = self.fields
        request['fields'] = fields
        self.create(self.execute(request)['taobaoke_report'])
        return self
570816
public boolean removeThriftServer(ThriftServerInfo thriftServerInfo) {
		// 不存在这台服务器 直接返回失败
		if (!thriftServers.contains(thriftServerInfo)) {
			return false;
		}

		serverListLock.writeLock().lock();
		try {
			Iterator<ThriftConnectionPartition<T>> iterator = partitions.iterator();
			while (iterator.hasNext()) {
				ThriftConnectionPartition<T> thriftConnectionPartition = iterator.next();
				if (thriftConnectionPartition.getThriftServerInfo().equals(thriftServerInfo)) {
					thriftConnectionPartition.setUnableToCreateMoreTransactions(false);
					List<ThriftConnectionHandle<T>> clist = new LinkedList<>();
					thriftConnectionPartition.getFreeConnections().drainTo(clist);
					for (ThriftConnectionHandle<T> c : clist) {
						destroyConnection(c);
					}
					thriftConnectionPartition.stopThreads();
					partitions.remove(thriftConnectionPartition);
					thriftServers.remove(thriftServerInfo);
					thriftServerCount = partitions.size();
					logger.info("移除服务器操作完成 剩余服务器数量：" + getThriftServerCount());
					if (getThriftServerCount() == 0) {
						logger.warn("连接池中没有可用thrift服务器 无法获取连接");
					}
					return true;
				}
			}
		} catch (Exception e) {
			logger.error("移除Thrift服务器失败  ip:" + thriftServerInfo.getHost() + " 端口：" + thriftServerInfo.getPort());
			return false;
		} finally {
			serverListLock.writeLock().unlock();
		}
		return false;
	}
598296
def cancel(self,order_id):
        ''' 
        '''
        url= 'https://coincheck.com/api/exchange/orders/' + order_id
        headers = make_header(url,access_key=self.access_key,secret_key=self.secret_key)
        r = requests.delete(url,headers=headers)
        return json.loads(r.text)
593205
function fn(metadataGetter, dataAdapter, opts = {}) {
    if (typeof metadataGetter !== 'function') {
        throw new Error(`'metadataGetter' must be a function.`);
    }
    if (typeof dataAdapter !== 'object') {
        throw new Error(`dataAdapter' must be an object.`);
    }
    Object.assign(metadata, metadataGetter.call(null));

    if (!opts.strategy) {
        if (opts.router) {
            opts.strategy = 'ROUTER';
        } else {
            opts.strategy = 'MIDDLEWARE';
        }
    }

    if (typeof opts.getLocaleString !== 'function') {
        opts.getLocaleString = (key) => {
            const object = {
                mongoose_adapter_error_list: '查询失败，请稍后重试',
                mongoose_adapter_error_count: '查询失败，请稍后重试',
                mongoose_adapter_error_id: '查询失败，请稍后重试',
                mongoose_adapter_error_create: '新增失败',
                mongoose_adapter_error_update: '更新失败',
                mongoose_adapter_error_remove: '删除失败',
            };
            return object[key];
        };
    }

    switch (opts.strategy) {
        case 'ROUTER':
            // 路由器挂载
            if (!opts.router) {
                throw new Error(`'router' can not be empty when using ROUTER strategy.`);
            }
            return routerStrategy(metadata, dataAdapter, opts);
        case 'MIDDLEWARE':
            // 中间件过滤
            if (opts.filter && typeof opts.filter !== 'function') {
                throw new Error(`'filter' must be a function type.`);
            }
            return middlewareStrategy(metadata, dataAdapter, opts);
            break;
    }
}
66182
public static void pickupFromRequest(RpcInvokeContext context, SofaRequest request, boolean init) {
        if (context == null && !init) {
            return;
        }
        // 解析请求 
        Map<String, String> requestBaggage = (Map<String, String>) request
            .getRequestProp(RemotingConstants.RPC_REQUEST_BAGGAGE);
        if (CommonUtils.isNotEmpty(requestBaggage)) {
            if (context == null) {
                context = RpcInvokeContext.getContext();
            }
            context.putAllRequestBaggage(requestBaggage);
        }
    }
1226825
def refunds_get(self, **kwargs):
        ''''''
        request = TOPRequest('taobao.increment.refunds.get')
        for k, v in kwargs.iteritems():
            if k not in ('status', 'nick', 'start_modified', 'end_modified', 'page_no', 'page_size') and v==None: continue
            request[k] = v
        self.create(self.execute(request), fields=['notify_refunds', 'total_results'], models={'notify_refunds':NotifyRefund})
        return self.notify_refunds
78373
def update(self, pid, session, **kwargs):
        ''''''
        request = TOPRequest('taobao.fenxiao.product.update')
        request['pid'] = pid
        for k, v in kwargs.iteritems():
            if k not in ('name', 'standard_price', 'cost_price', 'retail_price_low', 'retail_price_high', 'outer_id', 'quantity', 'alarm_number','desc','prov','city','postage_type','postage_id','postage_ordinary','postage_fast','postage_ems','status','sku_ids','sku_cost_prices','sku_quantitys','sku_outer_ids','have_invoice','have_guarantee','discount_id','sku_standard_prices','sku_properties','sku_properties_del','is_authz','pic_path','image','properties','property_alias','input_properties','dealer_cost_price','sku_dealer_cost_prices','category_id') and v==None: continue
            request[k] = v
        self.create(self.execute(request, session), fields=['pid','modified'], models={'modified':TOPDate})
        return self
810297
def cancel(self, orderID):
        """"""
        api = "order"
        postdict = {
            'orderID': orderID,
        }
        return self._curl_bitmex(api=api, postdict=postdict, verb="DELETE")
202002
function(_bid,_cid,_data){
        var _batch = _xcache[_bid];
        if (!_batch) return;
        try{
            (_batch.h[_cid].c||f)(_data);
        }catch(ex){
            __onError(
                _bid,_cid,{
                    code:_g._$CODE_ERRCABK,
                    message:'DWR回调执行异常：'+ex.message||ex
                }
            );
        }
    }
464395
function isRegularHoliday (date) {
  date = this.toDate(date);
  if (!date) {
    return null;
  }

  var regular = this._regularHoliday;

  if (typeof regular === 'object') {
    var w = date.getDay();

    // 週
    if (regular.week[w]) {
      return true;
    }

    // 日
    if (regular.day[date.getDate()]) {
      return true;
    }

    // 第ny曜日
    var n = parseInt((date.getDate() + 6) / 7, 10);
    if (regular.xweek[n + '-' + w]) {
      return true;
    } else if (regular.xweek['5-' + w]) {
      var nextW = new Date(date.getTime() + A_WEEK);
      if (nextW.getMonth() !== date.getMonth()) {
        return true;
      }
    }

    return false;
  }

  if (typeof regular === 'function') {
    return regular(date);
  }

  return false;
}
783076
def cancel(self, order_id):
        """"""

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

        return int(response.data.id)
1092972
def detail_get(self, session, fields=[], **kwargs):
        ''''''
        request = TOPRequest('taobao.logistics.orders.detail.get')
        if not fields:
            shipping = Shipping()
            fields = shipping.fields
        request['fields'] = fields
        for k, v in kwargs.iteritems():
            if k not in ('tid', 'buyer_nick', 'status', 'seller_confirm', 'receiver_name', 'start_created', 'end_created', 'freight_payer', 'type', 'page_no', 'page_size') and v==None: continue
            request[k] = v
        self.create(self.execute(request, session))
        return self.shippings
1198043
function(url, config) {
        config = config || {}

        // 获取头信息
        let realReq = setRequest(ctx, url, config);

        // 扩展请求头信息
        let headersObj = Object.assign({}, realReq.headers, config.headers)

        // 获取请求数据配置
        let requestData = parseData(ctx, config);

        // 请求request的最终配置
        let requestOpt = Object.assign({}, options, {
          uri: realReq.uri,
          method: realReq.method,
          headers: headersObj,
          timeout: undefined,
          gzip: false,
          encoding: null
        }, requestData, config.conf);

        // 发送请求前的钩子，可以对requestjs的参数自定义任何操作
        config.onBeforeRequest && config.onBeforeRequest.call(ctx, proxyName, requestOpt)

        return request(ctx, {
          needPipeRes: true
        }, requestOpt);
      }