Retrieves the details of an issuer fraud record that has previously been created.

<p>Please refer to the <a href="#issuer_fraud_record_object">issuer fraud record</a> object
reference for more details.
337521
public static IssuerFraudRecord retrieve(String issuerFraudRecord) throws StripeException {
    return retrieve(issuerFraudRecord, (Map<String, Object>) null, (RequestOptions) null);
  }
770749
def _get_record(self, record_type):
        
        if (not self.has_record_type(record_type) and
                record_type.get_identifier() not in self._record_type_data_sets):
            raise errors.Unsupported()
        if str(record_type) not in self._records:
            record_initialized = self._init_record(str(record_type))
            if record_initialized and str(record_type) not in self._my_map['recordTypeIds']:
                self._my_map['recordTypeIds'].append(str(record_type))
        return self._records[str(record_type)]
713757
def rpc_get_name_blockchain_record(self, name, **con_info):
        
        res = None
        if check_name(name):
            res = self.get_name_record(name, include_expired=True, include_history=True)
        elif check_subdomain(name):
            res = self.get_subdomain_record(name, include_history=True)
        else:
            return {'error': 'Invalid name or subdomain', 'http_status': 400}

        if 'error' in res:
            return {'error': res['error'], 'http_status': res.get('http_status', 404)}

        return self.success_response({'record': res['record']})
267651
def rpc_get_name_record(self, name, **con_info):
        
        res = None
        if check_name(name):
            res = self.get_name_record(name, include_expired=True, include_history=False)
        elif check_subdomain(name):
            res = self.get_subdomain_record(name, include_history=False)
        else:
            return {'error': 'Invalid name or subdomain', 'http_status': 400}

        if 'error' in res:
            return {'error': res['error'], 'http_status': 404}

        # also get a DID
        did_info = None
        did = None
        if check_name(name):
            did_info = self.get_name_DID_info(name)
        elif check_subdomain(name):
            did_info = self.get_subdomain_DID_info(name)
        else:
            return {'error': 'Invalid name or subdomain', 'http_status': 400}

        if did_info is not None:
            did = make_DID(did_info['name_type'], did_info['address'], did_info['index'])
            res['record']['did'] = did

        return self.success_response({'record': res['record']})
25314
def retrieve_ocsps(self, cert, issuer):
        

        if not self._allow_fetching:
            return self._ocsps

        if cert.issuer_serial not in self._fetched_ocsps:
            try:
                ocsp_response = ocsp_client.fetch(
                    cert,
                    issuer,
                    **self._ocsp_fetch_params
                )

                self._fetched_ocsps[cert.issuer_serial] = [ocsp_response]

                # Responses can contain certificates that are useful in validating the
                # response itself. We can use these since they will be validated using
                # the local trust roots.
                self._extract_ocsp_certs(ocsp_response)
            except (URLError, socket.error) as e:
                self._fetched_ocsps[cert.issuer_serial] = []
                if self._revocation_mode == "soft-fail":
                    self._soft_fail_exceptions.append(e)
                    raise SoftFailError()
                else:
                    raise

        return self._fetched_ocsps[cert.issuer_serial]
1125915
def get_issuer(request):
        
        if isinstance(request, etree._Element):
            elem = request
        else:
            if isinstance(request, Document):
                request = request.toxml()
            elem = fromstring(request, forbid_dtd=True)

        issuer = None
        issuer_nodes = OneLogin_Saml2_Utils.query(elem, '/samlp:LogoutRequest/saml:Issuer')
        if len(issuer_nodes) == 1:
            issuer = OneLogin_Saml2_Utils.element_text(issuer_nodes[0])
        return issuer
1259406
def obtain_record(check = nil, type = nil)
      
      return check if check.is_a?(ActiveRecord::Base)

      if check.blank? 
        return nil if @content.blank? || !@content[0].blank?
        @content
      else
        records = Post.where( 'post_title = :p OR post_slug = :p2 OR id = :p3', { p: check.to_s, p2: check.to_s, p3: check.to_i} )
        if !type.blank?
          records = records.where("post_type = :p4", {p4: type})
        end
        records.first
      end

    end
446504
public Record getReference()
    {
        Record record = this.getReferenceRecord();
        if (record != null)
        {
            try   {
                if (this.getData() == null)
                {
                    record.addNew();
                    return record;
                }
                Object bookmark = this.getData();
                if ((record.getEditMode() == Constants.EDIT_IN_PROGRESS)
                    || (record.getEditMode() == Constants.EDIT_CURRENT))
                {
                    Object oldBookmark = record.getHandle(DBConstants.BOOKMARK_HANDLE);
                    if ((bookmark != null) && (bookmark.equals(oldBookmark)))
                        return record;  // This record is already current
                }
                record.setHandle(bookmark, DBConstants.BOOKMARK_HANDLE);
            } catch (DBException ex)    {
                ex.printStackTrace();
                record = null;
            }   
        } 
        return record;
    }
214097
public X500Principal getIssuerX500Principal() {
        if (info == null) {
            return null;
        }
        try {
            X500Principal issuer = (X500Principal)info.get(
                                            X509CertInfo.ISSUER + DOT +
                                            "x500principal");
            return issuer;
        } catch (Exception e) {
            return null;
        }
    }
37665
def get_issuer_str(self):
        
        name_str = ""
        attrsDict = self.get_issuer()
        for attrType, attrSymbol in _attrName_mapping:
            if attrType in attrsDict:
                name_str += "/" + attrSymbol + "="
                name_str += attrsDict[attrType]
        for attrType in sorted(attrsDict):
            if attrType not in _attrName_specials:
                name_str += "/" + attrType + "="
                name_str += attrsDict[attrType]
        return name_str
865304
public Principal getIssuerDN() {
        if (info == null)
            return null;
        try {
            Principal issuer = (Principal)info.get(X509CertInfo.ISSUER + DOT +
                                                   X509CertInfo.DN_NAME);
            return issuer;
        } catch (Exception e) {
            return null;
        }
    }
198586
public Object getValue(final Object record) {
        Objects.requireNonNull(record);
        
        if(!getDeclaredClass().equals(record.getClass())) {
            throw new IllegalArgumentException(String.format("not match record class type. expected=%s. actual=%s, ",
                    type.getName(), record.getClass().getName()));
        }
        
        try {
            return field.get(record);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            throw new SuperCsvReflectionException("fail get field value.", e);
        }
        
    }
165980
public RecordId currentRecordId() {
		int id = rp.currentId();
		return new RecordId(new BlockId(fileName, currentBlkNum), id);
	}
266489
public String getUserID()
    {
        Record recUserInfo = (Record)this.getUserInfo();
        if (recUserInfo != null)
            return Converter.stripNonNumber(recUserInfo.getField(UserInfoModel.ID).toString());
        else
            return super.getUserID();
    }
63912
public String getReferenceRecordName()
    {
        if (m_recordReference != null)
            return this.getReferenceRecord().getTableNames(false);
        else
        {   // This code just takes a guess
            if (this.getClass().getName().indexOf("Field") != -1)
                return this.getClass().getName().substring(Math.max(0, this.getClass().getName().lastIndexOf('.') + 1), this.getClass().getName().indexOf("Field"));
            else if (this.getFieldName(false, false).indexOf("ID") != -1)
                return this.getFieldName(false, false).substring(0, this.getFieldName(false, false).indexOf("ID"));
            else
                this.getFieldName(false, false);
        }
        return Constants.BLANK;   // Never
    }
160975
public CardDetails details(Map<String, Object> params, RequestOptions options)
      throws StripeException {
    String url =
        String.format(
            "%s%s",
            Stripe.getApiBase(),
            String.format("/v1/issuing/cards/%s/details", ApiResource.urlEncodeId(this.getId())));
    return request(ApiResource.RequestMethod.GET, url, params, CardDetails.class, options);
  }
340003
async def detail(self, **kwargs):
        '''
        
        '''
        try:
            pk = self.pk_type(kwargs.get('pk'))
            obj = await self._meta.object_class.find_one(self.db, {self.pk: pk})
            if obj:
                return await obj.serialize()
            raise NotFound('Object matching the given {} with value {} was not found'.format(self.pk, str(pk)))
        except InvalidId:
            raise NotFound('Invalid ID')