c2s.py

# -*- coding: utf-8 -*-

try:
    from xml.etree import ElementTree
except ImportError:
    from elementtree import elementtree

import atom
import atom.data
import atom.service

import calendar

from datetime import date, timedelta
from dateutil import parser

import gdata.acl.data
import gdata.calendar.data
import gdata.calendar.service
import gdata.spreadsheet
import gdata.spreadsheet.service
import gdata.service
import re
import time

class NotFoundObject():
    def __init__(self, expression, message):
        self.expression = expression
        self.message    = message

class Gcal2Gdoc(object):
    def __init__(self, email, password, date):
        self._date     = parser.parse(date)
        self._password = password
        self._email    = email

        self._calendar   = gdata.calendar.service.CalendarService()
        self._spreadsheet = gdata.spreadsheet.service.SpreadsheetsService()

    def login(self):
        self.calendar_login()
        self.spreadsheet_login()

    def calendar_login(self):
        self._calendar.email = self._email
        self._calendar.password = self._password
        self._calendar.source = 'gdoc2gcal'
        self._calendar.ssl = True
        self._calendar.ProgrammaticLogin()

    def spreadsheet_login(self):
        self._spreadsheet.email = self._email
        self._spreadsheet.password = self._password
        self._spreadsheet.source = 'gdoc2gcal'
        self._spreadsheet.ssl = True
        self._spreadsheet.ProgrammaticLogin()

    def get_spreadsheet_key(self, keyword):
        feed = self._spreadsheet.GetSpreadsheetsFeed()
        entry = self.__find_entry(feed, keyword)

        key = entry.id.text.rsplit('/', 1)[1]
        self._spreadsheet_key = key

    def get_worksheet_id(self, keyword):
        feed = self._spreadsheet.GetWorksheetsFeed( self._spreadsheet_key )

        entry = self.__find_entry(feed, keyword)
        key = entry.id.text.split('/')[-1]
        self._worksheet_id = key

    def __find_entry(self, feed, keyword):
        regexp = re.compile(keyword)

        for entry in feed.entry:
            if regexp.match(entry.title.text):
                return entry

        raise NotFoundObject('Feed', "%s is not found" % keyword)

    def find_new_row_number_from_worksheet(self):
        feed = self.get_worksheet()

        for i, entry in enumerate(feed.entry):
            if not entry.custom[u'日付'].text:
                return i

    def get_worksheet(self):
        return self._spreadsheet.GetListFeed(self._spreadsheet_key, self._worksheet_id)

    def insert_new_row_into_worksheet(self, params):
        feed = self.get_worksheet()
        num  = self.find_new_row_number_from_worksheet()
        entry = self._spreadsheet.InsertRow(
            {
                u'日付': params['date'],
                u'開始時': str(params['start_hour']),
                u'開始分': str(params['start_minute']),
                u'終了時': str(params['end_hour']),
                u'終了分': str(params['end_minute']),
                u'メモ': params['my_note']
                },
            self._spreadsheet_key, self._worksheet_id)

    def to_spreadsheet_from_calendar(self):
        query = self.__create_calendar_event_query()
        feed = self._calendar.CalendarQuery(query)

        for i, an_event in zip(xrange(len(feed.entry)), feed.entry):
            row = {}
            row['my_note'] = an_event.title.text

            if an_event.when[0].start_time:
                row = self.__set_time_to_dict(an_event.when[0].start_time, row, 'start_')
                time = parser.parse( an_event.when[0].start_time )
                row['date'] = time.strftime('%Y-%m-%d')

            if an_event.when[0].end_time:
                row = self.__set_time_to_dict(an_event.when[0].end_time, row, 'end_')

            print "[%03d] %s" % (i, row['my_note'])
            self.insert_new_row_into_worksheet(row)

    def __set_time_to_dict(self, time_str, dict, prefix):
        time = parser.parse( time_str )
        dict[prefix + 'hour']   = time.hour
        dict[prefix + 'minute'] = time.minute

        return dict

    def __create_calendar_event_query(self):
        end_date = date(self._date.year, self._date.month, self.__get_end_of_month() )
        query = gdata.calendar.service.CalendarEventQuery('default', 'private', 'full')
        query.start_min = self._date.strftime('%Y-%m-%dT00:00:00')
        query.start_max = end_date.strftime('%Y-%m-%dT00:00:00')
        query.orderby   = 'starttime'
        query.sortorder = 'ascending'
        query.max_results = 200

        return query

    def __get_end_of_month(self):
        return calendar.monthrange(self._date.year, self._date.month)[1]

if __name__ == '__main__':
    # mail = raw_input("email: ")
    # password = raw_input("password: ")
    # name = raw_input("name: ")
    # date = raw_input("date(YYYY-MM-DD): ")
    # c2g = Gcal2Gdoc(mail, password, name, date)
    c2g = Gcal2Gdoc('mail address', 'password', '2011-10-01')

    c2g.login()

    try:
        c2g.get_spreadsheet_key('Timesheets')
    except NotFoundObject, e:
        print e.message

    try:
        c2g.get_worksheet_id('Timesheet')
    except NotFoundObject, e:
        print e.message

    c2g.to_spreadsheet_from_calendar()