def upload_file(self, google_folder_id, path, file_id=None):
        print("Uploading file %s" % path)
        (dt_taken, dt_modified) = self.get_taken_and_modified_time(path)
        file_name = os.path.basename(path)
        file_metadata = {
            'name': file_name,
            'parents': [google_folder_id],
            'createdTime': rfc3339.rfc3339(dt_taken),
            'modifiedTime': rfc3339.rfc3339(dt_modified)
        }

        if file_name.lower().endswith(".jpg"):
            mimetype = 'image/jpeg'
        else:
            mimetype = None
        media = MediaFileUpload(path,
                                mimetype=mimetype,
                                resumable=True)

        if (file_id is not None):
            self.service.files().delete(fileId=file_id).execute()

        file_node = self.service.files().create(body=file_metadata,
                                            media_body=media,
                                            fields='id, name, md5Checksum').execute()
        return file_node

	def _add_task(self,tasklist_id,title,notes=None, iscompleted=False, due=None, data_completed=None,deleted=False):
		params = {'tasklist':tasklist_id}
		url = 'https://www.googleapis.com/tasks/v1/lists/%s/tasks'%(tasklist_id)
		data = {
		'kind': 'tasks#task',
		'title':title,
		'deleted':deleted
		}
		if notes is not None:
			data['notes'] = notes
		if iscompleted:
			data['status'] = 'completed'
			if data_completed is not None:
				data['completed'] = rfc3339.rfc3339(data_completed)
			else:
				data['completed'] = rfc3339.rfc3339(datetime.datetime.now())
		else:
			data['status'] = 'needsAction'
			data['completed'] = None
		if due is not None:
			data['due'] = rfc3339.rfc3339(due)
		body = json.dumps(data).encode('utf-8')
		addheaders={'Content-type':'application/json'}
		response = self.__do_request('POST',url,addheaders=addheaders,params=params,data = body)
		if response and response.text:
			try:
				atask = Task(json.loads(response.text))
				atask['tasklist_id'] = tasklist_id
				return atask
			except Exception as e:
				print(e)
		return None

def getChannelVideos(channelId,dateToStartFrom,dateToGoBackTo,timeInterval):	
	if(dateToStartFrom < dateToGoBackTo):
		raise Exception('The date to start from cannot be before the date to go back to!')
	
	retVal = []
	
	# initialization
	startFrom = dateToStartFrom
	goBackTo = startFrom - timeInterval
	
	done = False
	
	while not done:
		if(goBackTo < dateToGoBackTo):
			goBackTo = dateToGoBackTo
		
		if(goBackTo == dateToGoBackTo):
			done = True
		
		goBackTo_rfc3339 = rfc3339(goBackTo,utc=True)
		startFrom_rfc3339 = rfc3339(startFrom,utc=True)
		
		videosPublishedInInterval = getChannelVideosPublishedInInterval(channelId,startFrom_rfc3339,goBackTo_rfc3339)
		retVal.extend(videosPublishedInInterval)
		
		if(not done):
			# we simply continue from where we are
			startFrom = goBackTo
			# calculate the next date to go back to based on the given interval
			nextDate = goBackTo - timeInterval
			goBackTo = nextDate
			
	return retVal	

def page2element(page, baseurl):
    root = ET.Element("entry")

    if page.author:
        author = ET.SubElement(root, "author")
        name = ET.SubElement(author,"name")
        name.text = page.author
    title = ET.SubElement(root, "title")
    title.text = page.title
    ET.SubElement(root, "link", attrib={"rel":"alternate", "type":"text/html",  "href":page.url})
    
    id = ET.SubElement(root, "id")
    #TODO generate id
    id.text = page.url

    summary = ET.SubElement(root, "summary")
    if page.description:
        summary.text = page.description
    else:
        logging.warn("Missing summary for element %s using title instead" %page.url)
        summary.text = page.title
    
    date = ET.SubElement(root, "updated")
    if page.date:
        #TODO check if right format 
        date.text = rfc3339(page.date)
    else:
        logging.warn("Missing date for element %s using now() instead" %page.url)
        date.text = rfc3339(datetime.datetime.now())
   
    if page.keywords:
        for keyword in page.keywords:
            ET.SubElement(root, "category", attrib={"scheme":baseurl, "term":keyword})

    return root

    def printEvents(self, calID='primary', orderBy='startTime',
                    singleEvents=True, timeMin=datetime.datetime(2010,11,10),
                    timeMax=datetime.datetime(2010,11,28)):
        page_token = None

        while True:
            events = self.service.events().list(
                        calendarId=calID,
                        orderBy=orderBy,
                        singleEvents=str(singleEvents),
                        timeMin=rfc3339(timeMin),
                        timeMax=rfc3339(timeMax),
                        pageToken=page_token).execute()

            for event in events['items']:
                if ('dateTime' in event['start']):
                    print event['summary'], ": From %s to %s" % ((parser.parse(event['start']['dateTime'])).strftime("%A, %d. %B %Y %I:%M%p"), (parser.parse(event['end']['dateTime'])).strftime("%A, %d. %B %Y %I:%M%p"))
                elif ('date' in event['start']):
                    print event['summary'], ": On %s" % parser.parse(event['start']['date']).strftime("%A, %d. %B %Y")
                else:
                    print event['summary'], "is a weird event..."

            page_token = events.get('nextPageToken')

            if not page_token:
                break

def insert_ajx(nombre,email,tlf,inicio,fin):
    rest="POST https://www.googleapis.com/calendar/v3/calendars/%s/events" % settings.google_calid
    from rfc3339 import rfc3339
    inicio=rfc3339(inicio)
    fin=rfc3339(fin)
    event = {
        'summary': nombre,
        'location': 'Caracas',
        'start': {
            'dateTime': inicio,
            'timeZone':"America/Caracas",
            },
        'end': {
            'dateTime': fin,
            'timeZone':"America/Caracas"
            },
        'attendees': [
            {
            'email': email,
            # Other attendee's data...
             },        
        ],
    }
    from oauth2client import gce
    import os
    import httplib2
    from apiclient.discovery import build    
    from oauth2client.client import flow_from_clientsecrets
    from oauth2client.file import Storage
    from oauth2client.tools import run

    jsonfile=os.path.join(request.folder,'static','client_secrets.json')
    storage = Storage('credentials.dat')
    credentials = storage.get()
    
    redirecturl='urn:ietf:wg:oauth:2.0:oob'
    flow = flow_from_clientsecrets(jsonfile,
                               scope='https://www.googleapis.com/auth/calendar',
                               redirect_uri=redirecturl)

    if credentials is None or credentials.invalid:
        credentials = run(flow, storage)
    http = httplib2.Http()
    http = credentials.authorize(http)
    
    service = build('calendar', 'v3',http=http)

    created_event = service.events().insert(calendarId=settings.google_calid, body=event).execute()
    #response.flash = created_event['id']
    script=''
    return dict(script=script)

    def getCalendarData(self, cur_time):
        start_of_day = datetime.date.today()
        end_of_day = datetime.date.today() + datetime.timedelta(days=1)

        # Today's events:
        events = []

        start_date = rfc3339(cur_time)
        end_date = rfc3339(end_of_day + datetime.timedelta(days=1))

        try:
            query = gdata.calendar.client.CalendarEventQuery(start_min=start_date,
                                                        start_max=end_date,
                                                        ctz="America/Vancouver",
                                                        orderby="starttime",
                                                        sortorder="ascending",
                                                        singleevents="true")
            feed = self.cal_client.GetCalendarEventFeed(q=query)

            for an_event in feed.entry:
                start = dateutil.parser.parse(an_event.when[0].start)
                end = dateutil.parser.parse(an_event.when[0].end)
                events.append((an_event.title.text, start, end))
        except:
            pass

        # Next Holidays
        holidays = []

        hol_uri = "https://www.google.com/calendar/feeds/en.canadian%23holiday%40group.v.calendar.google.com/private/full"
        start_date = rfc3339(start_of_day)
        try:
            query = gdata.calendar.client.CalendarEventQuery(
                                                        start_min=start_date,
                                                        ctz="America/Vancouver",
                                                        orderby="starttime",
                                                        singleevents="true",
                                                        sortorder="ascending",
                                                        max_results=4)
            feed = self.cal_client.GetCalendarEventFeed(q=query, uri=hol_uri)

            for an_event in feed.entry:
                start = dateutil.parser.parse(an_event.when[0].start)
                holidays.append((an_event.title.text, start.date()))
        except:
            pass

        return (events,holidays)

 def default(self, obj):
     if isinstance(obj, (datetime.date, datetime.datetime)):
         if __has_rfc3339__:
             return rfc3339(obj, utc=True, use_system_timezone=False)
         return obj.isoformat()
     else:
         return builtin_json.JSONEncoder.default(self, obj)

def template_render(template, _posts, metadata=None):
    posts = [{
        'key'     : str(post.key()),
        'title'   : unicode(post.title.encode("utf-8"), "utf-8"),
        'content' : unicode(Format.by_name(post.format)(post.content.encode("utf-8")), "utf-8"),
        'date'    : post.date,
        'updated' : rfc3339.rfc3339(post.date),
        'url'     : path.join(config.base_url, 'posts',  str(post.key()))
        } for post in _posts]
    variables = {
            'base_url'    : config.base_url,
            'blog_name'   : config.blog_name,
            'author'      : config.author,
            'email'       : config.email,
            'license'     : config.license,
            'plog_version': config.plog_version,
            'posts'       : posts,
            'updated'     : posts[0]['updated'] if len(posts) else 0
            }
    if metadata:
        variables['page'] = metadata["page"] + 1
        variables['pages'] = metadata["pages"]
        variables['prev_page'] = metadata["page"] - 1 if metadata["page"] > 0 else 0
        variables['next_page'] = metadata["page"] + 1
    variables['title'] = posts[0]['title'] if len(posts) == 1 else ""
    return pystache.render(template, variables)

	def set_completed(self,iscompleted = True):
		if iscompleted:
			self['status'] = 'completed'
			self['completed'] = rfc3339.rfc3339(datetime.datetime.now())
		else:
			self['status'] = 'needsAction'
			self['completed'] = None

def decodeBSONEntity(di, key):
    """
        Inspired by pymongo bson.json_util.default, but specially processing some value types:

        ObjectId --> hexvalue
        datetime --> rfc3339

        Also, while json_util.default creates a new dict in the form {$name: decodedvalue} we assign
        the decoded value, 'flattening' the value directly in the field.

        Fallback to other values using json_util.default, and flattening only those decoded entities
        that has only one key.
    """
    value = di[key]
    if isinstance(value, ObjectId):
        di[key] = str(value)
        return
    if isinstance(value, datetime):
        di[key] = rfc3339(value, utc=True, use_system_timezone=False)
        return
    try:
        decoded = json_util.default(di[key])
        if len(decoded.keys()) == 1:
            di[key] = decoded[decoded.keys()[0]]
        else:
            di[key] = decoded
    except:
        pass

 def _DateRangeQuery(self):
   print "Tim's Google Calendar Events for the next 7 days."
   print ''
   start_date = str(rfc3339.rfc3339(datetime.datetime.now()))
   end_date = str(datetime.date.today() + (datetime.timedelta(7)))
   query = gdata.calendar.service.CalendarEventQuery('default')
   query.start_min = start_date
   query.start_max = end_date
   query.orderby = 'starttime'
   query.sortorder = 'ascending' 
   feed = self.cal_client.CalendarQuery(query)
   for i, an_event in zip(xrange(len(feed.entry)), feed.entry):
     print '-- %s' % ( an_event.title.text,)
     try:
       for a_when in an_event.when:
           print '\tDate:\t\t%s' % (time.strftime('%A, %B %d',(time.strptime(a_when.start_time[:-10],"%Y-%m-%dT%H:%M:%S"))))
           print '\tTime:\t\t%s - %s' % (time.strftime('%I:%M %p',(time.strptime(a_when.start_time[:-10],"%Y-%m-%dT%H:%M:%S"))),
           time.strftime('%I:%M %p',(time.strptime(a_when.end_time[:-10],"%Y-%m-%dT%H:%M:%S"))))
       for a_where in an_event.where:
           if a_where.value_string != None:
               print '\tLocation:\t%s' % (a_where.value_string,)
               print ''
           else:
               print ''
     except:
     	for a_when in an_event.when:
     		print '\tDate:\t\t%s' % (time.strftime('%A, %B %d',(time.strptime(a_when.start_time,"%Y-%m-%d"))))
       for a_where in an_event.where:
           print '\tTime:\t\tAll day'
           if a_where.value_string != None:
               print '\tLocation:\t%s' % (a_where.value_string,)
               print ''
           else:
               print ''

def end_time():
    """
    Returns the RFC3339 time stamp for the end of today.
    """
    d = datetime.datetime.today()
    end = datetime.datetime(d.year, d.month, d.day, 23, 59, 59, 999999)
    return rfc3339(end)

 def atom(self):
     atom = ATOM_TEMPLATE.format(title=self.title,
                                 url=''.join(['http://', settings.HOSTNAME, self.link]),
                                 id=self.slug,
                                 summary=self.render_summary(),
                                 updated=rfc3339(self.updated, utc=True))
     return atom

def start_time():
    """
    Returns the RFC3339 time stamp for the start of today.
    """
    d = datetime.datetime.today()
    start = datetime.datetime(d.year, d.month, d.day, 0, 0, 0, 0)
    return rfc3339(start)

    def marshalled(self, context):
        userid = self.userid
        timestamp = rfc3339(datetime.datetime.now())
        secret = self.secret
        signature = sign(secret, timestamp+userid)
        auth = self.authfragment % locals()
        envelope = context.envelope

        #Set the right ns prefixes
        envelope.nsprefixes[ 'ns1' ] = envelope.nsprefixes[ 'ns0' ]
        envelope.clearPrefix( 'ns0' )

        #Add our auth to the header element
        header = envelope.getChild('Header')
        authns = Element( 'ns1:AuthenticationHeader' )
        authns.append( Element( 'mktowsUserId' ).setText(self.userid) )
        authns.append( Element( 'requestSignature' ).setText(signature) )
        authns.append( Element( 'requestTimestamp' ).setText(timestamp) )
        header.append( authns )

        #Set the proper body prefixes
        body = envelope.getChild( 'Body' )
        body.prefix = 'SOAP-ENV'
        body.children[0].prefix = 'ns1'

        if self.debug:
            with open("/tmp/envelope.txt","w") as f: f.write(envelope.str())

    def gen_atom(self):
        #pages, title, baseurl, feedurl, name, email=None, summary=None):
        feed = ET.Element("feed", nsmap={None: 'http://www.w3.org/2005/Atom'})
        #TODO set namespace

        f_title = ET.SubElement(feed, "title")
        f_title.text = self.title

        f_id = ET.SubElement(feed, "id")
        #TODO generate id
        f_id.text = self.feedurl
       
        f_updated = ET.SubElement(feed, "updated")
        f_updated.text = rfc3339(datetime.datetime.now())

        ET.SubElement(feed, "link", attrib={"href":self.feedurl, "rel":"self"})
        ET.SubElement(feed, "link", attrib={"href":self.baseurl})

        f_author = ET.SubElement(feed, "author")
        f_name = ET.SubElement(f_author, "name")
        f_name.text = self.name
        if self.email:
            f_email = ET.SubElement(f_author, "email")
            f_email.text = self.email

        if self.summary:
            f_summary = ET.SubElement(feed, "summary")
            f_summary.text = self.summary
        
        for page in self.pages:
            elem = page2element(page, self.baseurl)
            feed.append(elem)

        return feed

def CreateSourceElement(ee, feed):
    """Create an atom:source element in the provided entry element,
    based on the provided feed metadata.
    """
    if not feed: return
    
    root = SubElement(ee, "source")
    TextElement(root, "title", feed.get("title_detail"))
    if feed.has_key("links"):
        for link in feed.links:
            LinkElement(root, "link", link)
            
    TextElement(root, "subtitle", feed.get("subtitle_detail"))
    TextElement(root, "rights", feed.get("rights_detail"))
    SubElement(root, "generator").text = "feedarchive"
    SubElement(root, "updated").text = rfc3339(time.time())
    SubElementIf(root, "id", feed.get("id"))
    
    if feed.has_key("image"):
        SubElement(root, "icon").text = feed.image.href

    if feed.has_key("tags"):
        for tag in feed.tags:
            te = SubElement(root, "category")
            if tag.get("term"): te.attrib["term"] = tag.term
            if tag.get("scheme"): te.attrib["scheme"] = tag.scheme
            if tag.get("label"): te.attrib["label"] = tag.label

    PersonElement(root, "author", feed.get("author_detail"))

 def json(self, include_issues=True, serialize=True, host="chroniclingamerica.loc.gov"):
     b = {}
     b['name'] = self.name
     b['ingested'] = rfc3339(self.created)
     b['page_count'] = self.page_count
     b['lccns'] = self.lccns()
     b['awardee'] = {
         "name": self.awardee.name,
         "url": "http://" + host + self.awardee.json_url
     }
     b['url'] = "http://" + host + self.json_url
     if include_issues:
         b['issues'] = []
         for issue in self.issues.all():
             i = {
                 "title": {
                     "name": issue.title.display_name,
                     "url": "http://" + host + issue.title.json_url,
                 },
                 "date_issued": strftime(issue.date_issued, "%Y-%m-%d"),
                 "url": "http://" + host + issue.json_url
             }
             b['issues'].append(i)
     if serialize:
         return json.dumps(b)
     else:
         return b

def date_to_atom_friendly(date):
    """
    Converts dates from our default representation to an Atom-friendly RFC-3339 format.
    Uses a third party library released under a free license (see rfc3339.py for details).
    Uses code from http://stackoverflow.com/questions/9637838/convert-string-date-to-timestamp-in-python
    """
    parsed = time.mktime(datetime.datetime.strptime(date, "%Y-%m-%d %H:%M:%S").timetuple())
    return rfc3339(parsed)