attachment:passlog-1.0.py of GuestPass.py

   1 """
   2     MoinMoin - PassLog class Version 1.0, 4.01.2013
   3     
   4     This is used for accessing the wiki pass-log.
   5     
   6     To be installed wiki/data/plugin/logfile along with the 
   7     standard __init__.py for plugin modules.
   8 
   9     @copyright: 2013 Ian Riley <ian.riley@internode.on.net>
  10     
  11     Based on: editlog
  12     
  13     @copyright: 2006 MoinMoin:ThomasWaldmann
  14     @license: GNU GPL, see COPYING for details.
  15 """
  16 
  17 import time
  18 from MoinMoin import log
  19 logging = log.getLogger(__name__)
  20 
  21 from MoinMoin.logfile import LogFile
  22 from MoinMoin import wikiutil, config
  23 from MoinMoin.user import User
  24 from MoinMoin.Page import Page
  25 
  26 def makeCode(length=16):
  27     from string import digits, ascii_letters
  28     from random import choice
  29     return ''.join([choice(digits+ascii_letters) for i in range(length)])
  30 
  31 class PassLogLine:
  32     """
  33     Given the following attributes
  34 
  35     pass_time_usecs
  36     pagename
  37     action
  38     userid
  39     username
  40     addr
  41     hostname
  42     passcode
  43     lifespan (days)
  44     """
  45     def __init__(self, usercache):
  46         self._usercache = usercache
  47         
  48     def __repr__(self, user = None):
  49         return 'Dated: % s Page: %s Pass: %s Expires: %s' % (
  50                                                 self.dated(user),
  51                                                 self.pagename,
  52                                                 self.passcode,
  53                                                 self.expiry_date(user))
  54 
  55     def expiry_usecs(self):
  56         return (self.pass_time_usecs + 
  57                 wikiutil.timestamp2version(int(self.lifespan) * 86400))
  58                
  59     def expiry_days(self):
  60         if self.is_current():
  61             d = (self.expiry_usecs() - wikiutil.timestamp2version(time.time()))
  62             days = wikiutil.version2timestamp(d) / 86400
  63             if days <= 1.0:
  64                 result  = '<1 day'
  65             elif days < 1.5:
  66                 result = '1 day'
  67             else:
  68                 result = '%s days' % int(days + 0.5)
  69         else:
  70             result = ''
  71         return result
  72    
  73     def _dated(self, time_usecs, user = None):
  74         t = wikiutil.version2timestamp(time_usecs)
  75         if user:
  76             return user.getFormattedDateTime(t)
  77         else:
  78             return time.strftime("%Y-%m-%d %H:%M:%S GMT", time.gmtime(t))
  79             
  80     def expiry_date(self, user = None):
  81         return self._dated(self.expiry_usecs(), user)
  82 
  83     def dated(self, user = None):
  84         return self._dated(self.pass_time_usecs, user)
  85             
  86     def link_to(self, request):
  87         page = Page(request, self.pagename)
  88         querystr = 'action=GuestPass&pass=%s' % self.passcode
  89         return page.link_to(request, querystr=querystr)
  90         
  91     def is_current(self):
  92         return wikiutil.timestamp2version(time.time()) < self.expiry_usecs()
  93         
  94     def is_passable(self, request):
  95         page = Page(request, self.pagename)
  96         user = User(request, self.userid) # the user who created the pass
  97         # check pagename, even if used as filter 
  98         return (page.exists() and 
  99                 (self.pagename == request.page.page_name) and 
 100                 user.may.read(self.pagename))
 101     
 102     def is_read_allowed(self, request):
 103         return self.is_current() and self.is_passable(request)
 104 
 105 class PassLog(LogFile):
 106     """ Used for accessing wiki pass-log.
 107     """
 108     def __init__(self, request, filename=None, buffer_size=4096, **kw):
 109         if filename is None:
 110             rootpagename = kw.get('rootpagename', None)
 111             if rootpagename:
 112                 filename = Page(request, rootpagename).getPagePath('pass-log', isfile=1)
 113             else:
 114                 filename = request.rootpage.getPagePath('pass-log', isfile=1)
 115         if filename:
 116             LogFile.__init__(self, filename, buffer_size)
 117   	    
 118   	    self._NUM_FIELDS = 9
 119         self._usercache = {}
 120         
 121     def add(self, request, pass_time_usecs, action, pagename, username, 
 122             host=None, passcode = '', lifespan=30):
 123         """ Generate (and add) a line to the pass-log.
 124 
 125         If `host` is None, it's read from request vars.
 126         """
 127         if request.cfg.log_remote_addr or self.force_ip:
 128             if host is None:
 129                 host = request.remote_addr or ''
 130 
 131             if request.cfg.log_reverse_dns_lookups:
 132                 import socket
 133                 try:
 134                     hostname = socket.gethostbyaddr(host)[0]
 135                     hostname = unicode(hostname, config.charset)
 136                 except (socket.error, UnicodeError):
 137                     hostname = host
 138             else:
 139                 hostname = host
 140         else:
 141             host = ''
 142             hostname = ''
 143 
 144         userid = request.user.valid and request.user.id or ''
 145             
 146         if not passcode:
 147             passcode = makeCode()
 148 
 149         line = u"\t".join((str(long(pass_time_usecs)),
 150                            wikiutil.quoteWikinameFS(pagename),
 151                            action,
 152                            userid,
 153                            username,
 154                            host,
 155                            hostname,
 156                            passcode,
 157                            str(lifespan)
 158                            )) + "\n"
 159         self._add(line)
 160         return self.parser(line)
 161 
 162     def parser(self, line):
 163         """ Parse pass-log line into fields """
 164         fields = line.strip().split('\t')
 165         # Pad empty fields
 166         missing = self._NUM_FIELDS - len(fields)
 167         if missing:
 168             fields.extend([''] * missing)
 169         result = PassLogLine(self._usercache)
 170         (result.pass_time_usecs,
 171          result.pagename, result.action,
 172          result.userid, result.username,
 173          result.addr, result.hostname,
 174          result.passcode, result.lifespan ) = fields[:self._NUM_FIELDS]
 175         if not result.hostname:
 176             result.hostname = result.addr
 177         result.pagename = wikiutil.unquoteWikiname(result.pagename.encode('ascii'))
 178         result.pass_time_usecs = long(result.pass_time_usecs or '0')
 179         return result
 180 
 181     def set_filter(self, **kw):
 182         """ optionally filter for specific pagenames, userids, passcodes"""
 183         expr = "1"
 184         for field in ['pagename', 'userid', 'passcode']:
 185             if field in kw and kw[field]: # treat empty as non-existant
 186                 expr = "%s and x.%s == %s" % (expr, field, repr(kw[field]))
 187 
 188         if 'pass_time_usecs' in kw:
 189             expr = "%s and long(x.ed_time_usecs) == %s" % (expr, long(kw['pass_time_usecs']))
 190 
 191         self.filter = eval("lambda x: " + expr)