import cgi,string,urllib,random,time,types,md5,base64,re,socket,os
import xml.sax.saxutils as saxutils
from datetime import date, timedelta

def sendmail(mail):
 handle=os.popen("/usr/lib/sendmail -t","w")
 handle.write(mail)
 assert handle.close() is None
 return

def Sleep(t):
 time.sleep(t)
 return

def B64Encode(data):
  return base64.encodestring(data)

def B64Decode(data):
  return base64.decodestring(data)

def Md5HexDigest(data):
    return md5.new(data).hexdigest()

def UrlRead(url, data = None, timeout=20):
    oldtimeout=socket.getdefaulttimeout()
    socket.setdefaulttimeout(timeout)
    try:
     file = urllib.urlopen(url, data)
     result = file.read()
     file.close()
    finally:
     socket.setdefaulttimeout(oldtimeout)
    return result

def Update_Data(webfile,data,ctype):
  return webfile.update_data(data,content_type=ctype)

def GmTime(t):
  return time.gmtime(t)

def LocalTime(t):
  return time.localtime(t)

def LocalTime1(t):
  t=time.localtime(t)
  return [t[0],t[1],t[2],t[3],t[4],t[5],t[6],t[7],t[8]]

def MkTime(t):
  return time.mktime(t)

def StrpTime(s,f):
  return time.strptime(s,f)

def Time():
  return time.time()

def StrfTime(f,t):
  return time.strftime(f,t)

def CgiEscape(s):
  """Wrapper um cgi.escape
  """
  return cgi.escape(str(s),1)

def XMLEscape(s):
    # Vorsicht Hack: XML Charrefs werden unescaped
    s = str(s)
    ret = u''
    pos = 0
    while True:
        p = s.find('&#', pos)
        if p >= 0:
            ret += unicode(s[pos:p], 'latin-1')
            pos = p
            p = s.find(';', pos)
            if p < 0:
                ret += unicode(s[pos:], 'latin-1')
                break
            n = s[pos + 2: p]
            if n.isdigit():
                try:
                    n = int(n)
                    if 0 <= n <= 0xFFFF: # TODO: Surrogat-Paare
                        ret += unichr(n)
                        pos = p + 1
                        continue
                except ValueError:
                    pass
            ret += u'&#'
            pos += 2
        else:
            ret += unicode(s[pos:], 'latin-1')
            break

    text = saxutils.escape(ret)
    return text.encode('latin-1','xmlcharrefreplace')

def QuotePlus(s):
  """Wrapper um urllib.quote_plus
  """
  return string.replace(urllib.quote_plus(str(s)),"+","%20")

def UnquotePlus(s):
  """Wrapper um urllib.unquote_plus
  """
  return urllib.unquote_plus(s)

def PKDateiname(pk):
 """Konvertiert Primaerschluesselwert in Verzeichnisnamen
 """
 return string.replace(QuotePlus(pk),"%","")

def HoleObjekt(self,zielverzeichnis):
  """Gibt das Objekt mit dem entsprechenden Pfad zurueck
  """
  verzeichnis=self.getPhysicalRoot()
  if not zielverzeichnis: return None
  zielverzeichnis=string.split(zielverzeichnis,"/")
  for v in zielverzeichnis:
   if v!="":
    if v not in verzeichnis.objectIds(): return None
    verzeichnis=getattr(verzeichnis,v)
  return verzeichnis

def GeheZuObjekt(o,p):
  """Von einem Objekt zu einem anderen 'hinabsteigen'
  """
  for s in p:
   if s not in o.objectIds(): return None
   o=getattr(o,s)
  return o

def HoleZufallszahl(a,b,c):
 return random.randrange(a,b,c)

def VolleUrl(self):
 path = string.split(self.REQUEST.PATH_INFO,"/")

 if path[1]=="SSL":
  url="https://"+self.ServerName
  if path[2]!=self.ServerName: url=url+"/"+path[2]
  for p in path[3:]: url=url+"/"+self.QuotePlus(p)
 else:
  url = "http://"+self.ServerName
  if path[1]!=self.ServerName: url=url+"/"+path[1]
  for p in path[2:]: url=url+"/"+self.QuotePlus(p)

 query_string = self.REQUEST.QUERY_STRING
 if query_string:
   url += "?"+query_string
 return url

def Base(self):
 path = string.split(self.REQUEST.PATH_INFO,"/")

 if path[1]=="SSL":
  url="https://"+self.ServerName+"/"
  if path[2]!=self.ServerName: url=url+path[2]+"/"
  for p in path[3:len(path)-1]: url=url+self.QuotePlus(p)+"/"
 else:
  url = "http://"+self.ServerName+"/"
  if path[1]!=self.ServerName: url=url+path[1]+"/"
  for p in path[2:len(path)-1]: url=url+self.QuotePlus(p)+"/"

 return url

def SpeichereFormularDaten(self,formular,neuAnlegen=0):
 request = self.REQUEST
 form = request.form
 session = request.SESSION
 session["formular"]=formular
 if not neuAnlegen and session.has_key(formular):
  a=session[formular]
 else:
  a={}
 for k in form.keys():
  v = form[k]
  if not k.startswith('__'): a[k] = v
 a["fehler"]=""
 session[formular]=a
 return

def Formularwert(self,name):
 request = self.REQUEST
 session = request.SESSION
 formularArt=""
 if session.has_key("formular"): formularArt=session["formular"]
 if session.has_key(formularArt):
   form = session[formularArt]
   if form.has_key(name):
     return form[name]
 return ""

def re_find_all(pattern, s, opt=''):
    options = 0
    for o in opt:
        if o == 'I':
            options |= re.I
        else:
            assert False
    rexp = re.compile(pattern, options)
    ret = []
    p = 0
    while s:
        m = rexp.search(s)
        if m is None:
            break
        ret.append((m.groupdict(), p + m.start(), p + m.end()))
        s = s[m.end(): ]
        p += m.end()
    return tuple(ret)

# Datumsberechnungen fuer einen Monat
# Gibt die Anzahl der Tage des Monats, den Wochentag (0-6) des ersten Tages und
# den Wochentag des uebergebenen Tags zurueck.
def Monat(jahr, monat, tag):
    dt = date(jahr, monat, tag)
    et = dt.replace(day=1)
    lt = (et + timedelta(days=31)).replace(day=1)
    tage = (lt - et).days
    dtwt = dt.weekday()
    etwt = et.weekday()
    return tage, etwt, dtwt