Retrieves an Issuing <code>Card</code> object.
9022
public static Card retrieve(String card) throws StripeException {
    return retrieve(card, (Map<String, Object>) null, (RequestOptions) null);
  }
856105
def retrieve(payment_id):
        
        http_client = HttpClient()
        response, __ = http_client.get(routes.url(routes.PAYMENT_RESOURCE, resource_id=payment_id))
        return resources.Payment(**response)
1088893
def GetATR(self, reader):
        """"""
        atr = "no card inserted"
        try:
            if not type(reader) is str:
                connection = reader.createConnection()
                connection.connect()
                atr = toHexString(connection.getATR())
                connection.disconnect()
        except NoCardException:
            pass
        except CardConnectionException:
            pass
        return atr
1148047
function (cb) {
                  // card key
                  var url = options.url.replace(/light=true/i, ''),
                    params = {
                      legacyCardKey: Utils.getLegacyCardKey(url, process.env.CARD_SECRET),
                      cardKey: Utils.getCardKey(url, process.env.CARD_SECRET)
                    };

                  // extract input values
                  _.each(_.keys(options.inputValues), function (key) {
                    params[key] = options.inputValues[key];
                  });

                  if (options.inputValues.token) {

                    // retrieve previously saved parameters. Add or replace params
                    DB.unlock(options.packName, options.cardName, options.inputValues.token, process.env.LOCK_KEY, function (err, payload) {
                      if (err) {
                        // Ignore error and just return the params.
                        cb(null, params);
                      }
                      else {
                        if (payload && _.isObject(payload)) {
                          _.each(_.keys(Card.inputs), function (key) {
                            if (payload[key]) {
                              params[key] = Base64.decode(payload[key]);
                            }
                          });
                        }

                        cb(null, params);
                      }
                    });
                  }
                  else {
                    cb(null, params);
                  }
                }
1168813
public function getCode($code, $card_id = null, $check_consume = null)
    {
        $data = ['code' => $code];
        is_null($card_id) || $data['card_id'] = $card_id;
        is_null($check_consume) || $data['check_consume'] = $check_consume;
        $url = "https://api.weixin.qq.com/card/code/get?access_token=ACCESS_TOKEN";
        $this->registerApi($url, __FUNCTION__, func_get_args());
        return $this->httpPostForJson($url, $data);
    }
1336768
public function getCard($cardId)
    {
        if (!$this->stripe_id) {
            return null;
        }

        $customer = $this->asStripeCustomer();

        foreach ($customer->sources->data as $card) {
            if ($card->id === $cardId) {
                return $card;
            }
        }

        return null;
    }
837532
function (card) {
	if (typeof card == 'number')
		return card >= 1 && card <= deckSize ? card : undefined; // Already codified
	if (typeof card != 'string' || card.length != 2)
		return undefined; // Invalid input
	var posRank = abbr[card[0]];
	var posSuit = (abbr[card[1]] - ranks.length) >> 1;
	if (typeof posRank != 'number' || posRank >= ranks.length || posSuit < 0)
		return undefined; // Invalid characters
	return posRank * suits.length + posSuit + 1;
}
916163
def retrieve(cls, *args, **kwargs):
        """"""
        return super(Card, cls).retrieve(*args, **kwargs)
851775
public static CardTerminal getTheReader(String spec) throws CardException {
        try {
            String msg = "This application expects one and only one card reader (with an inserted card)";
            TerminalFactory tf = getTerminalFactory(spec);
            CardTerminals tl = tf.terminals();
            List<CardTerminal> list = tl.list(State.CARD_PRESENT);
            if (list.size() > 1) {
                throw new CardException(msg);
            } else if (list.size() == 1) {
                return list.get(0);
            } else {
                List<CardTerminal> wl = tl.list(State.ALL);
                // FIXME: JNA-s CardTerminals.waitForChange() does not work
                if (wl.size() == 1) {
                    CardTerminal t = wl.get(0);
                    System.out.println("Waiting for a card insertion to " + t.getName());
                    if (t.waitForCardPresent(0)) {
                        return t;
                    } else {
                        throw new CardException("Could not find a reader with a card");
                    }
                } else {
                    throw new CardException(msg);
                }
            }
        } catch (NoSuchAlgorithmException e) {
            throw new CardException(e);
        }
    }
1223862
public function defaultCard()
    {
        if (! $this->hasStripeId()) {
            return;
        }

        $customer = $this->asStripeCustomer();

        foreach ($customer->sources->data as $card) {
            if ($card->id === $customer->default_source) {
                return $card;
            }
        }
    }
1290077
function (params, cb) {
                  DB.getCardState(params.cardKey, params.legacyCardKey, function (err, state) {
                    cb(null, params, state);
                  });
                }
1250785
func Get(id string, params *stripe.IssuingCardParams) (*stripe.IssuingCard, error) {
	return getC().Get(id, params)
}
919663
def get_referenced_object(self):
        

        if self._BillingInvoice is not None:
            return self._BillingInvoice

        if self._DraftPayment is not None:
            return self._DraftPayment

        if self._MasterCardAction is not None:
            return self._MasterCardAction

        if self._Payment is not None:
            return self._Payment

        if self._PaymentBatch is not None:
            return self._PaymentBatch

        if self._RequestResponse is not None:
            return self._RequestResponse

        if self._ScheduleInstance is not None:
            return self._ScheduleInstance

        if self._TabResultResponse is not None:
            return self._TabResultResponse

        if self._WhitelistResult is not None:
            return self._WhitelistResult

        raise exception.BunqException(self._ERROR_NULL_FIELDS)
487019
public function getCard(string $token)
    {
        // Lof Debug
        $this->flow->getLogger()->debug("Retrieving Card with token $token");

        $resource = $this->make(
            $this->flow->send(
                'get',
                $this->endpoint . '/getRegisterStatus',
                ['token' => $token]
            )
        );

        $resource->setExists((int)$resource->status === 1);

        return $resource;
    }
47722
def get_referenced_object(self):
        

        if self._Payment is not None:
            return self._Payment

        if self._PaymentBatch is not None:
            return self._PaymentBatch

        raise exception.BunqException(self._ERROR_NULL_FIELDS)
489664
def card(self):
        
        body, more, is_markdown = self._entry_content
        return TrueCallableProxy(
            self._get_card,
            body or more) if is_markdown else CallableProxy(None)
1138845
def getATR(reader):
    """"""
    connection = reader.createConnection()
    atr = ""
    try:
        connection.connect()
        atr = smartcard.util.toHexString(connection.getATR())
        connection.disconnect()
    except smartcard.Exceptions.NoCardException:
        atr = "no card inserted"
    return atr