source: TI03-DataExtractor/branches/old_stuff/abstractPWSC/apwsui.py @ 793

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI03-DataExtractor/branches/old_stuff/abstractPWSC/apwsui.py@793
Revision 793, 8.3 KB checked in by astephen, 13 years ago (diff)

Put all the old code in the old_stuff branch.

  • Property svn:executable set to *
Line 
1#!/usr/local/cdat/bin/python
2"""
3apwsui.py
4=========
5
6This is the CGIClient for the AbstractPyWebService.
7
8It holds the CGIClient class.
9
10"""
11DEBUG=1
12# Set up cgi error reporting to screen if DEBUG is on
13if DEBUG==1:
14    import cgitb 
15    cgitb.enable() 
16
17# Import standard library modules
18import sys, cgi
19       
20# Import SOAP library   
21from ZSI.client import Binding 
22       
23# Import package modules
24BASEDIR="/home/as56/abstractWebService"
25sys.path.append(BASEDIR)
26from abstractPWSC import *
27
28
29class CGIClient:
30    """
31    The controlling class for the CGI client to the abstractPWSS.
32    """
33   
34    def __init__(self):
35        """
36        Initiates the instance setting up the appropriate
37        internal objects and calls to the relevant classes depending
38        on the configuration and arguments provided.
39        """
40        self.username=None
41        self.password=None
42        self.secureToken=None
43        self.userRoles=[]
44        self.loginStatus="out"
45        self.loginMessage=""
46        self.sessionObject={}
47       
48        self.displayer=DisplayManager()
49       
50        # Parse the arguments
51        try:
52            self._parseArgs()
53        except:
54            if DEBUG==1:
55                raise
56            else:
57                CGIErrorHandler("Error parsing arguments: "+str(sys.exc_type), noheader=0)
58
59        # Destroy any arguments not intended to pass any further
60        try:
61            self._destroyUnnecessaryArgs()
62        except:
63            if DEBUG==1:
64                raise
65            else:
66                CGIErrorHandler("Error destroying arguments: "+str(sys.exc_type), noheader=0)
67
68        # If switched on check security       
69        if RESTRICTED_DATA==1:
70            try:
71                self._checkSecurity()
72            except:
73                if DEBUG==1:
74                    raise
75                else:
76                    CGIErrorHandler("Security error: "+str(sys.exc_type), noheader=0)
77        else:
78            self.secureToken=None             
79                   
80        # Call the Web Service with the arguments provided       
81        try:
82            self._callAbstractPWSS(self.args)
83        except:
84            if DEBUG==1:
85                raise
86            else:
87                CGIErrorHandler("Error calling Web Service: "+str(sys.exc_type), noheader=0)       
88               
89        try:   
90            self.displayer._displayHTMLFooter() 
91        except:
92            if DEBUG==1:
93                raise
94            else:
95                CGIErrorHandler("Error generating HTML footer: "+str(sys.exc_type), noheader=0)
96       
97       
98    def _parseArgs(self):
99        """
100        Parses the arguments sent, if any, ready for sending to the
101        web service.
102        """
103        # Get arguments
104        self.args={}                           
105        args=cgi.FieldStorage() 
106
107        # Populate the argument dictionary
108        for key in args.keys(): 
109            self.args[key]=args.getvalue(key) 
110                   
111        if self.args.has_key("sessionID") and self.args["sessionID"]=="None":
112            self.args["sessionID"]=None     
113         
114        # Check for secure items, destroy if necessary and assign as instance variables   
115        if self.args.has_key("yousirnaim"):
116            self.username=self.args["yousirnaim"]
117            self.args["username"]=self.username
118            del self.args["yousirnaim"]
119           
120        if self.args.has_key("parcewerd"):
121            self.password=self.args["parcewerd"] 
122            del self.args["parcewerd"] 
123               
124        if self.args.has_key("secureToken"):
125            self.secureToken=self.args["secureToken"]
126            del self.args["secureToken"]   
127       
128        if not self.args.has_key("username"):
129            self.args["username"]=None
130       
131           
132    def _destroyUnnecessaryArgs(self):
133        """
134        Destroy the arguments that should not be passed to the main dx Web Service.
135        """
136        if self.args.has_key("password"):
137            del self.args["password"]
138       
139       
140    def _checkSecurity(self):
141        """
142        If security is switched on with RESTRICTED_DATA=1 then this will
143        call the local implementation of the security.
144        """
145
146        secChecker=SecurityViaCGI(self.username, self.password, self.secureToken)
147       
148        # Deal with logout
149        ############# NOTE - doesn't destroy session server side (yet)
150        if self.args.has_key("logout") and self.args["logout"]=="Logout":
151            secChecker.logout()
152            secCheck="You have been logged out."
153        else:
154            secCheck=secChecker.validate()         
155           
156        if type(secCheck)==type(""):
157            # Returned string means error in log in or logged out
158            self.loginMessage=secCheck
159        else:
160            self.loginStatus="in"
161            self.loginMessage=""
162            (self.secureToken, self.username, self.userRoles)=secCheck     
163               
164                       
165    def _callAbstractPWSS(self, args):
166        """
167        According to the arguments given this binds to an appropriate
168        Web Service and calls it with the relevant arguments.
169        """       
170        # Just print the login page if not logged in
171        if RESTRICTED_DATA==1 and self.loginStatus=="out":
172            self.displayer._displayHTTPHeader()
173            self.displayer._displayHTMLHeader()
174            self.displayer._displayLoginBar(self.username, self.loginStatus, self.loginMessage)
175            return
176           
177        # Set up SOAP bindings
178        server=Binding(url='', host=SOAP_SERVER_NAME, port=SOAP_SERVER_PORT) 
179       
180        # Make sure we have a session going and get a sessionID
181        if not self.args.has_key("sessionID") or self.args["sessionID"] in (None, "None"):
182            # Start session if not known about
183            response=self._webServiceCallWrapper(server.startSession(self.username, self.password, self.secureToken))
184            self.sessionID, self.secureToken=response
185        else:
186            self.sessionID=self.args["sessionID"] 
187       
188        self.args["sessionID"]=self.sessionID
189        # Clear session if requested   
190        if self.args.has_key("clearSession") or self.args.has_key("newSession"):
191            response=self._webServiceCallWrapper(server.newSession(self.sessionID, self.secureToken))
192            self.sessionID, self.secureToken=response
193                                                               
194        # Check if complete, then create output if it is complete
195        isCompleteStatus=0
196        if self.args.has_key("isComplete"):
197            response=self._webServiceCallWrapper(server.isComplete(self.sessionID, self.secureToken))
198            isCompleteStatus, self.secureToken=response     
199
200        if not self.args.has_key("secureToken"): self.args["secureToken"]=self.secureToken
201
202        # Select whatever user has selected and get the next lot of options 
203        response=self._webServiceCallWrapper(apply(server.selectOptions, [self.sessionID, self._packArgsAsList(args)]))
204        (optionCategories, options, optionStrings, secureToken)=response
205
206        # Make sure we have a secure token (=None if not configured)
207        #if not self.args.has_key("secureToken"): self.args["secureToken"]=self.secureToken
208        #if RESTRICTED_DATA==1:
209        #    self._upDateSecureToken(secureToken)
210       
211        # If the request is complete then create the output file(s)   
212        if isCompleteStatus==1 or optionCategories==[]:
213            response=self._webServiceCallWrapper(server.createOutput(self.sessionID, self.secureToken))
214            outputFilePath=response[0][0][0]
215            self.displayer._displayHTTPHeader()
216            self.displayer._displayHTMLHeader()
217            if RESTRICTED_DATA==1: 
218                self.displayer._displayLoginBar(self.username, self.loginStatus, self.loginMessage)
219            self.displayer._displayOutputPage(outputFilePath)       
220        else:
221            optcat=optionCategories[0][0]               
222            self.displayer._displayHTTPHeader()             
223            self.displayer._displayHTMLHeader()
224            if RESTRICTED_DATA==1:
225                self.displayer._displayLoginBar(self.username, self.loginStatus, self.loginMessage)
226            summaryList=[]
227           
228            for i in range(1,100): 
229                if self.args.has_key("option%s" % i): 
230                    summaryList.append(self.args["option%s" % i])
231            self.displayer._displaySummaryLine(summaryList)
232            self.displayer._displayMainTableHeader()
233            self.displayer._displayOptionsTable(optionCategories, options, self.sessionID)
234            self.displayer._displayMainTableFooter()
235       
236                               
237    def _webServiceCallWrapper(self, response):
238        """
239        Analyses the response from a Web Service call to check if an error has
240        occurred. If so it parses and reports the error. Otherwise it returns 
241        the object returned from the Web Service call.
242        """
243        if type(response)==type(""):
244            # String returns are errors
245            self.displayer._displayErrorPage(response)
246            self.displayer._displayHTMLFooter()
247            sys.exit()
248        else:
249            return response         
250
251
252    def _packArgsAsList(self, args):
253        """
254        In order to work with ZSI SOAP library need to pack up arguments as a list
255        of [keyword, value] pairs rather than a dictionary.
256        """
257        newList=[]
258        for key, value in args.items():
259            newList.append([key, value])
260        return newList
261       
262       
263    def _validateRequest(self):
264        """
265        Calls the validation Web Service to check that the current selection is
266        within the available options. This will be needed as users can write their
267        own XML files and upload them.
268        """
269        pass
270       
271
272if __name__=="__main__":
273
274    CGIClient() 
275
276
Note: See TracBrowser for help on using the repository browser.