ZSI Examples

Some ZSI Examples

CDPBilling

A Python script using the Zolera SOAP Infrastructure was implemented which allowed arbitrary combinations of orders to be generated. This script was run from the command line with arguments specifying the required attributes of order set. It dynamically generated an order cluster with randomized data, injected this into the web tier and captured and parsed the return response into a log file along with various timings.

Follow these links to view the submit script (do.py) and component ZSI generated modules:

do.py

1. !/usr/bin/env python
5. -------------------------------------------------------------------------------

from CDPBilling_serviceagent_services import *

from ZSI import FaultException, Fault

import ZSI

import os import re import csv import sys import time import getopt import random import socket import pprint import pickle import traceback

import types import pprint

import xml.dom.minidom

1. from xml.dom.utils import FileReader

from string import join, split from datetime import datetime, timedelta from time import strptime

1. -------------------------------------------------------------------------------

__version__ = '1.2.0'

debug_flg = False verbose_flg = False sundry_flg = False

no_sundries = 0 cnt_requests = 0 log = None

ServiceURL = "http://hx418:10000/Services/CDPBilling" # Is retrieved from WSDL

notification_email = 'peter.harding@auspost.com.au'

cdp_defaults = {

                       'AaE'    : ['APCBE', 'AAE PSft', 1,  'SVT-A-%06d', 0],
                       'MPC'    : ['APCBE', 'MPVIC', 1,  'SVT-M-%06d', 0],
                       'XXX'    : ['XXXXX', 'XXXX', 1,  'SVT-X-%06d', 0]
                    }

cdpId = 'AaE' cdp_details = None service_header = None no_orders = 1

dt_order = None dt_request = None

cdp_data_pickle = "cdp.pickle"

add_performance = True

1. ===============================================================================

class CDP:

  pass

  def __init__(self, cdpID):
     self.cdpID           = cdpID
     self.consortiumID    = cdp_details[cdpID][0]
     self.sourceSystemID  = cdp_details[cdpID][1]
     self.sequenceID      = cdp_details[cdpID][2]
     self.OrderNoFmt      = cdp_details[cdpID][3]
     self.OrderNo         = cdp_details[cdpID][4]
     self.customer        = []

  def get_order_number(self):
     order_number                = self.OrderNo
     self.OrderNo               += 1
     cdp_details[self.cdpID][4]  = self.OrderNo
     return order_number

1. ===============================================================================

class Customer:

  pass

  def __init__(self, m):
     self.apAccountNumber  = int(m[0])
     self.cdpAccountNumber = int(m[1])
     self.cdpCustomerID    = int(m[2])
     self.cdpCustomerName  = m[3]
     self.workCentreID     = int(m[4])
     self.order            = []

  def __str__(self):
     str = """
     apAccountNumber  = %d
     cdpAccountNumber = %d
     cdpCustomerID    = %d
     cdpCustomerName  = '%s'
     """ % (
              self.apAccountNumber,
              self.cdpAccountNumber,
              self.cdpCustomerID,
              self.cdpCustomerName
            )

     for o in self.order:
        str += """
     Order:\n"""
        str += o.__str__()

     return str

1. ===============================================================================

class Order:

  pass

  def __init__(self, cdp, customer):
     self.orderID             = cdp.OrderNoFmt % cdp.get_order_number()
     self.orderStatus         = None
     self.orderDateTime       = dt_order.timetuple()
     self.readyDateTime       = (dt_order + timedelta(days=1)).timetuple()
     self.invoiceDateTime     = (dt_order + timedelta(days=2)).timetuple()
     self.numberOfItems       = 1
     self.workCentreID        = customer.workCentreID
     self.CustomerReference   = None
     self.OrderReference      = None
     self.PickUpAddress       = None
     self.DeliveryAddress     = None
     self.Weight              = None
     self.Dimension           = None
     self.Performance         = None
     self.Service             = []

  def __str__(self):
     str = """
        orderID             = %s
        orderDateTime       = %s
        readyDateTime       = %s
        invoiceDateTime     = %s
        numberOfItems       = %d
        workCentreID        = %d
     """ % (
        self.orderID,
        self.orderDateTime,
        self.readyDateTime,
        self.invoiceDateTime,
        self.numberOfItems,
        self.workCentreID
     )
     return str

1. ===============================================================================

class CustomerReference:

  pass

  def __init__(self, cdp):
     self.customerCostCentre     = '%06d' % random.randint(100000,200000)
     self.otherCustomerRef       = '%s%05d' % (cdp.cdpID, random.randint(10000,99999))
     self.otherCustomerRefDesc   = 'Consignment Note Number'

  def __str__(self):
     return "CustomerReference"

1. ===============================================================================

class OrderReference:

  pass

  def __init__(self, m):
     self.orderRef1              = 'M%08d' % random.randint(10000000,99999999)
     self.orderRef1Desc          = 'Manifest Number'
     self.orderRef2              = 'R%05d' % random.randint(10000,99999)
     self.orderRef2Desc          = 'Run Number'
     self.orderRef3              = 'J%06d' % random.randint(100000,999999)
     self.orderRef3Desc          = 'Job Number'

  def __str__(self):
     return "OrderReference"

1. ===============================================================================

class Address:

  pass

  def __init__(self, m):
     # addr = get_address()
     self.address1    = m[0]
     self.address2    = m[1]
     self.address3    = m[2]
     self.address4    = m[3]
     self.suburb      = m[4]
     self.state       = m[5]
     self.postcode    = m[6]
     self.country     = m[7]

  def __str__(self):
     str = "       Address: %s," % self.address1,
     if self.address2:
        str += "%s, " % self.address2
     if self.address3:
        str += "%s, " % self.address3
     str += "%s, %s, %s" % (
        self.suburb,
        self.postcode,

self.state

     )
     return str

1. ===============================================================================

class Weight:

  pass

  def __init__(self, w):
     self.entryWeight  = w
     self.cubedWeight  = w
     self.actualWeight = w

  def __str__(self):
     return "Weight: %d" % (self.entryWeight)

1. ===============================================================================

class Dimension:

  pass

  def __init__(self, d):
     self.height          = d
     self.length          = d
     self.width           = d

  def __str__(self):
     return "Dimensions: %d x %d x %d" % (self.height, self.length, self.width)

1. ===============================================================================

class Performance:

  pass

  def __init__(self):
     t_pickup_sched    = dt_order + timedelta(hours=2)
     t_pickup_actual   = t_pickup_sched + timedelta(minutes=30)
     t_delivery_sched  = t_pickup_sched + timedelta(hours=1)
     t_delivery_actual = t_delivery_sched + timedelta(minutes=30)

     self.schedPickUpDateTime        = t_pickup_sched.timetuple()
     self.pickupSignatureRequired    = False
     self.pickupSignatureReceived    = False
     self.actualPickUpDateTime       = t_pickup_actual.timetuple()
     self.latePickUpIndicator        = False
     self.pickUpTimeliness           = -1
     self.schedDeliveryDateTime      = t_delivery_sched.timetuple()
     self.deliverySignatureRequired  = True
     self.deliverySignatureReceived  = True
     self.actualDeliveryDateTime     = t_delivery_actual.timetuple()
     self.lateDeliveryIndicator      = True
     self.deliveryTimeliness         = 7

  def __str__(self):
     return "Performance:"

1. ===============================================================================

class Service:

  pass

  # serviceCodeSet,serviceType,serviceArea,serviceCode,serviceDesc,apProductCode

  def __init__(self, m):
     self.serviceCodeSet    = m[0]
     self.serviceType       = m[1]
     self.serviceArea       = m[2]
     self.serviceCode       = m[3]
     self.serviceDesc       = m[4]
     self.apProductCode     = m[5]
     self.deliveryDistance  = None
     self.charge            = []

     if  self.apProductCode == :
        self.apProductCode = None

  def __str__(self):
     return "%s,%s,%s" % (self.serviceType, self.serviceArea,self.serviceCodeSet)

1. ===============================================================================

class Charge:

  pass

  def __init__(self, cdp, m):
     self.transactionID       = '%s%06d' % (cdp.cdpID[0:1], random.randint(100000,999999))
     self.transactionType     = m[0]
     self.chargeType          = m[1]
     self.chargeCode          = m[2]
     self.chargeCodeDesc      = m[3]
     self.priceCharged        = float(m[4])
     self.taxCode             = m[5]

  def __str__(self):
     return "%s,%s,%s,%s" % (
        self.chargeType,
        self.chargeCode,
        self.chargeCodeDesc,
        self.priceCharged
     )

1. ===============================================================================
2. ----- Read in Account address info ---------------------------------------

class Addresses:

  pass

  #-------------------------------------------------------------

  def __init__(self, carrier):
     self.addresses = []

     file = 'dat/%s/Address.csv' % carrier.cdpID

     f_in  = open(file, "r")

     reader = csv.reader(f_in)

     for row in reader:
        if re.search('#', row[0]):
           continue
        self.addresses.append(Address(row))

     f_in.close()  # Explicitly close the file *NOW*

     self.no_addresses = len(self.addresses)

     if debug_flg: print "Read in %d addresses" % self.no_addresses

  #-------------------------------------------------------------

  def Get(self):
     idx = random.randint(0, self.no_addresses - 1)

     return self.addresses[idx]

  #-------------------------------------------------------------

  def GetPair(self):
     idx1 = random.randint(0, self.no_addresses - 1)

     while True:
        idx2 = random.randint(0, self.no_addresses - 1)
        if idx1 != idx2:
           break

     return (self.addresses[idx1], self.addresses[idx2])

1. ===============================================================================

class Charges:

  pass

  #-------------------------------------------------------------

  def __init__(self, carrier):
     self.values = []

     file = 'dat/%s/Charge.csv' % carrier.cdpID

     f_in  = open(file, "r")

     reader = csv.reader(f_in)

     for row in reader:
        if re.search('#', row[0]):
           continue
        self.values.append(Charge(carrier, row))

     f_in.close()  # Explicitly close the file *NOW*

     self.no_values = len(self.values)

     if debug_flg: print "Read in %d charges" % self.no_values

  #-------------------------------------------------------------

  def Get(self):
     idx = random.randint(0, self.no_values - 1)

     return self.values[idx]

1. ===============================================================================

class Charges_Sundry:

  pass

  #-------------------------------------------------------------

  def __init__(self, carrier):
     self.values = []

     file = 'dat/%s/Charge_Sundry.csv' % carrier.cdpID

     f_in  = open(file, "r")

     reader = csv.reader(f_in)

     for row in reader:
        if re.search('#', row[0]):
           continue
        sundry = Charge(carrier, row)
        print sundry
        self.values.append(sundry)

     f_in.close()  # Explicitly close the file *NOW*

     self.no_values = len(self.values)

     print "Read in %d sundry charges" % self.no_values
     if debug_flg: print "Read in %d sundry charges" % self.no_values

  #-------------------------------------------------------------

  def Get(self):
     idx = random.randint(0, self.no_values - 1)

     return self.values[idx]

1. ===============================================================================

class Customers:

  pass

  #-------------------------------------------------------------

  def __init__(self, carrier):
     self.values = []

     file = 'dat/%s/Customer.csv' % carrier.cdpID

     f_in  = open(file, "r")

     reader = csv.reader(f_in)

     for row in reader:
        if re.search('#', row[0]):
           continue
        self.values.append(Customer(row))

     f_in.close()  # Explicitly close the file *NOW*

     self.no_values = len(self.values)

     if debug_flg: print "Read in %d Customers" % self.no_values

  #-------------------------------------------------------------

  def Get(self):
     idx = random.randint(0, self.no_values - 1)

     return self.values[idx]

1. ===============================================================================

class Services:

  pass

  #-------------------------------------------------------------

  def __init__(self, carrier):
     self.values = []

     file = 'dat/%s/Service.csv' % carrier.cdpID

     if debug_flg: print "Using -- %s" % file

     f_in  = open(file, "r")

     reader = csv.reader(f_in)

     for row in reader:
        if re.search('#', row[0]):
           continue
        s = Service(row)
        # print s
        self.values.append(s)

     f_in.close()  # Explicitly close the file *NOW*

     self.no_values = len(self.values)

     if debug_flg: print "Read in %d services" % self.no_values

  #-------------------------------------------------------------

  def Get(self):
     idx = random.randint(0, self.no_values - 1)

     self.values[idx].charge = []

     return self.values[idx]

1. ===============================================================================

1. -------------------------------------------------------------------------------

def load_cdp_data():

  global cdp_details

  try:
     pf = open(cdp_data_pickle, "r")
  except IOError, msg:
     sys.stderr.write('%s: cannot open: %s\n' % (cdp_data_pickle, msg))
     cdp_details = cdp_defaults
     return

  u  = pickle.Unpickler(pf)

  cdp_details = u.load()

  pf.close()

  return

1. -------------------------------------------------------------------------------

def save_cdp_data():

  try:
     pf = open(cdp_data_pickle, 'w')
  except IOError, msg:
     sys.stderr.write('%s: cannot open: %s\n' % (cdp_data_pickle, msg))
     sys.exit(1)

  p = pickle.Pickler(pf)

  p.dump(cdp_details)

  pf.close()

1. -------------------------------------------------------------------------------

def generate_orders(cdp, no_orders=1, debug=None):

  #----- Create data constructors ---------------------------------------------

  customers        = Customers(cdp)
  addresses        = Addresses(cdp)
  charges          = Charges(cdp)
  services         = Services(cdp)

  if sundry_flg:
     sundry_charges = Charges_Sundry(cdp)

  customer_list = []
 
  customer         = customers.Get()

  customer_list.append(customer)

  for order_idx in range(no_orders):
     order     = Order(cdp, customer)

     customer.order.append(order)

     order.CustomerReference = CustomerReference(cdp)

     (order.PickUpAddress, order.DeliveryAddress) = addresses.GetPair()

     order.Weight         = Weight(random.randint(100,3000))
     order.Dimension      = Dimension(random.randint(10,99))
     order.Service        = services.Get()

     if add_performance:
        order.Performance = Performance()

     order.Service.charge.append(charges.Get())

     if sundry_flg:
        for i in range(no_sundries):
           order.Service.charge.append(sundry_charges.Get())

     print "Len Charges - %d" % len(order.Service.charge)

  print customer

  return customer_list

1. ----- Construct the Service Header --------------------------------------------

def create_header(debug=None):

  reqInfo = ns1.RequestorInfo_Def('RequestorInfo').pyclass()

  reqInfo._ComponentID            = 'Test'
  reqInfo._ComponentName          = 'Test Application'

  service_header = ESBSvcHeader()

  #service_header._SvcName         = 'receiveCDPBilling'
  service_header._SvcName         = 'CDPBilling-receiveBilling'
  service_header._SvcVersion      = '1.0'
  service_header._RequestDt       = dt_request.timetuple()
  service_header._RequestorInfo   = reqInfo

  if (debug): print service_header.__dict__

1. -------------------------------------------------------------------------------

def create_request(cdp, customers, debug=None):

  global dt_request
  global service_header

  dt_request = datetime.now()

  log.write("============================================================")
  log.write("%s INFO Start new request" % dt_request.strftime("%Y-%m-%d %H:%M:%S"))

  request = None

  #----- Construct the Service Header -----------------------------------------

  reqInfo = ns1.RequestorInfo_Def('RequestorInfo').pyclass()

  reqInfo._ComponentID            = 'Test'
  reqInfo._ComponentName          = 'Test Application'

  service_header = ESBSvcHeader()

  #service_header._SvcName         = 'receiveCDPBilling'
  service_header._SvcName         = 'CDPBilling-receiveBilling'
  service_header._SvcVersion      = '1.0'
  service_header._RequestDt       = dt_request.timetuple()
  service_header._RequestorInfo   = reqInfo

  if (debug): print service_header.__dict__

  #----- Create the order request ---------------------------------------------

  request = ReceiveCDPBilling()

  request._cdpID              = cdp.cdpID
  request._consortiumID       = cdp.consortiumID
  request._sourceSystemID     = cdp.sourceSystemID
  request._sequenceID         = cdp.sequenceID
  request._notificationEmail  = notification_email
  request._Customer           = []

  # print request
  # print request.__dict__

  for cust in customers:
     customer = ns0.Customer_Def('Customer').pyclass()

     request._Customer.append(customer)

     customer._apAccountNumber  = cust.apAccountNumber
     customer._cdpAccountNumber = cust.cdpAccountNumber
     customer._cdpCustomerID    = cust.cdpCustomerID
     customer._cdpCustomerName  = cust.cdpCustomerName
     customer._Order            = []

     # print customer
     # print customer.__dict__

     for ord in cust.order:
        order = ns0.Order_Def('Order').pyclass()

        order._orderID             = ord.orderID
        order._orderStatus         = ord.orderStatus
        order._orderDateTime       = ord.orderDateTime
        order._readyDateTime       = ord.readyDateTime
        order._invoiceDateTime     = ord.invoiceDateTime
        order._numberOfItems       = ord.numberOfItems
        order._workCentreID        = ord.workCentreID
        order._CustomerReference   = None
        order._OrderReference      = None
        order._PickUpAddress       = None
        order._DeliveryAddress     = None
        order._Weight              = None
        order._Dimension           = None
        order._Performance         = None
        order._Service             = []

        print "Constructing order number %s" % order._orderID

        customer._Order.append(order)

        customerReference = ns0.CustomerReference_Def('CustomerReference').pyclass()

        cust_ref = ord.CustomerReference

        customerReference._customerCostCentre     = cust_ref.customerCostCentre

customerReference._otherCustomerRef = cust_ref.otherCustomerRef

        customerReference._otherCustomerRefDesc   = cust_ref.otherCustomerRefDesc

        order._CustomerReference   = customerReference

        pickUpAddress = ns0.Address_Def('Address').pyclass()

        pickUpAddress._address1    = ord.PickUpAddress.address1[:34]
        pickUpAddress._address2    = ord.PickUpAddress.address2[:34]
        pickUpAddress._address3    = ord.PickUpAddress.address3[:34]
        pickUpAddress._suburb      = ord.PickUpAddress.suburb
        pickUpAddress._postcode    = ord.PickUpAddress.postcode
        pickUpAddress._state       = ord.PickUpAddress.state
        pickUpAddress._country     = ord.PickUpAddress.country

        order._PickUpAddress       = pickUpAddress

        deliveryAddress = ns0.Address_Def('Address').pyclass()

        deliveryAddress._address1  = ord.DeliveryAddress.address1[:34]
        deliveryAddress._address2  = ord.DeliveryAddress.address2[:34]
        deliveryAddress._address3  = ord.DeliveryAddress.address3[:34]
        deliveryAddress._suburb    = ord.DeliveryAddress.suburb
        deliveryAddress._postcode  = ord.DeliveryAddress.postcode
        deliveryAddress._state     = ord.DeliveryAddress.state
        deliveryAddress._country   = ord.DeliveryAddress.country

        order._DeliveryAddress     = deliveryAddress

        weight = ns0.Weight_Def('Weight').pyclass()

        weight._entryWeight        = ord.Weight.entryWeight
        weight._cubedWeight        = ord.Weight.cubedWeight
        weight._actualWeight       = ord.Weight.actualWeight

        order._Weight              = weight

        dimension = ns0.Dimension_Def('Dimension').pyclass()

        dimension._height          = ord.Dimension.height
        dimension._length          = ord.Dimension.length
        dimension._width           = ord.Dimension.width

        order._Dimension           = dimension

        if ord.Performance:
           performance = ns0.Performance_Def('Performance').pyclass()

           performance._schedPickUpDateTime        = ord.Performance.schedPickUpDateTime
           performance._pickupSignatureRequired    = ord.Performance.pickupSignatureRequired
           performance._pickupSignatureReceived    = ord.Performance.pickupSignatureReceived
           performance._actualPickUpDateTime       = ord.Performance.actualPickUpDateTime
           performance._latePickUpIndicator        = ord.Performance.latePickUpIndicator
           performance._pickUpTimeliness           = ord.Performance.pickUpTimeliness
           performance._schedDeliveryDateTime      = ord.Performance.schedDeliveryDateTime
           performance._deliverySignatureRequired  = ord.Performance.deliverySignatureRequired
           performance._deliverySignatureReceived  = ord.Performance.deliverySignatureReceived
           performance._actualDeliveryDateTime     = ord.Performance.actualDeliveryDateTime
           performance._lateDeliveryIndicator      = ord.Performance.lateDeliveryIndicator
           performance._deliveryTimeliness         = ord.Performance.deliveryTimeliness

           order._Performance                      = performance

        service = ns0.Service_Def('Service').pyclass()

        service._serviceType       = ord.Service.serviceType
        service._serviceArea       = ord.Service.serviceArea
        service._serviceCodeSet    = ord.Service.serviceCodeSet
        service._serviceCode       = ord.Service.serviceCode
        service._serviceDesc       = ord.Service.serviceDesc
        service._apProductCode     = ord.Service.apProductCode
        service._deliveryDistance  = None
        service._Charge            = []

        order._Service.append(service)

        for ord_charge in ord.Service.charge:
           # ord_charge = ord.Service.charge[0]

           charge = ns0.Charge_Def('Charge').pyclass()

           charge._transactionID       = ord_charge.transactionID
           charge._transactionType     = ord_charge.transactionType
           charge._chargeType          = ord_charge.chargeType
           charge._chargeCode          = ord_charge.chargeCode
           charge._chargeCodeDesc      = ord_charge.chargeCodeDesc
           charge._priceCharged        = ord_charge.priceCharged
           charge._taxCode             = ord_charge.taxCode

           service._Charge.append(charge)

  assert isinstance(request, ReceiveCDPBilling), "ERROR: Need ReceiveCDPBilling pyclass instance"

  return request

1. -------------------------------------------------------------------------------

def send(request):

  response = None

  locator     = CDPBilling_serviceagentLocator()

  service_url = locator.getCDPBillingAddress()

  log.write('End Point (Servie URL) -> "%s"' % service_url)

  kw = {'url' : service_url}

  if log:
     kw['tracefile'] =  log

  port_type = locator.getCDPBilling(**kw)

  # service_header = GED(u'http://www.auspost.com.au/ESB/schema/ESBTypes', u'ESBSvcHeader').pyclass()
  # service_header.SvcName = 'receiveCDPBilling'

  try:
     response = port_type.receiveCDPBilling(request, soapheaders=[service_header],)

  except (Fault, FaultException), msg:
     dt_end        = datetime.now()

     print "msg -> Template:%s" % str(msg)
     print "response -> ", response

     # print response._ESBSvcHeader
     # print response._ESBException

     # faultText     = (msg.fault[0].string or '<no fault text available>')
     # faultDetail   = "SOAP response: \n" + msg.fault[1].strip("\n")

     faultText   = 'N/A'
     faultDetail = 'N/A'

     log.write("Fault (for %s): %s" % (request._Customer[0]._cdpCustomerID, faultText))
     log.write("%s ERROR Fault Exception: Details: %s, elapsed: %s, %s, %s" % \
        (datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         faultText, str(dt_end - dt_request),
         traceback.format_tb(sys.exc_info()[2],1),
         faultDetail))

  except socket.error, msg:
     log.write("Fault - socket error (for %s): %s" % (request._BusinessRefID, msg))
     log.write("%s ERROR Socket Error Exception. Details: %s %s" % \
        (datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 
        msg,
        traceback.format_tb(sys.exc_info()[2],1)))

  #----- Order successfully processed -------------------------------

  else:                
     dt_end       = datetime.now()
     log.write("OK  (for Customer %s - %s)" % (request._Customer[0]._cdpCustomerID,
                                               request._Customer[0]._cdpCustomerName))

  return response

1. -------------------------------------------------------------------------------

def analyse(logfile):

  cnt = 0

  lfd     = open(logfile, 'r')

  for line in lfd.readlines():
     if cnt == 11:
        response_xml = line[:-1]
        # print "%s" % response_xml
     # print "Cnt -> %d" % cnt
     cnt += 1

  lfd.close()

  ofd = open('response.xml', 'w')

  ofd.write(response_xml)
  ofd.close()

  return response_xml

1. -------------------------------------------------------------------------------

def examine(efd):

  resp_xml = analyse('send.log')

  dom_obj  = xml.dom.minidom.parse('response.xml')

  pp       = pprint.PrettyPrinter(indent=3)

  # print "===== dom_obj.__dict__ =========================================\n"
  # pp.pprint(dom_obj.__dict__)
  # print "\n"
  
  envelope = dom_obj.childNodes[0]

  # print "===== dom_obj.childNodes: ======================================\n"
  # pp.pprint(envelope.__dict__)
  # print "\n"

  soap_header = envelope.childNodes[0]
  # pp.pprint(soap_header.__dict__)
  # print "\n"

  svc_header = soap_header.childNodes[0]
  #pp.pprint(svc_header.__dict__)
  #print "\n"

  request_dt = svc_header.childNodes[2]
  # print "request_dt.__dict__"
  # pp.pprint(request_dt.__dict__)
  # print "\n"

  req_date = request_dt.childNodes[0].nodeValue
  t  = split(req_date, '.')
  msec = t[1].replace('Z',)
  dt = datetime(*(strptime(t[0], "%Y-%m-%dT%H:%M:%S")[0:6]))
  dt = dt.replace(microsecond=int(msec) * 1000)

  tracking = svc_header.childNodes[4]
  # print "tracking.__dict__"
  # pp.pprint(tracking.__dict__)
  # print "\n"

  status_node = tracking.childNodes[1]
  # print "status.__dict__"
  # pp.pprint(status.__dict__)
  # print "\n"
  status = status_node.childNodes[0].nodeValue

  tracking_events = tracking.childNodes[3]
  # print "tracking_events.__dict__"
  # pp.pprint(tracking_events.__dict__)
  # print "\n"

  events1 = tracking_events.childNodes[0]
  # print "events1.__dict__"
  # pp.pprint(events1.__dict__)
  # print "\n"

  e1_dt_node = events1.childNodes[1]
  # pp.pprint(e1_dt_node.__dict__)
  # print "\n"
  e1_dt = e1_dt_node.childNodes[0].nodeValue
  t  = split(e1_dt, '.')
  msec = t[1].replace('+10:00',)
  e1_dt = datetime(*(strptime(t[0], "%Y-%m-%dT%H:%M:%S")[0:6]))
  dt_end = e1_dt.replace(microsecond=int(msec) * 1000)

  e1_desc_node = events1.childNodes[2]
  e1_desc = e1_desc_node.childNodes[0].nodeValue
  # print e1_desc
  m = re.search("ocessed is ([0-9]*),", e1_desc)
  if m:
     no_orders = int(m.group(1))
  else:
     no_orders = 0

  events2 = tracking_events.childNodes[1]
  # pp.pprint(events2.__dict__)
  # print "\n"

  e2_node = events2.childNodes[1]
  # pp.pprint(e2_node.__dict__)
  # print "\n"
  e2_dt = e2_node.childNodes[0].nodeValue
  t  = split(e2_dt, '.')
  msec = t[1].replace('+10:00',)
  e2_dt = datetime(*(strptime(t[0], "%Y-%m-%dT%H:%M:%S")[0:6]))
  dt_start = e2_dt.replace(microsecond=int(msec) * 1000)

  e2_desc_node = events2.childNodes[2]
  e2_desc = e2_desc_node.childNodes[0].nodeValue
  #print "    frontend processing desc:  %s" % e2_desc

  t_delta    = dt_end - dt_start
  t_microsec = 0.0 + (t_delta.days * 86400) + t_delta.seconds + (t_delta.microseconds/1000000.0)

  efd.write("                Request date:  %s\n" % req_date)
  efd.write("                    Received:  %d orders\n" % no_orders)
  efd.write("                      Status:  %s\n\n" % status)
  efd.write("Start frontend processing DT:  %s\n" % dt_start)
  efd.write("  End frontend processing DT:  %s\n" % dt_end)
  efd.write("     Average processing time:  %.03f seconds\n" % (t_microsec/no_orders))
  efd.write("    %4d orders processed in:  %.03f seconds\n" % (no_orders, t_microsec))

  efd.close()

  # PLH

  # body = envelope.childNodes[1]
  # pp.pprint(body)
  # pp.pprint(body.__dict__)
  # print "\n"

  # billing_response = body.childNodes[0]
  # pp.pprint(billing_response)
  # pp.pprint(billing_response.__dict__)
  # print "\n"

1. -------------------------------------------------------------------------------

def generate(cdpId, no_orders):

  global log
  global dt_order
  global cdp_details
  global add_performance

  dt_order = datetime.now() - timedelta(days=3)
  dt_stamp = datetime.now().strftime('%Y%m%d%H%M%S')

  print "Timestamp [%s]" % dt_stamp
  print "Posting order at %s" % dt_order
  print "timetuple %s" % dt_order.timetuple()

  load_cdp_data()

  if (cdpId == 'MPC'):
     add_performance = True

  logfile = "log/ReceiveCDPBilling__%s.log" % dt_stamp

  log     = open(logfile, 'w+')

  cdp     = CDP(cdpId)

  customer_orders = generate_orders(cdp, no_orders=no_orders)

  request  = create_request(cdp, customer_orders)

  response = send(request)

  save_cdp_data()

  log.close()

  os.system('rm send.log');
  os.system('ln -s %s send.log' % logfile);

  if (response == 'success'):
     exlog = "log/examine__%s.log" % dt_stamp
     efd = open(exlog, 'w')
     examine(efd)
     efd.close()
     os.system('rm examine.log')
     os.system('ln -s %s examine.log' % exlog)
     os.system('cat examine.log')

1. -------------------------------------------------------------------------------

def usage():

  USAGE = """
  
    Usage:
    
      $ dt.py
   
  """
  
  sys.stderr.write(USAGE)
  

1. -------------------------------------------------------------------------------

def main(argv):

  global debug_flg, verbose_flg, sundry_flg, cdpId, no_orders, no_sundries

  loop_cnt    = 1
  examine_flg = False

  #----- Process command line arguments ----------------------------

  try:
     opts, args = getopt.getopt(argv, "c:dehl:n:sS:v",
             ["cdp", "debug", "examine", "help", "loop", "no=", "sundry", "sundries", "verbose"])
  except getopt.GetoptError:
     usage()
     sys.exit(2)
  else:
     for opt, arg in opts:
        if opt in ("-h", "--help"):
           usage()
           sys.exit(0)
        elif opt in ("-c", "--cdp"):
           cdpId = arg
        elif opt in ("-e", "--examine"):
           examine_flg = True
        elif opt in ("-l", "--loop"):
           loop_cnt = int(arg)
        elif opt in ("-n", "--no"):
           no_orders = int(arg)
        elif opt in ("-s", "--sundry"):
           sundry_flg  = True
           no_sundries = 1
        elif opt in ("-S", "--sundries"):
           sundry_flg  = True
           no_sundries = int(arg)
        elif opt in ("-v", "--verbose"):
           verbose_flg = True

  if not cdp_defaults.has_key(cdpId):
     print 'Bad CDP ID "%s"' % cdpId
     sys.exit(1)

  if examine_flg:
     examine(sys.stdout)
  else:
     for idx in range(loop_cnt):
        generate(cdpId, no_orders)
        if idx < loop_cnt - 1:
           time.sleep(30)

1. ---------------------------------------------------------------------

if __name__ == "__main__":

  main(sys.argv[1:])

1. ---------------------------------------------------------------------

"""

ESBSOAPException:

               def __init__(self):
                   # pyclass
                   self._ESBSvcHeader = None
                   self._ESBException = None
                   return

ESBSvcHeader

               def __init__(self):
                   # pyclass
                   self._SvcName = None
                   self._SvcVersion = None
                   self._RequestDt = None
                   self._RequestorInfo = None
                   self._Tracking = None
                   return

ESBException:

               def __init__(self):
                   # pyclass
                   self._ExceptionCategory = None
                   self._ExceptionType = None
                   self._ExceptionCode = None
                   self._ExceptionDescription = None
                   self._ExceptionOtherData = None
                   self._ESBAlert = None
                   return

"""