def auth_transaction(user, campaign_id, link_id, amount, payment_method_id, references):
if payment_method_id not in PayID.get_ids(user._id):
return None, "invalid payment method"
profile_id = CustomerID.get_id(user._id)
invoice = "T%dC%d" % (link_id, campaign_id)
references["pay_id"] = payment_method_id
try:
authorize_response = api.create_authorization_hold(profile_id, payment_method_id, amount, invoice, request.ip)
AuthorizeTransaction._new(authorize_response, **references)
except api.DuplicateTransactionError as e:
transaction_id = e.transaction_id
try:
bid = Bid.one(transaction_id, campaign=campaign_id)
except NotFound:
bid = Bid._new(transaction_id, user, payment_method_id, link_id, amount, campaign_id)
g.log.error("%s on campaign %d" % (e.message, campaign_id))
return transaction_id, None
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return None, e.message
bid = Bid._new(authorize_response.trans_id, user, payment_method_id, link_id, amount, campaign_id)
return authorize_response.trans_id, None
def auth_transaction(amount, user, payment_method_id, link, campaign_id):
if payment_method_id not in PayID.get_ids(user._id):
return None, "invalid payment method"
profile_id = CustomerID.get_id(user._id)
invoice = "T%dC%d" % (link._id, campaign_id)
try:
transaction_id = api.create_authorization_hold(profile_id,
payment_method_id,
amount, invoice,
request.ip)
except api.DuplicateTransactionError as e:
transaction_id = e.transaction_id
try:
bid = Bid.one(transaction_id, campaign=campaign_id)
except NotFound:
bid = Bid._new(transaction_id, user, payment_method_id, link._id,
amount, campaign_id)
g.log.error("%s on campaign %d" % (e.message, campaign_id))
return transaction_id, None
except api.TransactionError as e:
return None, e.message
bid = Bid._new(transaction_id, user, payment_method_id, link._id, amount,
campaign_id)
return transaction_id, None
def auth_transaction(user, campaign_id, link_id, amount, payment_method_id,
references):
if payment_method_id not in PayID.get_ids(user._id):
return None, "invalid payment method"
profile_id = CustomerID.get_id(user._id)
invoice = "T%dC%d" % (link_id, campaign_id)
references['pay_id'] = payment_method_id
try:
authorize_response = api.create_authorization_hold(
profile_id, payment_method_id, amount, invoice, request.ip)
AuthorizeTransaction._new(authorize_response, **references)
except api.DuplicateTransactionError as e:
transaction_id = e.transaction_id
try:
bid = Bid.one(transaction_id, campaign=campaign_id)
except NotFound:
bid = Bid._new(transaction_id, user, payment_method_id, link_id,
amount, campaign_id)
g.log.error("%s on campaign %d" % (e.message, campaign_id))
return transaction_id, None
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return None, e.message
bid = Bid._new(authorize_response.trans_id, user, payment_method_id,
link_id, amount, campaign_id)
return authorize_response.trans_id, None
def auth_transaction(amount, user, payment_method_id, link, campaign_id):
if payment_method_id not in PayID.get_ids(user._id):
return None, "invalid payment method"
profile_id = CustomerID.get_id(user._id)
invoice = "T%dC%d" % (link._id, campaign_id)
try:
transaction_id = api.create_authorization_hold(
profile_id, payment_method_id, amount, invoice, request.ip)
except api.DuplicateTransactionError as e:
transaction_id = e.transaction_id
try:
bid = Bid.one(transaction_id, campaign=campaign_id)
except NotFound:
bid = Bid._new(transaction_id, user, payment_method_id, link._id,
amount, campaign_id)
g.log.error("%s on campaign %d" % (e.message, campaign_id))
return transaction_id, None
except api.TransactionError as e:
return None, e.message
bid = Bid._new(transaction_id, user, payment_method_id, link._id, amount,
campaign_id)
return transaction_id, None
def refund_transaction(amount, user, trans_id, test=None):
bid = Bid.one(trans_id)
if trans_id > 0:
# create a new bid to identify the refund
success, res = _make_transaction(ProfileTransRefund, amount, user, bid.pay_id, trans_id=trans_id, test=test)
if success:
bid = Bid._new(res.trans_id, user, -1, bid.thing_id, amount)
bid.refund()
return bool(res.trans_id)
def auth_freebie_transaction(amount, user, link, campaign_id):
transaction_id = -link._id
try:
# attempt to update existing freebie transaction
bid = Bid.one(thing_id=link._id, transaction=transaction_id, campaign=campaign_id)
except NotFound:
bid = Bid._new(transaction_id, user, FREEBIE_PAYMENT_METHOD_ID, link._id, amount, campaign_id)
else:
bid.bid = amount
bid.auth()
return transaction_id, ""
def auth_transaction(amount, user, payid, thing, test = None):
# use negative pay_ids to identify freebies, coupons, or anything
# that doesn't require a CC.
if payid < 0:
trans_id = -thing._id
# update previous freebie transactions if we can
try:
bid = Bid.one(thing_id = thing._id,
pay_id = payid)
bid.bid = amount
bid.auth()
except NotFound:
bid = Bid._new(trans_id, user, payid, thing._id, amount)
return bid.transaction
elif int(payid) in PayID.get_ids(user):
order = Order(invoiceNumber = "%dT%d" % (user._id, thing._id))
success, res = _make_transaction(ProfileTransAuthOnly,
amount, user, payid,
order = order, test = test)
if success:
Bid._new(res.trans_id, user, payid, thing._id, amount)
return res.trans_id
elif res is None:
# we are in test mode!
return auth_transaction(amount, user, -1, thing, test = test)
# duplicate transaction, which is bad, but not horrible. Log
# the transaction id, creating a new bid if necessary.
elif (res.response_code, res.response_reason_code) == (3,11):
try:
Bid.one(res.trans_id)
except NotFound:
Bid._new(res.trans_id, user, payid, thing._id, amount)
return res.trans_id
def auth_freebie_transaction(amount, user, link, campaign_id):
transaction_id = -link._id
try:
# attempt to update existing freebie transaction
bid = Bid.one(thing_id=link._id,
transaction=transaction_id,
campaign=campaign_id)
except NotFound:
bid = Bid._new(transaction_id, user, FREEBIE_PAYMENT_METHOD_ID,
link._id, amount, campaign_id)
else:
bid.bid = amount
bid.auth()
return transaction_id, ""
def charge_transaction(user, transaction_id, campaign_id):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if bid.is_charged():
return True, None
if transaction_id < 0:
bid.charged()
return True, None
profile_id = CustomerID.get_id(user._id)
try:
api.capture_authorization_hold(
customer_id=profile_id,
payment_profile_id=bid.pay_id,
amount=bid.bid,
transaction_id=transaction_id,
)
except api.AuthorizationHoldNotFound:
# authorization hold has expired
bid.void()
return False, api.TRANSACTION_NOT_FOUND
except api.TransactionError as e:
return False, e.message
bid.charged()
return True, None
def void_transaction(user, trans_id, test=None):
bid = Bid.one(trans_id)
bid.void()
# verify that the transaction has the correct ownership
if bid.account_id == user._id and trans_id > 0:
res = _make_transaction(ProfileTransVoid, None, user, None, trans_id=trans_id, test=test)
return res
def charge_transaction(user, campaign_id, link_id, transaction_id, references):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if bid.is_charged():
return True, None
if transaction_id < 0:
bid.charged()
return True, None
references['pay_id'] = bid.pay_id
profile_id = CustomerID.get_id(user._id)
try:
authorize_response = api.capture_authorization_hold(
customer_id=profile_id,
payment_profile_id=bid.pay_id,
amount=bid.bid,
transaction_id=transaction_id,
)
AuthorizeTransaction._new(authorize_response, **references)
except api.AuthorizationHoldNotFound:
# authorization hold has expired
bid.void()
return False, api.TRANSACTION_NOT_FOUND
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return False, e.message
bid.charged()
return True, None
def charge_transaction(user, campaign_id, link_id, transaction_id, references):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if bid.is_charged():
return True, None
if transaction_id < 0:
bid.charged()
return True, None
references["pay_id"] = bid.pay_id
profile_id = CustomerID.get_id(user._id)
try:
authorize_response = api.capture_authorization_hold(
customer_id=profile_id, payment_profile_id=bid.pay_id, amount=bid.bid, transaction_id=transaction_id
)
AuthorizeTransaction._new(authorize_response, **references)
except api.AuthorizationHoldNotFound:
# authorization hold has expired
bid.void()
return False, api.TRANSACTION_NOT_FOUND
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return False, e.message
bid.charged()
return True, None
def refund_transaction(user, campaign_id, link_id, amount, transaction_id,
references):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id < 0:
bid.refund(amount)
return True, None
references['pay_id'] = bid.pay_id
profile_id = CustomerID.get_id(user._id)
try:
authorize_response = api.refund_transaction(
customer_id=profile_id,
payment_profile_id=bid.pay_id,
amount=amount,
transaction_id=transaction_id,
)
AuthorizeTransaction._new(authorize_response, **references)
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return False, e.message
bid.refund(amount)
return True, None
def charge_transaction(user, transaction_id, campaign_id):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if bid.is_charged():
return True, None
if transaction_id < 0:
bid.charged()
return True, None
profile_id = CustomerID.get_id(user._id)
try:
api.capture_authorization_hold(
customer_id=profile_id,
payment_profile_id=bid.pay_id,
amount=bid.bid,
transaction_id=transaction_id,
)
except api.AuthorizationHoldNotFound:
# authorization hold has expired
bid.void()
return False, api.TRANSACTION_NOT_FOUND
except api.TransactionError as e:
return False, e.message
bid.charged()
return True, None
def void_transaction(user, trans_id, campaign, test=None):
bid = Bid.one(transaction=trans_id, campaign=campaign)
bid.void()
if trans_id > 0:
res = _make_transaction(ProfileTransVoid,
None, user, None, trans_id=trans_id,
test=test)
return res
def charge_transaction(user, trans_id, test=None):
bid = Bid.one(trans_id)
bid.charged()
if trans_id < 0:
# freebies are automatically approved
return True
elif bid.account_id == user._id:
res = _make_transaction(ProfileTransPriorAuthCapture, bid.bid, user, bid.pay_id, trans_id=trans_id, test=test)
return bool(res)
def get_transactions(*trans_keys):
from sqlalchemy import and_, or_
if trans_keys:
f = or_(*[and_(Bid.transaction == trans_id, Bid.campaign == camp) for trans_id, camp in trans_keys])
q = Bid.query()
q = q.filter(f)
return dict(((p.transaction, p.campaign), p) for p in q)
return {}
def get_transactions(*trans_keys):
from sqlalchemy import and_, or_
if trans_keys:
f = or_(*[and_(Bid.transaction == trans_id, Bid.campaign == camp)
for trans_id, camp in trans_keys])
q = Bid.query()
q = q.filter(f)
return dict(((p.transaction, p.campaign), p) for p in q)
return {}
def is_charged_transaction(trans_id, campaign):
if not trans_id: return False # trans_id == 0 means no bid
try:
bid = Bid.one(transaction=trans_id, campaign=campaign)
except NotFound:
return False
except MultipleResultsFound:
g.log.error('Multiple bids for trans_id %s' % trans_id)
return False
return bid.is_charged() or bid.is_refund()
def auth_transaction(amount, user, payid, thing, campaign, test=None):
# use negative pay_ids to identify freebies, coupons, or anything
# that doesn't require a CC.
if payid < 0:
trans_id = -thing._id
# update previous freebie transactions if we can
try:
bid = Bid.one(thing_id=thing._id,
transaction=trans_id,
campaign=campaign)
bid.bid = amount
bid.auth()
except NotFound:
bid = Bid._new(trans_id, user, payid, thing._id, amount, campaign)
return bid.transaction, ""
elif int(payid) in PayID.get_ids(user):
order = Order(invoiceNumber="T%dC%d" % (thing._id, campaign))
success, res = _make_transaction(ProfileTransAuthOnly,
amount,
user,
payid,
order=order,
test=test)
if success:
if test:
return auth_transaction(amount,
user,
-1,
thing,
campaign,
test=test)
else:
Bid._new(res.trans_id, user, payid, thing._id, amount,
campaign)
return res.trans_id, ""
elif res is None:
# we are in test mode!
return auth_transaction(amount, user, -1, thing, test=test)
# duplicate transaction, which is bad, but not horrible. Log
# the transaction id, creating a new bid if necessary.
elif res.trans_id and (res.response_code,
res.response_reason_code) == (3, 11):
g.log.error("Authorize.net duplicate trans %d on campaign %d" %
(res.trans_id, campaign))
try:
Bid.one(res.trans_id, campaign=campaign)
except NotFound:
Bid._new(res.trans_id, user, payid, thing._id, amount,
campaign)
return res.trans_id, res.response_reason_text
def charge_transaction(user, trans_id, campaign, test=None):
bid = Bid.one(transaction=trans_id, campaign=campaign)
if not bid.is_charged():
bid.charged()
if trans_id < 0:
# freebies are automatically authorized
return True
elif bid.account_id == user._id:
res = _make_transaction(
ProfileTransPriorAuthCapture, bid.bid, user, bid.pay_id, trans_id=trans_id, test=test
)
return bool(res)
# already charged
return True
def void_transaction(user, transaction_id, campaign_id):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id <= 0:
bid.void()
return True, None
profile_id = CustomerID.get_id(user._id)
try:
api.void_authorization_hold(profile_id, bid.pay_id, transaction_id)
except api.TransactionError as e:
return False, e.message
bid.void()
return True, None
def void_transaction(user, transaction_id, campaign_id):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id <= 0:
bid.void()
return True, None
profile_id = CustomerID.get_id(user._id)
try:
api.void_authorization_hold(profile_id, bid.pay_id, transaction_id)
except api.TransactionError as e:
return False, e.message
bid.void()
return True, None
def charge_transaction(user, trans_id, campaign, test=None):
bid = Bid.one(transaction=trans_id, campaign=campaign)
if not bid.is_charged():
bid.charged()
if trans_id < 0:
# freebies are automatically authorized
return True
elif bid.account_id == user._id:
res = _make_transaction(ProfileTransPriorAuthCapture,
bid.bid, user,
bid.pay_id, trans_id=trans_id,
test=test)
return bool(res)
# already charged
return True
def refund_transaction(user, trans_id, campaign_id, amount, test=None):
# refund will only work if charge has settled
bid = Bid.one(transaction=trans_id, campaign=campaign_id)
if trans_id < 0:
bid.refund(amount)
return True
else:
success, res = _make_transaction(ProfileTransRefund, amount, user,
bid.pay_id, trans_id=trans_id,
test=test)
if success:
bid.refund(amount)
elif success == False:
msg = "Refund failed, response: %r" % res
raise AuthorizeNetException(msg)
return True
def charge_transaction(user, trans_id, campaign, test=None):
bid = Bid.one(transaction=trans_id, campaign=campaign)
if bid.is_charged():
return True
if trans_id < 0:
success = True
else:
success, res = _make_transaction(ProfileTransPriorAuthCapture,
bid.bid, user,
bid.pay_id, trans_id=trans_id,
test=test)
if success:
bid.charged()
return success
def refund_transaction(user, transaction_id, campaign_id, amount):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id < 0:
bid.refund(amount)
return True, None
profile_id = CustomerID.get_id(user._id)
try:
api.refund_transaction(
customer_id=profile_id,
payment_profile_id=bid.pay_id,
amount=amount,
transaction_id=transaction_id,
)
except api.TransactionError as e:
return False, e.message
bid.refund(amount)
return True, None
def refund_transaction(user, transaction_id, campaign_id, amount):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id < 0:
bid.refund(amount)
return True, None
profile_id = CustomerID.get_id(user._id)
try:
api.refund_transaction(
customer_id=profile_id,
payment_profile_id=bid.pay_id,
amount=amount,
transaction_id=transaction_id,
)
except api.TransactionError as e:
return False, e.message
bid.refund(amount)
return True, None
def void_transaction(user, campaign_id, link_id, transaction_id, references):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id <= 0:
bid.void()
return True, None
references["pay_id"] = bid.pay_id
profile_id = CustomerID.get_id(user._id)
try:
authorize_response = api.void_authorization_hold(profile_id, bid.pay_id, transaction_id)
AuthorizeTransaction._new(authorize_response, **references)
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return False, e.message
bid.void()
return True, None
def auth_transaction(amount, user, payid, thing, campaign):
# use negative pay_ids to identify freebies, coupons, or anything
# that doesn't require a CC.
if payid < 0:
trans_id = -thing._id
# update previous freebie transactions if we can
try:
bid = Bid.one(thing_id=thing._id,
transaction=trans_id,
campaign=campaign)
bid.bid = amount
bid.auth()
except NotFound:
bid = Bid._new(trans_id, user, payid, thing._id, amount, campaign)
return bid.transaction, ""
elif int(payid) in PayID.get_ids(user):
order = Order(invoiceNumber="T%dC%d" % (thing._id, campaign))
success, res = _make_transaction(
ProfileTransAuthOnly, amount, user, payid, order=order,
include_request_ip=True)
if success:
Bid._new(res.trans_id, user, payid, thing._id, amount, campaign)
return res.trans_id, ""
elif (res.trans_id and
(res.response_code, res.response_reason_code) == (3, 11)):
# duplicate transaction, which is bad, but not horrible. Log
# the transaction id, creating a new bid if necessary.
g.log.error("Authorize.net duplicate trans %d on campaign %d" %
(res.trans_id, campaign))
try:
Bid.one(res.trans_id, campaign=campaign)
except NotFound:
Bid._new(res.trans_id, user, payid, thing._id, amount, campaign)
return res.trans_id, res.response_reason_text
def void_transaction(user, campaign_id, link_id, transaction_id, references):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id <= 0:
bid.void()
return True, None
references['pay_id'] = bid.pay_id
profile_id = CustomerID.get_id(user._id)
try:
authorize_response = api.void_authorization_hold(
profile_id, bid.pay_id, transaction_id)
AuthorizeTransaction._new(authorize_response, **references)
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return False, e.message
bid.void()
return True, None
def refund_transaction(user, campaign_id, link_id, amount, transaction_id, references):
bid = Bid.one(transaction=transaction_id, campaign=campaign_id)
if transaction_id < 0:
bid.refund(amount)
return True, None
references["pay_id"] = bid.pay_id
profile_id = CustomerID.get_id(user._id)
try:
authorize_response = api.refund_transaction(
customer_id=profile_id, payment_profile_id=bid.pay_id, amount=amount, transaction_id=transaction_id
)
AuthorizeTransaction._new(authorize_response, **references)
except api.TransactionError as e:
authorize_response = e.authorize_response
AuthorizeTransaction._new(authorize_response, **references)
return False, e.message
bid.refund(amount)
return True, None
def charge_transaction(user, trans_id, campaign, test=None):
bid = Bid.one(transaction=trans_id, campaign=campaign)
if bid.is_charged():
return True
if trans_id < 0:
success = True
response_reason_code = None
else:
success, res = _make_transaction(ProfileTransPriorAuthCapture,
bid.bid, user,
bid.pay_id, trans_id=trans_id,
test=test)
response_reason_code = res.get("response_reason_code")
if success:
bid.charged()
elif response_reason_code == TRANSACTION_NOT_FOUND:
# authorization hold has expired
bid.void()
return success, response_reason_code
def charge_transaction(user, trans_id, campaign, test=None):
bid = Bid.one(transaction=trans_id, campaign=campaign)
if bid.is_charged():
return True
if trans_id < 0:
success = True
response_reason_code = None
else:
success, res = _make_transaction(ProfileTransPriorAuthCapture,
bid.bid,
user,
bid.pay_id,
trans_id=trans_id,
test=test)
response_reason_code = res.get("response_reason_code")
if success:
bid.charged()
elif response_reason_code == TRANSACTION_NOT_FOUND:
# authorization hold has expired
bid.void()
return success, response_reason_code
def is_charged_transaction(trans_id, campaign):
bid = Bid.one(transaction = trans_id, campaign = campaign)
return bid.is_charged()
def is_charged_transaction(trans_id, campaign):
bid = Bid.one(transaction=trans_id, campaign=campaign)
return bid.is_charged()
def is_charged_transaction(trans_id, campaign):
if not trans_id: return False # trans_id == 0 means no bid
bid = Bid.one(transaction = trans_id, campaign = campaign)
return bid.is_charged()
def is_charged_transaction(trans_id, campaign):
if not trans_id: return False # trans_id == 0 means no bid
bid = Bid.one(transaction = trans_id, campaign = campaign)
return bid.is_charged()
