359 lines
14 KiB
Python
359 lines
14 KiB
Python
# -*- coding: utf-8 -*-
|
|
##############################################################################
|
|
#
|
|
# OpenERP, Open Source Management Solution
|
|
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
##############################################################################
|
|
|
|
import re
|
|
import urllib
|
|
import dateutil
|
|
import pytz
|
|
from dateutil import *
|
|
from pytz import timezone
|
|
from datetime import datetime
|
|
import time
|
|
from osv import *
|
|
from tools.translate import _
|
|
|
|
try:
|
|
import gdata
|
|
import gdata.contacts.service
|
|
import gdata.calendar.service
|
|
import gdata.contacts
|
|
import gdata.calendar
|
|
except ImportError:
|
|
raise osv.except_osv(_('Google Contacts Import Error!'), _('Please install gdata-python-client from http://code.google.com/p/gdata-python-client/downloads/list'))
|
|
from import_base.import_framework import *
|
|
from import_base.mapper import *
|
|
|
|
class google_import(import_framework):
|
|
|
|
gd_client = False
|
|
calendars = False
|
|
contact = False
|
|
DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
|
|
TABLE_CONTACT = 'Contact'
|
|
TABLE_ADDRESS ='Address'
|
|
TABLE_EVENT = 'Events'
|
|
|
|
def initialize(self):
|
|
google = self.obj.pool.get('google.login')
|
|
self.gd_client = google.google_login(self.context.get('user'),
|
|
self.context.get('password'),
|
|
self.context.get('instance'))
|
|
|
|
if self.context.get('instance') and self.context.get('instance') == 'contact':
|
|
self.contact = self.context.get('contact')
|
|
if self.context.get('instance') and self.context.get('instance') == 'calendar':
|
|
self.calendars = self.context.get('calendars')
|
|
|
|
def get_mapping(self):
|
|
return {
|
|
self.TABLE_EVENT: self.get_event_mapping(),
|
|
self.TABLE_CONTACT: self.get_contact_mapping(),
|
|
self.TABLE_ADDRESS: self.get_address_mapping(),
|
|
}
|
|
|
|
def get_data(self, table):
|
|
data_fetching_function = {
|
|
self.TABLE_CONTACT: self.get_contact,
|
|
self.TABLE_ADDRESS: self.get_contact,
|
|
self.TABLE_EVENT: self.get_events,
|
|
}
|
|
|
|
return data_fetching_function.get(table)()
|
|
|
|
|
|
def _get_tinydates(self, stime, etime, au_tz):
|
|
stime = dateutil.parser.parse(stime)
|
|
etime = dateutil.parser.parse(etime)
|
|
try:
|
|
au_dt = au_tz.normalize(stime.replace(tzinfo=pytz.utc).astimezone(au_tz))
|
|
timestring = datetime.datetime(*au_dt.timetuple()[:6]).strftime('%Y-%m-%d %H:%M:%S')
|
|
au_dt = au_tz.normalize(etime.replace(tzinfo=pytz.utc).astimezone(au_tz))
|
|
timestring_end = datetime.datetime(*au_dt.timetuple()[:6]).strftime('%Y-%m-%d %H:%M:%S')
|
|
except:
|
|
timestring = datetime.datetime(*stime.timetuple()[:6]).strftime('%Y-%m-%d %H:%M:%S')
|
|
timestring_end = datetime.datetime(*etime.timetuple()[:6]).strftime('%Y-%m-%d %H:%M:%S')
|
|
return (timestring, timestring_end)
|
|
|
|
def _get_rules(self, datas):
|
|
new_val = {}
|
|
if datas['FREQ'] == 'WEEKLY' and datas.get('BYDAY'):
|
|
for day in datas['BYDAY'].split(','):
|
|
new_val[day.lower()] = True
|
|
datas.pop('BYDAY')
|
|
|
|
if datas.get('UNTIL'):
|
|
until = parser.parse(''.join((re.compile('\d')).findall(datas.get('UNTIL'))))
|
|
new_val['end_date'] = until.strftime('%Y-%m-%d')
|
|
new_val['end_type'] = 'end_date'
|
|
datas.pop('UNTIL')
|
|
|
|
if datas.get('COUNT'):
|
|
new_val['count'] = datas.get('COUNT')
|
|
new_val['end_type'] = 'count'
|
|
datas.pop('COUNT')
|
|
|
|
if datas.get('INTERVAL'):
|
|
new_val['interval'] = datas.get('INTERVAL')
|
|
else:
|
|
new_val['interval'] = 1
|
|
|
|
if datas.get('BYMONTHDAY'):
|
|
new_val['day'] = datas.get('BYMONTHDAY')
|
|
datas.pop('BYMONTHDAY')
|
|
new_val['select1'] = 'date'
|
|
|
|
if datas.get('BYDAY'):
|
|
d = datas.get('BYDAY')
|
|
if '-' in d:
|
|
new_val['byday'] = d[:2]
|
|
new_val['week_list'] = d[2:4].upper()
|
|
else:
|
|
new_val['byday'] = d[:1]
|
|
new_val['week_list'] = d[1:3].upper()
|
|
new_val['select1'] = 'day'
|
|
|
|
if datas.get('BYMONTH'):
|
|
new_val['month_list'] = datas.get('BYMONTH')
|
|
datas.pop('bymonth')
|
|
return new_val
|
|
|
|
|
|
def _get_repeat_status(self, str_google):
|
|
rrule = str_google[str_google.find('FREQ'):str_google.find('\nBEGIN')]
|
|
status = {}
|
|
for rule in rrule.split(';'):
|
|
status[rule.split('=')[0]] = rule.split('=')[-1:] and rule.split('=')[-1:][0] or ''
|
|
rules = self._get_rules(status)
|
|
if status.get('FREQ') == 'WEEKLY':
|
|
status.update({'rrule_type': 'weekly'})
|
|
status.pop('FREQ')
|
|
elif status.get('FREQ') == 'DAILY':
|
|
status.update({'rrule_type': 'daily'})
|
|
status.pop('FREQ')
|
|
elif status.get('FREQ') == 'MONTHLY':
|
|
status.update({'rrule_type': 'monthly'})
|
|
status.pop('FREQ')
|
|
elif status.get('FREQ') == 'YEARLY':
|
|
status.update({'rrule_type': 'yearly'})
|
|
status.pop('FREQ')
|
|
status.update(rules)
|
|
return status
|
|
|
|
|
|
def _get_repeat_dates(self, x):
|
|
if len(x) > 4:
|
|
if x[3].startswith('BY'):
|
|
zone_time = x[4].split('+')[-1:][0].split(':')[0][:4]
|
|
else:
|
|
zone_time = x[3].split('+')[-1:][0].split(':')[0][:4]
|
|
else:
|
|
zone_time = x[2].split('+')[-1:][0].split(':')[0][:4]
|
|
tz_format = zone_time[:2]+':'+zone_time[2:]
|
|
repeat_start = x[1].split('\n')[0].split(':')[1]
|
|
repeat_end = x[2].split('\n')[0].split(':')[1]
|
|
o = repeat_start.split('T')
|
|
repeat_start = str(o[0][:4]) + '-' + str(o[0][4:6]) + '-' + str(o[0][6:8])
|
|
if len(o) == 2:
|
|
repeat_start += ' ' + str(o[1][:2]) + ':' + str(o[1][2:4]) + ':' + str(o[1][4:6])
|
|
else:
|
|
repeat_start += ' ' + '00' + ':' + '00' + ':' + '00'
|
|
p = repeat_end.split('T')
|
|
repeat_end = str(p[0][:4]) + '-' + str(p[0][4:6]) + '-' + str(p[0][6:8])
|
|
if len(p) == 2:
|
|
repeat_end += ' ' + str(p[1][:2]) + ':' + str(p[1][2:4]) + ':' + str(p[1][4:6])
|
|
else:
|
|
repeat_end += ' ' + '00' + ':' + '00' + ':' + '00'
|
|
return (repeat_start, repeat_end, tz_format)
|
|
|
|
def get_events(self):
|
|
if 'tz' in self.context and self.context['tz']:
|
|
time_zone = self.context['tz']
|
|
else:
|
|
time_zone = tools.get_server_timezone()
|
|
au_tz = timezone(time_zone)
|
|
event_vals = []
|
|
for cal in self.calendars:
|
|
events_query = gdata.calendar.service.CalendarEventQuery(user=urllib.unquote(cal.split('/')[~0]))
|
|
events_query.start_index = 1
|
|
events_query.max_results = 1000
|
|
event_feed = self.gd_client.GetCalendarEventFeed(events_query.ToUri())
|
|
for feed in event_feed.entry:
|
|
event = {
|
|
'recurrency': False,
|
|
'end_date' : False,
|
|
'end_type' : False,
|
|
'byday': 0,
|
|
'count' : 0,
|
|
'interval': 1,
|
|
'day': False,
|
|
'select1': False,
|
|
'week_list': "",
|
|
'month_list': False,
|
|
'rrule_type': False,
|
|
}
|
|
|
|
timestring = timestring_end = datetime.datetime.now().strftime(self.DATETIME_FORMAT)
|
|
if feed.when:
|
|
timestring, timestring_end = self._get_tinydates(feed.when[0].start_time, feed.when[0].end_time, au_tz)
|
|
else:
|
|
x = feed.recurrence.text.split(';')
|
|
repeat_status = self._get_repeat_status(feed.recurrence.text)
|
|
repeat_start, repeat_end, zone_time = self._get_repeat_dates(x)
|
|
timestring = time.strftime('%Y-%m-%d %H:%M:%S', time.strptime(repeat_start, "%Y-%m-%d %H:%M:%S"))
|
|
timestring_end = time.strftime('%Y-%m-%d %H:%M:%S', time.strptime(repeat_end, "%Y-%m-%d %H:%M:%S"))
|
|
if repeat_status:
|
|
repeat_status.update({'recurrency': True})
|
|
event.update(repeat_status)
|
|
|
|
event.update({'id' : feed.id.text,
|
|
'DateStart': timestring,
|
|
'DateEnd': timestring_end,
|
|
'Category':event_feed.title.text,
|
|
'Name': feed.title.text or 'No title',
|
|
'Description': feed.content.text,
|
|
})
|
|
event_vals.append(event)
|
|
return event_vals
|
|
|
|
|
|
def get_event_category(self, val, name):
|
|
fields = ['name', 'object_id']
|
|
nameid = 'event_category_'+name
|
|
data = [name, 'crm.meeting']
|
|
return self.import_object(fields, data, 'crm.case.categ', "crm_case_categ", nameid, [('name', 'ilike', name)])
|
|
|
|
def get_rec(self, val):
|
|
if val.get("recurrency"):
|
|
return "1"
|
|
return "0"
|
|
|
|
def get_event_mapping(self):
|
|
return {
|
|
'model': 'crm.meeting',
|
|
'map': {
|
|
'id': 'id',
|
|
'name': 'Name',
|
|
'description': 'Description',
|
|
'email_from': 'Email',
|
|
'date': 'DateStart',
|
|
'date_deadline': 'DateEnd',
|
|
'categ_id/id': call(self.get_event_category, value('Category')),
|
|
'recurrency': self.get_rec,
|
|
'end_date' : 'end_date',
|
|
'end_type' : 'end_type',
|
|
'byday':'byday',
|
|
'count' : 'count',
|
|
'interval': 'interval',
|
|
'day': 'day',
|
|
'select1': 'date',
|
|
'week_list': 'week_list',
|
|
'month_list':'month_list',
|
|
'rrule_type': 'rrule_type',
|
|
}
|
|
}
|
|
|
|
|
|
def get_contact(self):
|
|
table = self.context.get('table')[0]
|
|
datas = []
|
|
if self.context.get('group_name'):
|
|
query = gdata.contacts.service.ContactsQuery()
|
|
query.group = self.context.get('group_name')
|
|
self.contact = self.gd_client.GetContactsFeed(query.ToUri())
|
|
else:
|
|
self.contact = self.gd_client.GetContactsFeed()
|
|
while self.contact:
|
|
for entry in self.contact.entry:
|
|
data = {}
|
|
data['id'] = entry.id.text
|
|
name = tools.ustr(entry.title.text)
|
|
if name == "None":
|
|
name = entry.email and entry.email[0].address or ''
|
|
data['name'] = name or _('Unknown')
|
|
emails = ','.join(email.address for email in entry.email)
|
|
data['email'] = emails
|
|
if table == 'Contact':
|
|
data.update({'customer': str(self.context.get('customer')),
|
|
'supplier': str(self.context.get('supplier'))})
|
|
if entry.organization:
|
|
if entry.organization.org_name:
|
|
data.update({'company': entry.organization.org_name.text})
|
|
if entry.organization.org_title:
|
|
data.update ({'function': entry.organization.org_title.text})
|
|
if entry.phone_number:
|
|
for phone in entry.phone_number:
|
|
if phone.rel == gdata.contacts.REL_WORK:
|
|
data['phone'] = phone.text
|
|
if phone.rel == gdata.contacts.PHONE_MOBILE:
|
|
data['mobile'] = phone.text
|
|
if phone.rel == gdata.contacts.PHONE_WORK_FAX:
|
|
data['fax'] = phone.text
|
|
datas.append(data)
|
|
next = self.contact.GetNextLink()
|
|
self.contact = next and self.gd_client.GetContactsFeed(next.href) or None
|
|
return datas
|
|
|
|
|
|
|
|
def get_contact_mapping(self):
|
|
return {
|
|
'model': 'res.partner',
|
|
#'dependencies': [self.TABLE_ADDRESS],
|
|
'map': {
|
|
'id':'id',
|
|
'name': value('company', fallback='name'),
|
|
'customer': 'customer',
|
|
'supplier': 'supplier',
|
|
'child_ids/id': ref(self.TABLE_ADDRESS, 'id'),
|
|
}
|
|
}
|
|
|
|
def get_partner_id(self, val):
|
|
partner_id = False
|
|
company_pool = self.obj.pool.get('res.partner')
|
|
if 'company' in val:
|
|
partner_ids = company_pool.search(self.cr, self.uid, [('name', '=', val.get('company'))])
|
|
return partner_ids and partner_ids[0] or False
|
|
contact = self.xml_id_exist(self.TABLE_CONTACT, val.get('id'))
|
|
if contact:
|
|
partner_id = self.get_mapped_id(self.TABLE_CONTACT, val.get('id'))
|
|
return partner_id
|
|
|
|
def get_address_mapping(self):
|
|
return {
|
|
'model': 'res.partner',
|
|
'dependencies': [],
|
|
'map': {
|
|
'id':'id',
|
|
'parent_id/.id': self.get_partner_id,
|
|
'name': 'name',
|
|
'city': 'city',
|
|
'phone': 'phone',
|
|
'mobile': 'mobile',
|
|
'email': 'email',
|
|
'fax': 'fax',
|
|
'function': 'function'
|
|
}
|
|
|
|
}
|
|
|
|
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|