Example #1
0
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
Example #2
0
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
Example #3
0
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
Example #4
0
    def test_create_authorization_hold(self, CreateRequest):
        _response = Mock()
        _response.trans_id = self.transaction_id
        _request = Mock()
        _request.make_request.return_value = (True, _response)
        CreateRequest.return_value = _request

        # Scenario: call is successful; pass customer_ip
        return_value = create_authorization_hold(self.customer_id,
                                                 self.payment_profile_id,
                                                 self.amount, 12345,
                                                 '127.0.0.1')
        self.assertTrue(CreateRequest.called)
        args, kwargs = CreateRequest.call_args
        self.assertEqual(kwargs['extraOptions'], {'x_customer_ip': '127.0.0.1'})
        self.assertEqual(return_value, _response)

        # Scenario: call raises transaction_error
        _request.make_request.return_value = (False, _response)
        self.assertRaises(TransactionError, create_authorization_hold,
                          self.customer_id, self.payment_profile_id,
                          self.amount, 12345, '127.0.0.1')

        # Scenario: call returns duplicate errors
        _response.response_code = TRANSACTION_ERROR
        _response.response_reason_code = TRANSACTION_DUPLICATE
        _request.make_request.return_value = (True, _response)
        self.assertRaises(DuplicateTransactionError, create_authorization_hold,
                          self.customer_id, self.payment_profile_id,
                          self.amount, 12345)
Example #5
0
    def test_create_authorization_hold(self, CreateRequest):
        _response = Mock()
        _response.trans_id = self.transaction_id
        _request = Mock()
        _request.make_request.return_value = (True, _response)
        CreateRequest.return_value = _request

        # Scenario: call is successful; pass customer_ip
        return_value = create_authorization_hold(self.customer_id,
                                                 self.payment_profile_id,
                                                 self.amount, 12345,
                                                 '127.0.0.1')
        self.assertTrue(CreateRequest.called)
        args, kwargs = CreateRequest.call_args
        self.assertEqual(kwargs['extraOptions'],
                         {'x_customer_ip': '127.0.0.1'})
        self.assertEqual(return_value, _response)

        # Scenario: call raises transaction_error
        _request.make_request.return_value = (False, _response)
        self.assertRaises(TransactionError, create_authorization_hold,
                          self.customer_id, self.payment_profile_id,
                          self.amount, 12345, '127.0.0.1')

        # Scenario: call returns duplicate errors
        _response.response_code = TRANSACTION_ERROR
        _response.response_reason_code = TRANSACTION_DUPLICATE
        _request.make_request.return_value = (True, _response)
        self.assertRaises(DuplicateTransactionError, create_authorization_hold,
                          self.customer_id, self.payment_profile_id,
                          self.amount, 12345)
Example #6
0
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