home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / xbmc-9.11.exe / system / python / spyce / modules / request.py < prev    next >
Encoding:
Python Source  |  2009-12-23  |  8.5 KB  |  225 lines
  1. ##################################################
  2. # SPYCE - Python-based HTML Scripting
  3. # Copyright (c) 2002 Rimon Barr.
  4. #
  5. # Refer to spyce.py
  6. # CVS: $Id: request.py 20864 2009-06-02 06:16:47Z ceros7 $
  7. ##################################################
  8.  
  9. from spyceModule import spyceModule
  10. import cgi, string, urlparse, spyceUtil
  11.  
  12. __doc__ = """Request module provides access to the browser request
  13. information. """
  14.  
  15. class request(spyceModule):
  16.   def start(self):
  17.     "Initialise module variables"
  18.     self._get = None
  19.     self._postfields = None
  20.   def uri(self, component=None):
  21.     "Return request URI, or URI component"
  22.     theuri = self._api.getRequest().env()['REQUEST_URI']
  23.     if not component:
  24.       return theuri
  25.     else:
  26.       component = string.lower(component)
  27.       if component == 'scheme': component = 0
  28.       elif component == 'location': component = 1
  29.       elif component == 'path': component = 2
  30.       elif component == 'parameters': component = 3
  31.       elif component == 'query': component = 4
  32.       elif component == 'fragment': component = 5
  33.       else: raise 'unknown uri component'
  34.       return urlparse.urlparse(theuri)[component]
  35.   def uri_scheme(self):
  36.     "Return request URI scheme, ie. http (usually)"
  37.     return urlparse.urlparse(self.uri())[0]
  38.   def uri_location(self):
  39.     "Return request URI scheme, ie. http (usually)"
  40.     return urlparse.urlparse(self.uri())[1]
  41.   def uri_path(self):
  42.     "Return request URI path component"
  43.     return urlparse.urlparse(self.uri())[2]
  44.   def method(self):
  45.     "Return request method: get/post/..."
  46.     return string.upper(self._api.getRequest().env()['REQUEST_METHOD'])
  47.   def query(self):
  48.     "Return request query string"
  49.     return self._api.getRequest().env()['QUERY_STRING']
  50.   def filename(self, relative=None):
  51.     "Return original Spyce filename"
  52.     myfile = self._api.getFilename()
  53.     if relative==None:
  54.       return myfile
  55.     else:
  56.       return os.path.normpath(os.path.join(os.path.dirname(myfile), relative))
  57.   def default(self, value, value2):
  58.     "Return value, or value2 if value==None"
  59.     if value==None: return value2
  60.     return value
  61.   def _getInit(self):
  62.     if self._get==None:
  63.       self._get = cgi.parse_qs(self.query(), 1)
  64.       self._get1 = {}
  65.       self._getL = {}
  66.       self._getL1 = {}
  67.       for key in self._get.keys():
  68.         self._getL[string.lower(key)] = []
  69.       for key in self._get.keys():
  70.         keyL = string.lower(key)
  71.         self._getL[keyL] = self._getL[keyL] + self._get[key]
  72.       for key in self._get.keys():
  73.         self._get1[key] = self._get[key][0]
  74.       for keyL in self._getL.keys():
  75.         self._getL1[keyL] = self._getL[keyL][0]
  76.   def get(self, name=None, default=None, ignoreCase=0):
  77.     "Return GET parameter(s) list(s)"
  78.     self._getInit()
  79.     if ignoreCase:
  80.       if name: name = string.lower(name)
  81.       value = spyceUtil.extractValue(self._getL, name)
  82.     else:
  83.       value = spyceUtil.extractValue(self._get, name)
  84.     return self.default(value, default)
  85.   def get1(self, name=None, default=None, ignoreCase=0):
  86.     "Return single GET parameter(s)"
  87.     self._getInit()
  88.     if ignoreCase:
  89.       if name: name = string.lower(name)
  90.       value = spyceUtil.extractValue(self._getL1, name)
  91.     else:
  92.       value = spyceUtil.extractValue(self._get1, name)
  93.     return self.default(value, default)
  94.   def _postInit(self):
  95.     if self._postfields==None:
  96.       if hasattr(self._api.getRequest(), 'spycepostinfo'):
  97.         # stream was already parsed (possibly this is an internal redirect)
  98.         (self._post, self._post1, self._file, 
  99.           self._postL, self._postL1, self._fileL, 
  100.           self._postfields) = self._api.getRequest().spycepostinfo
  101.         return
  102.       self._post = {}
  103.       self._post1 = {}
  104.       self._file = {}
  105.       self._postL = {}
  106.       self._postL1 = {}
  107.       self._fileL = {}
  108.       self._postfields={}
  109.       try: len = int(str(self.env('CONTENT_LENGTH')))
  110.       except: len=0
  111.       if self.method()=='POST' and len:
  112.         self._postfields = cgi.FieldStorage(fp=self._api.getRequest(), environ=self.env(), keep_blank_values=1)
  113.         for key in self._postfields.keys():
  114.           if type(self._postfields[key]) == type( [] ):
  115.             self._post[key] = map(lambda attr: attr.value, self._postfields[key])
  116.             self._post1[key] = self._post[key][0]
  117.           elif not self._postfields[key].filename:
  118.             self._post[key] = [self._postfields[key].value]
  119.             self._post1[key] = self._post[key][0]
  120.           else:
  121.             self._file[key] = self._fileL[string.lower(key)] = self._postfields[key]
  122.         for key in self._post.keys():
  123.           self._postL[string.lower(key)] = []
  124.         for key in self._post.keys():
  125.           keyL = string.lower(key)
  126.           self._postL[keyL] = self._postL[keyL] + self._post[key]
  127.         for keyL in self._postL.keys():
  128.           self._postL1[keyL] = self._postL[keyL][0]
  129.       # save parsed information in request object to prevent reparsing (on redirection)
  130.       self._api.getRequest().spycepostinfo = (self._post, self._post1, self._file, 
  131.         self._postL, self._postL1, self._fileL, self._postfields)
  132.   def post(self, name=None, default=None, ignoreCase=0):
  133.     "Return POST parameter(s) list(s)"
  134.     self._postInit()
  135.     if ignoreCase:
  136.       if name: name = string.lower(name)
  137.       value = spyceUtil.extractValue(self._postL, name)
  138.     else:
  139.       value = spyceUtil.extractValue(self._post, name)
  140.     return self.default(value, default)
  141.   def post1(self, name=None, default=None, ignoreCase=0):
  142.     "Return single POST parameter(s)"
  143.     self._postInit()
  144.     if ignoreCase:
  145.       if name: name = string.lower(name)
  146.       value = spyceUtil.extractValue(self._postL1, name)
  147.     else:
  148.       value = spyceUtil.extractValue(self._post1, name)
  149.     return self.default(value, default)
  150.   def file(self, name=None, ignoreCase=0):
  151.     "Return POSTed file(s)"
  152.     self._postInit()
  153.     if ignoreCase:
  154.       if name: name = string.lower(name)
  155.       return spyceUtil.extractValue(self._fileL, name)
  156.     else:
  157.       return spyceUtil.extractValue(self._file, name)
  158.   def env(self, name=None, default=None):
  159.     "Return other request (CGI) environment variables"
  160.     return self.default(self._api.getRequest().env(name), default)
  161.   def getHeader(self, type=None):
  162.     "Return browser HTTP header(s)"
  163.     return self._api.getRequest().getHeader(type)
  164.   def __getitem__(self, key):
  165.     if type(key) == type(0):
  166.       return self.getpost().keys()[key]
  167.     else:
  168.       v = self.get1(key)
  169.       if v!=None: return v
  170.       v = self.post1(key)
  171.       if v!=None: return v
  172.       v = self.file(key)
  173.       if v!=None: return v
  174.   def __repr__(self):
  175.     return ''
  176.   def __multidict(self, *args):
  177.     args = list(args)
  178.     args.reverse()
  179.     dict = {}
  180.     for d in args:
  181.       for k in d.keys():
  182.         dict[k] = d[k]
  183.     return dict
  184.   def getpost(self, name=None, default=None, ignoreCase=0):
  185.     "Return get() if not None, otherwise post() if not None, otherwise default"
  186.     if name==None:
  187.       self._getInit()
  188.       self._postInit()
  189.       return self.__multidict(self._get, self._post)
  190.     else:
  191.       value = self.get(name, None, ignoreCase)
  192.       if value==None: value = self.post(name, default, ignoreCase)
  193.       return value
  194.   def getpost1(self, name=None, default=None, ignoreCase=0):
  195.     "Return get1() if not None, otherwise post1() if not None, otherwise default"
  196.     if name==None:
  197.       self._getInit()
  198.       self._postInit()
  199.       return self.__multidict(self._get1, self._post1)
  200.     else:
  201.       value = self.get1(name, None, ignoreCase)
  202.       if value==None: value = self.post1(name, default, ignoreCase)
  203.       return value
  204.   def postget(self, name=None, default=None, ignoreCase=0):
  205.     "Return post() if not None, otherwise get() if not None, otherwise default"
  206.     if name==None:
  207.       self._getInit()
  208.       self._postInit()
  209.       return self.__multidict(self._post, self._get)
  210.     else:
  211.       value = self.post(name, None, ignoreCase)
  212.       if value==None: value = self.get(name, default, ignoreCase)
  213.       return value
  214.   def postget1(self, name=None, default=None, ignoreCase=0):
  215.     "Return post1() if not None, otherwise get1() if not None, otherwise default"
  216.     if name==None:
  217.       self._getInit()
  218.       self._postInit()
  219.       return self.__multidict(self._post1, self._get1)
  220.     else:
  221.       value = self.post1(name, None, ignoreCase)
  222.       if value==None: value = self.get1(name, default, ignoreCase)
  223.       return value
  224.  
  225.