APIOperationBase.execute() - Code Metrics - Inspection of "Merge pull request #64 from AuthorizeNet/future" - AuthorizeNet/sdk-python - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 894137...9ad265 )

unknown

created 2016-08-12 16:56 UTC

APIOperationBase.execute() C

↳ Parent: APIOperationBase

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

Metric	Value
c	5
b	0
f	0
dl	0
loc	56
rs	6.7294
cc	7

How to fix Long Method

'''
Created on Nov 1, 2015

@author: krgupta
'''
import abc
import logging
import pyxb
import sys
import xml.dom.minidom
from pip._vendor import requests
from lxml import objectify

from authorizenet.constants import constants
from authorizenet import apicontractsv1
from authorizenet import utility
'''
from authorizenet.apicontractsv1 import merchantAuthenticationType
from authorizenet.apicontractsv1 import ANetApiRequest
from authorizenet.apicontractsv1 import ANetApiResponse
'''
class APIOperationBaseInterface(object):
    
    __metaclass__ = abc.ABCMeta
    
    @abc.abstractmethod
    def execute(self):
        '''
        Makes a http-post call. 
        Uses request xml and response class type to check that the response was of correct type
        '''
        pass

    @abc.abstractmethod
    def getresponseclass(self):
        ''' Returns the response class '''
        pass
    
    @abc.abstractmethod
    def getrequesttype(self):
        ''' Returns the request class '''
        pass
    
    @abc.abstractmethod
    def getresponse(self):
        ''' Returns the de-serialized response'''
        pass
    
    @abc.abstractmethod
    def getresultcode(self):
        ''' Returns the result code from the response '''
        pass
    
    @abc.abstractmethod
    def getmessagetype(self):
        ''' Returns the message type enum from the response '''
        pass

    @abc.abstractmethod
    def afterexecute(self):
        '''Returns the message received from binding after processing request'''
        pass

    @abc.abstractmethod
    def beforeexecute(self):
        '''TODO'''
        pass

class APIOperationBase(APIOperationBaseInterface):
    
    __metaclass__ = abc.ABCMeta 
    __initialized = False
    __merchantauthentication = "null"
    __environment = "null"
    
    @staticmethod
    def __classinitialized():
        return APIOperationBase.__initialized
    
    @abc.abstractmethod
    def validaterequest(self):
        return
    
    def validate(self):
        anetapirequest = self._getrequest()
        self.validateandsetmerchantauthentication()       
        self.validaterequest()
        
        return

    def setClientId(self): #protected method
        self._request.clientId = constants.clientId

    def _getrequest(self): #protected method
        return self._request 
     
    def buildrequest(self):
        logging.debug('building request..')
        
        xmlRequest = self._request.toxml(encoding=constants.xml_encoding, element_name=self.getrequesttype())
        #remove namespaces that toxml() generates
        xmlRequest = xmlRequest.replace(constants.nsNamespace1, b'')
        xmlRequest = xmlRequest.replace(constants.nsNamespace2, b'')

        return xmlRequest
    
    def getprettyxmlrequest(self):
        xmlRequest = self.buildrequest()
        requestDom = xml.dom.minidom.parseString(xmlRequest)
        logging.debug('Request is: %s' % requestDom.toprettyxml())

        return requestDom
    
    def execute(self):
        
        self.endpoint = APIOperationBase.__environment
              
        logging.debug('Executing http post to url: %s', self.endpoint)
        
        self.beforeexecute()
        
        proxyDictionary = {'http' : utility.helper.getproperty("http"),
                           'https' : utility.helper.getproperty("https"),
                           'ftp' : utility.helper.getproperty("ftp")}
                           
        #requests is http request  
        try:
            self.setClientId()
            xmlRequest = self.buildrequest()
            self._httpResponse = requests.post(self.endpoint, data=xmlRequest, headers=constants.headers, proxies=proxyDictionary)
        except Exception as httpException:
            logging.error( 'Error retrieving http response from: %s for request: %s', self.endpoint, self.getprettyxmlrequest())
            logging.error( 'Exception: %s, %s', type(httpException), httpException.args )


        if self._httpResponse:            
            self._httpResponse.encoding = constants.response_encoding
            self._httpResponse = self._httpResponse.text[3:] #strip BOM
            self.afterexecute()
            try:
                self._response = apicontractsv1.CreateFromDocument(self._httpResponse) 
                #objectify code  
                xmlResponse= self._response.toxml(encoding=constants.xml_encoding, element_name=self.getrequesttype()) 
                xmlResponse = xmlResponse.replace(constants.nsNamespace1, b'')
                xmlResponse = xmlResponse.replace(constants.nsNamespace2, b'') 
                self._mainObject = objectify.fromstring(xmlResponse)   
                 
            except Exception as objectifyexception:
                logging.error( 'Create Document Exception: %s, %s', type(objectifyexception), objectifyexception.args )
                pyxb.GlobalValidationConfig._setForBinding(False)
                self._response = apicontractsv1.CreateFromDocument(self._httpResponse)    
                #objectify code 
                xmlResponse= self._response.toxml(encoding=constants.xml_encoding, element_name=self.getrequesttype()) 
                xmlResponse = xmlResponse.replace(constants.nsNamespace1, b'')
                xmlResponse = xmlResponse.replace(constants.nsNamespace2, b'') 
                self._mainObject = objectify.fromstring(xmlResponse) 
            else:    
                #if type(self.getresponseclass()) == type(self._response):
                if type(self.getresponseclass()) != type(self._mainObject):
                    if self._response.messages.resultCode == "Error":
                        logging.debug("Response error")
                    domResponse = xml.dom.minidom.parseString(self._httpResponse)
                    logging.debug('Received response: %s' % domResponse.toprettyxml())
                else:
                    #Need to handle ErrorResponse  
                    logging.debug('Error retrieving response for request: %s' % self._request)
        else:
            logging.debug("Did not receive http response")
        return
    
    def getresponse(self):
        #return self._response #pyxb object
        return self._mainObject #objectify object
    
    def getresultcode(self):
        resultcode = 'null'
        if self._response:
            resultcode = self._response.resultCode
        return resultcode
    
    def getmessagetype(self):
        message = 'null'
        if self._response:
            message = self._response.message
        return message
    
    def afterexecute(self ):
        return 
    
    def beforeexecute(self):
        return 
    
    @staticmethod
    def getmerchantauthentication(self):
        return self.__merchantauthentication
    
    @staticmethod
    def setmerchantauthentication(merchantauthentication):
        APIOperationBase.__merchantauthentication = merchantauthentication
        return
    
    def validateandsetmerchantauthentication(self):
        anetapirequest = apicontractsv1.ANetApiRequest()
        if (anetapirequest.merchantAuthentication == "null"):
            if (self.getmerchantauthentication() != "null"):
                anetapirequest.merchantAuthentication = self.getmerchantauthentication()
            else:
                raise ValueError('Merchant Authentication can not be null')
        return
    
    @staticmethod
    def getenvironment(self):
        return APIOperationBase.__environment
        
    
    @staticmethod
    def setenvironment(userenvironment):
        APIOperationBase.__environment = userenvironment 
        return 
    
    def __init__(self, apiRequest):
        self._httpResponse = None
        self._request = None
        self._response = None
        #objectify variables 
        self._responseXML = None
        self._reponseObject = None
        self._mainObject = None
               
        if None == apiRequest:
            raise ValueError('Input request cannot be null')
         
        self._request = apiRequest
        __merchantauthentication = apicontractsv1.merchantAuthenticationType()
        APIOperationBase.__environment = constants.SANDBOX
        
        APIOperationBase.setmerchantauthentication(__merchantauthentication)

        if ( False == APIOperationBase.__classinitialized()):
            loggingfilename = utility.helper.getproperty(constants.propertiesloggingfilename)
            logginglevel = utility.helper.getproperty(constants.propertiesexecutionlogginglevel)
            
            if (None == loggingfilename):
                loggingfilename = constants.defaultLogFileName
            if (None == logginglevel):
                logginglevel = constants.defaultLoggingLevel
                
            logging.basicConfig(filename=loggingfilename, level=logginglevel, format=constants.defaultlogformat)
            __initialized = True

        self.validate()
            
        return


1			'''
2			Created on Nov 1, 2015
3
4			@author: krgupta
5			'''
6			import abc
7			import logging
8			import pyxb
9			import sys
10			import xml.dom.minidom
11			from pip._vendor import requests
12			from lxml import objectify
13
14			from authorizenet.constants import constants
15			from authorizenet import apicontractsv1
16			from authorizenet import utility
17			'''
18			from authorizenet.apicontractsv1 import merchantAuthenticationType
19			from authorizenet.apicontractsv1 import ANetApiRequest
20			from authorizenet.apicontractsv1 import ANetApiResponse
21			'''
22			class APIOperationBaseInterface(object):
23
24			__metaclass__ = abc.ABCMeta
25
26			@abc.abstractmethod
27			def execute(self):
28			'''
29			Makes a http-post call.
30			Uses request xml and response class type to check that the response was of correct type
31			'''
32			pass
33
34			@abc.abstractmethod
35			def getresponseclass(self):
36			''' Returns the response class '''
37			pass
38
39			@abc.abstractmethod
40			def getrequesttype(self):
41			''' Returns the request class '''
42			pass
43
44			@abc.abstractmethod
45			def getresponse(self):
46			''' Returns the de-serialized response'''
47			pass
48
49			@abc.abstractmethod
50			def getresultcode(self):
51			''' Returns the result code from the response '''
52			pass
53
54			@abc.abstractmethod
55			def getmessagetype(self):
56			''' Returns the message type enum from the response '''
57			pass
58
59			@abc.abstractmethod
60			def afterexecute(self):
61			'''Returns the message received from binding after processing request'''
62			pass
63
64			@abc.abstractmethod
65			def beforeexecute(self):
66			'''TODO'''
67			pass
68
69			class APIOperationBase(APIOperationBaseInterface):
70
71			__metaclass__ = abc.ABCMeta
72			__initialized = False
73			__merchantauthentication = "null"
74			__environment = "null"
75
76			@staticmethod
77			def __classinitialized():
78			return APIOperationBase.__initialized
79
80			@abc.abstractmethod
81			def validaterequest(self):
82			return
83
84			def validate(self):
85			anetapirequest = self._getrequest()
86			self.validateandsetmerchantauthentication()
87			self.validaterequest()
88
89			return
90
91			def setClientId(self): #protected method
92			self._request.clientId = constants.clientId
93
94			def _getrequest(self): #protected method
95			return self._request
96
97			def buildrequest(self):
98			logging.debug('building request..')
99
100			xmlRequest = self._request.toxml(encoding=constants.xml_encoding, element_name=self.getrequesttype())
101			#remove namespaces that toxml() generates
102			xmlRequest = xmlRequest.replace(constants.nsNamespace1, b'')
103			xmlRequest = xmlRequest.replace(constants.nsNamespace2, b'')
104
105			return xmlRequest
106
107			def getprettyxmlrequest(self):
108			xmlRequest = self.buildrequest()
109			requestDom = xml.dom.minidom.parseString(xmlRequest)
110			logging.debug('Request is: %s' % requestDom.toprettyxml())
111
112			return requestDom
113
114			def execute(self):
115
116			self.endpoint = APIOperationBase.__environment
117
118			logging.debug('Executing http post to url: %s', self.endpoint)
119
120			self.beforeexecute()
121
122			proxyDictionary = {'http' : utility.helper.getproperty("http"),
123			'https' : utility.helper.getproperty("https"),
124			'ftp' : utility.helper.getproperty("ftp")}
125
126			#requests is http request
127			try:
128			self.setClientId()
129			xmlRequest = self.buildrequest()
130			self._httpResponse = requests.post(self.endpoint, data=xmlRequest, headers=constants.headers, proxies=proxyDictionary)
131			except Exception as httpException:
132			logging.error( 'Error retrieving http response from: %s for request: %s', self.endpoint, self.getprettyxmlrequest())
133			logging.error( 'Exception: %s, %s', type(httpException), httpException.args )
134
135
136			if self._httpResponse:
137			self._httpResponse.encoding = constants.response_encoding
138			self._httpResponse = self._httpResponse.text[3:] #strip BOM
139			self.afterexecute()
140			try:
141			self._response = apicontractsv1.CreateFromDocument(self._httpResponse)
142			#objectify code
143			xmlResponse= self._response.toxml(encoding=constants.xml_encoding, element_name=self.getrequesttype())
144			xmlResponse = xmlResponse.replace(constants.nsNamespace1, b'')
145			xmlResponse = xmlResponse.replace(constants.nsNamespace2, b'')
146			self._mainObject = objectify.fromstring(xmlResponse)
147
148			except Exception as objectifyexception:
149			logging.error( 'Create Document Exception: %s, %s', type(objectifyexception), objectifyexception.args )
150			pyxb.GlobalValidationConfig._setForBinding(False)
151			self._response = apicontractsv1.CreateFromDocument(self._httpResponse)
152			#objectify code
153			xmlResponse= self._response.toxml(encoding=constants.xml_encoding, element_name=self.getrequesttype())
154			xmlResponse = xmlResponse.replace(constants.nsNamespace1, b'')
155			xmlResponse = xmlResponse.replace(constants.nsNamespace2, b'')
156			self._mainObject = objectify.fromstring(xmlResponse)
157			else:
158			#if type(self.getresponseclass()) == type(self._response):
159			if type(self.getresponseclass()) != type(self._mainObject):
160			if self._response.messages.resultCode == "Error":
161			logging.debug("Response error")
162			domResponse = xml.dom.minidom.parseString(self._httpResponse)
163			logging.debug('Received response: %s' % domResponse.toprettyxml())
164			else:
165			#Need to handle ErrorResponse
166			logging.debug('Error retrieving response for request: %s' % self._request)
167			else:
168			logging.debug("Did not receive http response")
169			return
170
171			def getresponse(self):
172			#return self._response #pyxb object
173			return self._mainObject #objectify object
174
175			def getresultcode(self):
176			resultcode = 'null'
177			if self._response:
178			resultcode = self._response.resultCode
179			return resultcode
180
181			def getmessagetype(self):
182			message = 'null'
183			if self._response:
184			message = self._response.message
185			return message
186
187			def afterexecute(self ):
188			return
189
190			def beforeexecute(self):
191			return
192
193			@staticmethod
194			def getmerchantauthentication(self):
195			return self.__merchantauthentication
196
197			@staticmethod
198			def setmerchantauthentication(merchantauthentication):
199			APIOperationBase.__merchantauthentication = merchantauthentication
200			return
201
202			def validateandsetmerchantauthentication(self):
203			anetapirequest = apicontractsv1.ANetApiRequest()
204			if (anetapirequest.merchantAuthentication == "null"):
205			if (self.getmerchantauthentication() != "null"):
206			anetapirequest.merchantAuthentication = self.getmerchantauthentication()
207			else:
208			raise ValueError('Merchant Authentication can not be null')
209			return
210
211			@staticmethod
212			def getenvironment(self):
213			return APIOperationBase.__environment
214
215
216			@staticmethod
217			def setenvironment(userenvironment):
218			APIOperationBase.__environment = userenvironment
219			return
220
221			def __init__(self, apiRequest):
222			self._httpResponse = None
223			self._request = None
224			self._response = None
225			#objectify variables
226			self._responseXML = None
227			self._reponseObject = None
228			self._mainObject = None
229
230			if None == apiRequest:
231			raise ValueError('Input request cannot be null')
232
233			self._request = apiRequest
234			__merchantauthentication = apicontractsv1.merchantAuthenticationType()
235			APIOperationBase.__environment = constants.SANDBOX
236
237			APIOperationBase.setmerchantauthentication(__merchantauthentication)
238
239			if ( False == APIOperationBase.__classinitialized()):
240			loggingfilename = utility.helper.getproperty(constants.propertiesloggingfilename)
241			logginglevel = utility.helper.getproperty(constants.propertiesexecutionlogginglevel)
242
243			if (None == loggingfilename):
244			loggingfilename = constants.defaultLogFileName
245			if (None == logginglevel):
246			logginglevel = constants.defaultLoggingLevel
247
248			logging.basicConfig(filename=loggingfilename, level=logginglevel, format=constants.defaultlogformat)
249			__initialized = True
250
251			self.validate()
252
253			return
254

AuthorizeNet / sdk-python

Push — master ( 894137...9ad265 )

APIOperationBase.execute() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like