def __init__(self, name, number, exp_month, exp_year, cvd=''): """ Initialize a credit card struct and perform some basic validation. Arguments: name: the owner of the credit card, as displayed on the card itself number: the number of the credit card exp_month: the month of expiry, as a number, 1-indexed exp_year: the year of expiry, as a number cvd: the CVD of the credit card (optional) """ if not name: raise errors.ValidationException('Name must be specified in credit card') self.name = name if not number: raise errors.ValidationException('Number must be specified in credit card') self.number = str(number) if not exp_month: raise errors.ValidationException('Expiry month must be specified in credit card') if not exp_year: raise errors.ValidationException('Expiry year must be specified in credit card') # Parse out the month & year as expected by Beanstream (numeric month, # 1-indexed, & last two digits of the year). year = int(exp_year) month = int(exp_month) expiry_date = date(year, month, calendar.monthrange(year, month)[1]) self.exp_month = expiry_date.strftime('%m') self.exp_year = expiry_date.strftime('%y') self.cvd = str(cvd)
def validate(self): if (self.has_billing_address or self.has_credit_card) and self.has_customer_code: log.error('billing address or credit card specified with customer code') raise errors.ValidationException('cannot specify both customer code and billing address/credit card') if not self.has_customer_code and self.beanstream.REQUIRE_BILLING_ADDRESS and not self.has_billing_address: log.error('billing address required') raise errors.ValidationException('billing address required')
def set_refs(self, refs): if len(refs) > 5: raise errors.ValidationException('too many ref fields') for ref_idx, ref in enumerate(refs, start=1): if ref: self.params['ref%s' % ref_idx] = ref
def set_card(self, card): if self.beanstream.REQUIRE_CVD and not card.has_cvd(): log.error('CVD required') raise errors.ValidationException('CVD required') self.params.update(card.params()) self.has_credit_card = True
def set_language(self, language): language = language.upper() if language not in ('ENG', 'FRE'): raise errors.ValidationException( 'invalid language option specified: %s (must be one of FRE, ENG)' % language) self.params['trnLanguage'] = language
def set_status(self, status): status = status.lower() if status not in STATUS_DESCRIPTORS: raise errors.ValidationException('invalid status option specified: %s' % status) self.params['status'] = STATUS_DESCRIPTORS[status]
def parse_raw_response(self, body): fields = self.response_class._fields() lines = body.split('\r\n') report = [] pattern = re.compile(r'\t'.join([r'([^\t]*)'] * len(fields))) for line in lines[1:]: m = pattern.match(line) if not line.strip(): continue if m: report_item = {} for idx, field in enumerate(fields): if not m.groups()[idx] or m.groups()[idx] == '\x00': report_item[field] = None else: report_item[field] = m.groups()[idx] report.append(report_item) else: raise errors.ValidationException( 'unexpected format received: %s' % line) return report
def __init__(self, name, email, phone=None, address1=None, address2=None, city=None, province=None, postal_code=None, country=None): """ Initialize an address struct. """ if not name: raise errors.ValidationException('Name must be specified in address') self.name = name if not email: raise errors.ValidationException('Email must be specified in address') self.email = email self.phone = None if phone: self.phone = str(phone) self.address1 = address1 self.address2 = address2 self.city = city self.province = province self.postal_code = postal_code self.country = country
def parse_raw_response(self, body): pattern = re.compile(r'^<\?xml version="1\.0".*>\s*<response>\s*<accountId>([^<]+)</accountId>\s*<code>(\d+)</code>\s*<message>(.*)</message>\s*</response>\s*$') m = pattern.match(body) if m: account_id, response_code, message = m.groups() return { 'accountId': [account_id], 'code': [response_code], 'message': [message] } else: raise errors.ValidationException('unexpected message format received: %s' % body)
def toStr(self): if self.value == '=': return '%3D' elif self.value == '<': return '%3C' elif self.value == '>': return '%3E' elif self.value == '<=': return '%3C%3D' elif self.value == '>=': return '%3E%3D' elif self.value == 'START WITH': return 'START%20WITH' else: return errors.ValidationException( "Unrecognized Operator parameter for report query: " + value)
def __init__(self, beanstream, amount, frequency_period, frequency_increment): """ Create a new recurring billing account creation transaction. Arguments: beanstream: gateway object amount: the amount to charge on a recurring basis frequency_period: one of DWMY; used in combination with frequency_increment to set billing frequency frequency_increment: numeric; used in combination with frequency_period to set billing frequency """ super(CreateRecurringBillingAccount, self).__init__(beanstream, amount) self.response_class = CreateRecurringBillingAccountResponse self.params['trnRecurring'] = '1' frequency_period = frequency_period.upper() if frequency_period not in 'DWMY': raise errors.ValidationException('invalid frequency period specified: %s (must be one of DWMY)' % frequency_period) self.params['rbBillingPeriod'] = frequency_period self.params['rbBillingIncrement'] = frequency_increment
def set_frequency_period(self, frequency_period): frequency_period = frequency_period.upper() if frequency_period not in 'DWMY': raise errors.ValidationException('invalid frequency period specified: %s (must be one of DMWY)' % frequency_period) self.params['rbBillingPeriod'] = frequency_period
def set_billing_state(self, billing_state): billing_state = billing_state.lower() if billing_state not in STATUS_DESCRIPTORS: raise errors.ValidationException('invalid billing state option specified: %s' % billing_state) self.params['rbBillingState'] = STATUS_DESCRIPTORS[billing_state]
def validate(self): if 'rptTransId' not in self.params and 'rptCcNumber' not in self.params: raise errors.ValidationException( 'CreditCardLookupReport must specify one of transaction id or credit card number' )