func newDisputedCharge() (*stripe.Charge, error) {
chargeParams := &stripe.ChargeParams{
Amount: 1001,
Currency: currency.USD,
}
chargeParams.SetSource(&stripe.CardParams{
Number: "4000000000000259",
Month: "06",
Year: "20",
})
res, err := charge.New(chargeParams)
if err != nil {
return nil, err
}
target, err := charge.Get(res.ID, nil)
if err != nil {
return target, err
}
for target.Dispute == nil {
time.Sleep(time.Second * 10)
target, err = charge.Get(res.ID, nil)
if err != nil {
return target, err
}
}
return target, err
}
func ExampleCharge_get() {
stripe.Key = "sk_key"
params := &stripe.ChargeParams{}
params.Expand("customer")
params.Expand("balance_transaction")
ch, err := charge.Get("ch_example_id", params)
if err != nil {
log.Fatal(err)
}
log.Printf("%v\n", ch.ID)
}
//Show builds an html page that display a receipt
//this is a very boring, plain test, monospaced font page designed for easy printing and reading
//the receipt is generated from the charge id
//the data for the charge may be in memcache or will have to be retrieved from stripe
func Show(w http.ResponseWriter, r *http.Request) {
//get charge id from form value
chargeId := r.FormValue("chg_id")
//try looking up charge data in memcache
var chg *stripe.Charge
c := appengine.NewContext(r)
_, err := memcache.Gob.Get(c, chargeId, &chg)
//charge not found in memcache
//look up charge data from stripe
if err == memcache.ErrCacheMiss {
//init stripe
c := appengine.NewContext(r)
stripe.SetBackend(stripe.APIBackend, nil)
stripe.SetHTTPClient(urlfetch.Client(c))
//get charge data
chg, err = charge.Get(chargeId, nil)
if err != nil {
fmt.Fprint(w, "An error occured and the receipt cannot be displayed.\n")
fmt.Fprint(w, err)
return
}
//save to memcache
//just in case we want to view the receipt again
memcacheutils.Save(c, chg.ID, chg)
}
//extract charge data
d := chargeutils.ExtractData(chg)
//get company info
info, err := getCompanyInfo(r)
name, street, suite, city, state, postal, country, phone := "", "", "", "", "", "", "", ""
if err == ErrCompanyDataDoesNotExist {
name = "**Company info has not been set yet.**"
street = "**Please contact an administrator to fix this.**"
} else {
name = info.CompanyName
street = info.Street
suite = info.Suite
city = info.City
state = info.State
postal = info.PostalCode
country = info.Country
phone = info.PhoneNum
}
//display receipt
output := templateData{
CompanyName: name,
Street: street,
Suite: suite,
City: city,
State: state,
Postal: postal,
Country: country,
PhoneNum: phone,
Customer: d.Customer,
Cardholder: d.Cardholder,
CardBrand: d.CardBrand,
LastFour: d.LastFour,
Expiration: d.Expiration,
Captured: d.CapturedStr,
Timestamp: d.Timestamp,
Amount: d.AmountDollars,
Invoice: d.Invoice,
Po: d.Po,
}
templates.Load(w, "receipt", output)
return
}
func TestRefundNew(t *testing.T) {
chargeParams := &stripe.ChargeParams{
Amount: 1000,
Currency: currency.USD,
Source: &stripe.SourceParams{
Card: &stripe.CardParams{
Number: "378282246310005",
Month: "06",
Year: "20",
},
},
}
res, err := charge.New(chargeParams)
if err != nil {
t.Error(err)
}
// full refund
ref, err := New(&stripe.RefundParams{Charge: res.ID})
if err != nil {
t.Error(err)
}
if ref.Charge != res.ID {
t.Errorf("Refund charge %q does not match expected value %v\n", ref.Charge, res.ID)
}
target, err := charge.Get(res.ID, nil)
if err != nil {
t.Error(err)
}
if !target.Refunded || target.Refunds == nil {
t.Errorf("Expected to have refunded this charge\n")
}
if len(target.Refunds.Values) != 1 {
t.Errorf("Expected to have a refund, but instead have %v\n", len(target.Refunds.Values))
}
if target.Refunds.Values[0].Amount != target.AmountRefunded {
t.Errorf("Refunded amount %v does not match amount refunded %v\n", target.Refunds.Values[0].Amount, target.AmountRefunded)
}
if target.Refunds.Values[0].Currency != target.Currency {
t.Errorf("Refunded currency %q does not match charge currency %q\n", target.Refunds.Values[0].Currency, target.Currency)
}
if len(target.Refunds.Values[0].Tx.ID) == 0 {
t.Errorf("Refund transaction not set\n")
}
if target.Refunds.Values[0].Charge != target.ID {
t.Errorf("Refund charge %q does not match expected value %v\n", target.Refunds.Values[0].Charge, target.ID)
}
res, err = charge.New(chargeParams)
// partial refund
refundParams := &stripe.RefundParams{
Charge: res.ID,
Amount: 253,
}
New(refundParams)
target, err = charge.Get(res.ID, nil)
if err != nil {
t.Error(err)
}
if target.Refunded {
t.Errorf("Partial refund should not be marked as Refunded\n")
}
if target.AmountRefunded != refundParams.Amount {
t.Errorf("Refunded amount %v does not match expected amount %v\n", target.AmountRefunded, refundParams.Amount)
}
// refund with reason
res, err = charge.New(chargeParams)
if err != nil {
t.Error(err)
}
New(&stripe.RefundParams{Charge: res.ID, Reason: RefundFraudulent})
target, err = charge.Get(res.ID, nil)
if err != nil {
t.Error(err)
}
if target.FraudDetails.UserReport != "fraudulent" {
t.Errorf("Expected a fraudulent UserReport for charge refunded with reason=fraudulent but got: %s",
target.FraudDetails.UserReport)
}
}