X-Git-Url: https://git.ucc.asn.au/?p=frenchie%2Ficalparse.git;a=blobdiff_plain;f=icalparse.py;h=95d52089ba166c7ae1fb88dd24454af2c3ade12c;hp=f41c4a1c6208ee38f3ab53f7c7f37695a9dbbff1;hb=HEAD;hpb=c5df217cb78f340a12a0ba9145af79faee186772

diff --git a/icalparse.py b/icalparse.py
index f41c4a1..59e409b 100755
--- a/icalparse.py
+++ b/icalparse.py
@@ -1,6 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 #
-# Copyright (c) 2010 James French <frenchie@frenchie.id.au>
+# Copyright (c) 2013 James French <frenchie@frenchie.id.au>
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -20,63 +20,168 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-import sys
-import urlparse
-import os
+import sys, os
+from urllib import (request, error, parse)
+import vobject
+from cgi import parse_header
 
-class InvalidICS(Exception): pass
-class notJoined(Exception): pass
+def getContent(url='',stdin=False):
+	'''Generic content retriever, DO NOT use this function in a CGI script as
+	it can read from the local disk (which you probably don't want it to).
+	'''
+
+	encoding = '' # If we don't populate this, the script will assume UTF-8
+
+	# Special case, if this is a HTTP url, return the data from it using
+	# the HTTP functions which attempt to play a bit nicer.
+	parsedURL = parse.urlparse(url)
+	if 'http' in parsedURL[0]: return getHTTPContent(url)
+
+	if stdin:
+		content = sys.stdin.read()
+		return (content, encoding)
 
-def lineJoiner(oldcal):
-	'''Takes a string containing a calendar and returns an array of its lines'''
+	if not parsedURL[0]: url = 'file://' + os.path.abspath(url)
 
-	if list(oldcal) == oldcal:
-		oldcal = '\r\n'.join(oldcal)
+	# If we've survived, use python's generic URL opening library to handle it
+	try:
+		res = request.urlopen(url)
+		content = res.read()
+		ct = res.info().getplist()
+		res.close()
+	except (error.URLError, OSError) as e:
+		sys.stderr.write('%s\n'%e)
+		sys.exit(1)
 
-	oldcal.replace('\r\n ', '')
-	return oldcal.split('\r\n')
+	for param in ct:
+		if 'charset' in param:
+			encoding = param.split('=')[1]
+			break
 
+	return (content, encoding)
 
-def lineFolder(oldcal, length=75):
-	'''Folds content lines to a specified length, returns a list'''
 
-	if length > 75:
-		sys.stderr.write('WARN: lines > 75 octets are not RFC compliant\n')
+def getHTTPContent(url=''):
+	'''This function attempts to play nice when retrieving content from HTTP
+	services. It's what you should use in a CGI script.'''
+
+	try:
+		import httplib2
+	except ImportError:
+		pass
 
-	cal = []
-	sl = length - 1
+	if not url: return ('','')
 
-	for line in oldcal:
-		# Line fits inside length, do nothing
-		if len(line.rstrip()) <= length:
-			cal.append(line)
+	if not 'http' in parse.urlparse(url)[0]: return ('','')
+
+	if 'httplib2' in sys.modules:
+		try: h = httplib2.Http()
+		except OSError: h = httplib2.Http()
+	else: h = False
+
+	if h:
+		try:
+			req = h.request(url)
+		except ValueError as e:
+			sys.stderr.write('%s\n'%e)
+			sys.exit(1)
+
+		resp, content = req
+		if 'content-type' in resp:
+			ct = 'Content-Type: %s'%req[0]['content-type']
+			ct = parse_header(ct)
+			if 'charset' in ct[1]: encoding = ct[1]['charset']
+			else: encoding = ''
 		else:
-			brokenline = [line[0:length] + '\r\n']
-			ll = length
-			while ll < len(line.rstrip('\r\n')) + 1:
-				brokenline.append(' ' + line[ll:sl+ll].rstrip('\r\n') + '\r\n')
-				ll += sl
-			cal += brokenline
+			ct = ''
+			encoding = ''
+
+	else:
+		try:
+			req = request.urlopen(url)
+		except error.URLError as e:
+			sys.stderr.write('%s\n'%e)
+			sys.exit(1)
+
+		content = req.read()
+		ct = req.info().getplist()
+		for param in ct:
+			if 'charset' in param:
+				encoding = param.split('=')[1]
+				break
+
+	return (content, encoding)
+
+
+def generateRules(ruleConfig):
+	'''Attempts to load a series of rules into a list'''
+	try:
+		import parserrules
+	except ImportError:
+		return []
+
+	for conf in ruleConfig:
+		parserrules.ruleConfig[conf] = ruleConfig[conf]
+
+	rules = [getattr(parserrules, rule) for rule in dir(parserrules) if callable(getattr(parserrules, rule))]
+
+	return rules
+
+
+def applyRules(cal, rules=[], verbose=False):
+	'Runs a series of rules on the lines in ical and mangles its output'
+
+	for rule in rules:
+		cal = rule(cal)
 
 	return cal
 
-def getContent(url='',stdin=False):
-	pass
 
+def writeOutput(cal, outfile=''):
+	'''Takes a list of lines and outputs to the specified file'''
+
+	if not cal:
+		sys.stderr.write('Refusing to write out an empty file')
+		sys.exit(0)
+
+	if not outfile:
+		out = sys.stdout
+	else:
+		try:
+			out = open(outfile, 'w')
+		except (IOError, OSError) as e:
+			sys.stderr.write('%s\n'%e)
+			sys.exit(1)
+
+	cal.serialize(out)
+
+	if not out == sys.stdout:
+		out.close()
+
+
+def runLocal():
+	'''Main run function if this script is called locally'''
 
-if __name__ == '__main__':
 	from optparse import OptionParser
-	# If the user passed us a 'stdin' argument, we'll go with that,
-	# otherwise we'll try for a url opener
 
 	parser = OptionParser('usage: %prog [options] url')
 	parser.add_option('-s', '--stdin', action='store_true', dest='stdin',
 		default=False, help='Take a calendar from standard input')
+	parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
+		default=False, help='Be verbose when rules are being applied')
 	parser.add_option('-o', '--output', dest='outfile', default='',
 		help='Specify output file (defaults to standard output)')
+	parser.add_option('-m','--encoding', dest='encoding', default='',
+		help='Specify a different character encoding'
+		'(ignored if the remote server also specifies one)')
+	parser.add_option('-t','--timezone', dest='timezone', default='',
+		help='Specify a timezone to use if the remote calendar doesn\'t set it properly')
 
 	(options, args) = parser.parse_args()
+	ruleConfig["defaultTZ"] = options.timezone or ruleConfig["defaultTZ"]
 
+	# If the user passed us a 'stdin' argument, we'll go with that,
+	# otherwise we'll try for a url opener
 	if not args and not options.stdin:
 		parser.print_usage()
 		sys.exit(0)
@@ -85,43 +190,77 @@ if __name__ == '__main__':
 	else:
 		url = ''
 
-	# Work out what url parsers we're going to need based on what the user
-	# gave us on the command line - we do like files after all
-	parsedURL = urlparse.urlparse(url)
-	http = 'http' in parsedURL[0]
+	(content, encoding) = getContent(url, options.stdin)
+	encoding = encoding or options.encoding or 'utf-8'
 
-	if not parsedURL[0]: u = False
-	else: u = True
+	cal = vobject.readOne(str(content, encoding))
+	cal = applyRules(cal, generateRules(ruleConfig), options.verbose)
 
-	if not options.stdin and http:
-		try:
-			import httplib2
-		except ImportError:
-			import urllib2
-
-	# Try and play nice with HTTP servers unless something goes wrong. We don't
-	# really care about this cache (A lot of ics files seem to be generated with
-	# php which hates caching with a passion).
-	h = False
-	if 'httplib2' in sys.modules:
-		try: h = httplib2.Http('.httplib2-cache')
-		except OSError: h = httplib2.Http()
+	writeOutput(cal, options.outfile)
+
+
+def exitQuiet(exitstate=0):
+	'''When called as a CGI script, exit quietly if theres any errors'''
+	print('Content-Type: text/html\n')
+	sys.exit(exitstate)
 
-	# Load urllib2 if this is not a stdin
-	if not options.stdin and (not http or not 'httplib2' in sys.modules):
-		import urllib2
 
+def runCGI():
+	'''Main run function if this script is called as a CGI script
+	to process facebook ical files'''
+	import cgi
+	import re
+	import cgitb; cgitb.enable()
+
+	ruleConfig["facebook"] = True
+
+	form = cgi.FieldStorage()
+	if "uid" not in form or "key" not in form:
+		print('Content-Type: text/calendar\n')
+		sys.exit(0)
 	try:
-		content = u and (h and h.request(url)[1] or urllib2.urlopen(url).read())
-	except (ValueError, urllib2.URLError), e:
-		sys.stderr.write('%s\n'%e)
-		sys.exit(1)
+		# UID should be numeric, if it's not we have someone playing games
+		uid = int(form['uid'].value)
+	except:
+		exitQuiet()
 
-	if not u and not options.stdin:
-		try: content = open(os.path.abspath(url),'r').read()
-		except (IOError, OSError), e:
-			sys.stderr.write('%s\n'%e)
-			sys.exit(1)
+	# The user's key will be a 16 character string
+	key = form['key'].value
+	re.search('[&?]+', key) and exitQuiet()
+	len(key) == 16 or exitQuiet()
 
-	if options.stdin:
-		content = sys.stdin.read()
+	# Historically facebook has been notoriously bad at setting timzeones
+	# in their stuff so this should be a user setting. If it is set in
+	# their calendar it'll  be used otherwise if the user feeds crap or
+	# nothing just assume they want Australia/Perth
+	tz = ""
+	if "tz" in form:
+		from pytz import timezone
+		try:
+			timezone(form['tz'].value)
+			tz = form['tz'].value
+		except: pass
+
+	ruleConfig["defaultTZ"] = tz or ruleConfig["defaultTZ"]
+
+	# Okay, we're happy that the input is sane, lets serve up some data
+	url = 'https://www.facebook.com/events/ical/upcoming/?uid=%s&key=%s'%(uid,key)
+	(content, encoding) = getHTTPContent(url)
+
+	cal = vobject.readOne(str(content, encoding))
+	cal = applyRules(cal, generateRules(ruleConfig), False)
+
+	print(('Content-Type: text/calendar; charset=%s\n'%encoding))
+	writeOutput(cal)
+
+
+if __name__ == '__main__':
+	# Ensure the rules process using the desired timezone
+	ruleConfig = {}
+	ruleConfig["defaultTZ"] = 'Australia/Perth'
+
+	# Detect if this script has been called by CGI and proceed accordingly
+	if 'REQUEST_METHOD' in os.environ:
+		runCGI()
+	else:
+		runLocal()