addons/import_sugarcrm/import_sugarcrm.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21 from osv import fields, osv
  22 import sugar
  23 from tools.translate import _
  24 from import_base.import_framework import *
  25 from import_base.mapper import *
  26 from datetime import datetime
  27 import base64
  28 import pprint
  29 pp = pprint.PrettyPrinter(indent=4)
  30
  31 #copy old import here
  32 class related_ref(dbmapper):
  33     def __init__(self, type):
  34         self.type = type
  35
  36     def __call__(self, external_val):
  37         if external_val.get('parent_type') in self.type and external_val.get('parent_id'):
  38             return self.parent.xml_id_exist(external_val['parent_type'], external_val['parent_id'])
  39         return ''
  40
  41 class sugar_import(import_framework):
  42     TABLE_CONTACT = 'Contacts'
  43     TABLE_ACCOUNT = 'Accounts'
  44     TABLE_USER = 'Users'
  45     TABLE_EMPLOYEE = 'Employees'
  46     TABLE_RESSOURCE = "resource"
  47     TABLE_OPPORTUNITY = 'Opportunities'
  48     TABLE_LEAD = 'Leads'
  49     TABLE_STAGE = 'crm_stage'
  50     TABLE_ATTENDEE = 'calendar_attendee'
  51     TABLE_CALL = 'Calls'
  52     TABLE_MEETING = 'Meetings'
  53     TABLE_TASK = 'Tasks'
  54     TABLE_PROJECT = 'Project'
  55     TABLE_PROJECT_TASK = 'ProjectTask'
  56     TABLE_BUG = 'Bugs'
  57     TABLE_CASE = 'Cases'
  58     TABLE_NOTE = 'Notes'
  59     TABLE_EMAIL = 'Emails'
  60     TABLE_DOCUMENT = 'DocumentRevisions'
  61     TABLE_COMPAIGN = 'Campaigns'
  62     TABLE_HISTORY_ATTACHMNET = 'history_attachment'
  63
  64     def initialize(self):
  65         #login
  66         PortType,sessionid = sugar.login(self.context.get('username',''), self.context.get('password',''), self.context.get('url',''))
  67         if sessionid == '-1':
  68             raise osv.except_osv(_('Error !'), _('Authentication error !\nBad Username or Password !'))
  69         self.context['port'] = PortType
  70         self.context['session_id'] = sessionid
  71
  72     def get_data(self, table):
  73
  74         return sugar.search(self.context.get('port'), self.context.get('session_id'), table)
  75     """
  76     Common import method
  77     """
  78
  79     def get_category(self, val, model, name):
  80         fields = ['name', 'object_id']
  81         data = [name, model]
  82         return self.import_object(fields, data, 'crm.case.categ', 'crm_categ', name, [('object_id.model','=',model), ('name', 'ilike', name)])
  83
  84     def get_job_title(self, dict, salutation):
  85         fields = ['shortcut', 'name', 'domain']
  86         if salutation:
  87             data = [salutation, salutation, 'Contact']
  88             return self.import_object(fields, data, 'res.partner.title', 'contact_title', salutation, [('shortcut', '=', salutation)])
  89
  90     def get_channel_id(self, dict, val):
  91         fields = ['name']
  92         data = [val]
  93         return self.import_object(fields, data, 'res.partner.canal', 'crm_channel', val)
  94
  95     def get_all_states(self, external_val, country_id):
  96         """Get states or create new state unless country_id is False"""
  97         state_code = external_val[0:3] #take the tree first char
  98         fields = ['country_id/id', 'name', 'code']
  99         data = [country_id, external_val, state_code]
 100         if country_id:
 101             return self.import_object(fields, data, 'res.country.state', 'country_state', external_val)
 102         return False
 103
 104     def get_all_countries(self, val):
 105         """Get Country, if no country match do not create anything, to avoid duplicate country code"""
 106         return self.mapped_id_if_exist('res.country', [('name', 'ilike', val)], 'country', val)
 107
 108     def get_float_time(self, dict, hour, min):
 109         min = int(min) * 100 / 60
 110         return "%s.%i" % (hour, min)
 111
 112     def get_attachment(self, val):
 113         File, Filename = sugar.attachment_search(self.context.get('port'), self.context.get('session_id'), self.TABLE_NOTE, val.get('id'))
 114         attach_xml_id = False
 115         attachment_obj = self.obj.pool.get('ir.attachment')
 116         model_obj = self.obj.pool.get('ir.model.data')
 117         mailgate_obj = self.obj.pool.get('mailgate.message')
 118         if File:
 119             fields = ['name', 'datas', 'datas_fname','res_id', 'res_model']
 120             name = 'attachment_'+ (Filename or val.get('name'))
 121             datas = [Filename or val.get('name'), File, Filename, val.get('res_id'),val.get('model',False)]
 122             attach_xml_id = self.import_object(fields, datas, 'ir.attachment', self.TABLE_HISTORY_ATTACHMNET, name, [('res_id', '=', val.get('res_id'), ('model', '=', val.get('model')))])
 123         return attach_xml_id
 124
 125     """
 126     import Documents
 127     """
 128     #THIS IS A JOKE ? NOT FUNNY
 129     def import_document(self, val):
 130         filepath = '/home/openerp/Public/sugarcrm/cache/upload/'+ val.get('id')
 131         f = open(filepath, "r")
 132         datas = f.read()
 133         f.close()
 134         val['datas'] = base64.encodestring(datas)
 135         val['datas_fname'] = val.get('filename')
 136         return val
 137
 138     def get_document_mapping(self):
 139         return {
 140                 'model' : 'ir.attachment',
 141                 'dependencies' : [self.TABLE_USER],
 142                 'hook' : self.import_document,
 143                 'map' : {'name':'filename',
 144                          'description': ppconcat('description'),
 145                          'datas': 'datas',
 146                          'datas_fname': 'datas_fname',
 147                 }
 148             }
 149
 150     """
 151     import Emails
 152     """
 153
 154     def import_email(self, val):
 155         print 'import email'
 156         model_obj =  self.obj.pool.get('ir.model.data')
 157         xml_id = self.xml_id_exist(val.get('parent_type'), val.get('parent_id'))
 158         model_ids = model_obj.search(self.cr, self.uid, [('name', 'like', xml_id)])
 159         if model_ids:
 160             print 'model_id', xml_id, model_ids
 161             model = model_obj.browse(self.cr, self.uid, model_ids)[0]
 162             if model.model == 'res.partner':
 163                 val['partner_id/.id'] = model.res_id
 164             else:
 165                 val['res_id'] = model.res_id
 166                 val['model'] = model.model
 167         return val
 168
 169     def get_email_mapping(self):
 170         return {
 171                 'model' : 'mailgate.message',
 172                 'dependencies' : [self.TABLE_USER, self.TABLE_PROJECT, self.TABLE_PROJECT_TASK, self.TABLE_ACCOUNT, self.TABLE_CONTACT, self.TABLE_LEAD, self.TABLE_OPPORTUNITY, self.TABLE_MEETING, self.TABLE_CALL],
 173                 'hook' : self.import_email,
 174                 'map' : {'name':'name',
 175                         'date':'date_sent',
 176                         'email_from': 'from_addr_name',
 177                         'email_to': 'reply_to_addr',
 178                         'email_cc': 'cc_addrs_names',
 179                         'email_bcc': 'bcc_addrs_names',
 180                         'message_id': 'message_id',
 181                         'res_id': 'res_id',
 182                         'model': 'model',
 183                         'partner_id/.id': 'partner_id/.id',
 184                         'attachment_ids/id': self.get_attachment,
 185                         'user_id/id': ref(self.TABLE_USER, 'assigned_user_id'),
 186                         'description': ppconcat('description', 'description_html'),
 187                 }
 188             }
 189
 190     """
 191     import History(Notes)
 192     """
 193
 194     def import_history(self, val):
 195         model_obj =  self.obj.pool.get('ir.model.data')
 196         xml_id = self.xml_id_exist(val.get('parent_type'), val.get('parent_id'))
 197         model_ids = model_obj.search(self.cr, self.uid, [('name', 'like', xml_id)])
 198         if model_ids:
 199               model = model_obj.browse(self.cr, self.uid, model_ids)[0]
 200               if model.model == 'res.partner':
 201                     val['partner_id/.id'] = model.res_id
 202               else:
 203                     val['res_id'] = model.res_id
 204                     val['model'] = model.model
 205         return val
 206
 207     def get_history_mapping(self):
 208         return {
 209                 'model' : 'mailgate.message',
 210                 'dependencies' : [self.TABLE_USER, self.TABLE_PROJECT, self.TABLE_PROJECT_TASK, self.TABLE_ACCOUNT, self.TABLE_CONTACT, self.TABLE_LEAD, self.TABLE_OPPORTUNITY, self.TABLE_MEETING, self.TABLE_CALL],
 211                 'hook' : self.import_history,
 212                 'map' : {
 213                       'name':'name',
 214                       'date': 'date_entered',
 215                       'user_id/id': ref(self.TABLE_USER, 'assigned_user_id'),
 216                       'description': ppconcat('description', 'description_html'),
 217                       'res_id': 'res_id',
 218                       'model': 'model',
 219                       'attachment_ids/id': self.get_attachment,
 220                       'partner_id/.id' : 'partner_id/.id',
 221                 }
 222             }
 223
 224     """
 225     import Claims(Cases)
 226     """
 227     def get_claim_priority(self, val):
 228         priority_dict = {
 229                 'High': '2',
 230                 'Medium': '3',
 231                 'Low': '4'
 232         }
 233         return priority_dict.get(val.get('priority'), '')
 234
 235     def get_contact_info_from_account(self, val):
 236         partner_id = self.get_mapped_id(self.TABLE_ACCOUNT, val.get('account_id'))
 237         partner_address_id = False
 238         partner_phone = False
 239         partner_email = False
 240         partner = self.obj.pool.get('res.partner').browse(self.cr, self.uid, [partner_id])[0]
 241         if partner.address and partner.address[0]:
 242             address = partner.address[0]
 243             partner_address_id = address.id
 244             partner_phone = address.phone
 245             partner_email = address.email
 246         return partner_address_id, partner_phone,partner_email
 247
 248     def import_crm_claim(self, val):
 249         partner_address_id, partner_phone,partner_email =  self.get_contact_info_from_account(val)
 250         val['partner_address_id/.id'] = partner_address_id
 251         val['partner_address_id/.id'] = partner_address_id
 252         val['partner_phone'] = partner_phone
 253         val['email_from'] = partner_email
 254         return val
 255
 256     def get_crm_claim_mapping(self):
 257         return {
 258                 'model' : 'crm.claim',
 259                 'dependencies' : [self.TABLE_USER, self.TABLE_ACCOUNT, self.TABLE_CONTACT, self.TABLE_LEAD],
 260                 'hook' : self.import_crm_claim,
 261                 'map' : {
 262                     'name': 'name',
 263                     'date': 'date_entered',
 264                     'user_id/id': ref(self.TABLE_USER, 'assigned_user_id'),
 265                     'description': ppconcat('description'),
 266                     'partner_id/id': ref(self.TABLE_ACCOUNT, 'account_id'),
 267                     'partner_address_id/.id': 'partner_address_id/.id',
 268                     'partner_phone': 'partner_phone',
 269                     'email_from': 'email_from',
 270                     'priority': self.get_claim_priority,
 271                     'state': map_val('status', self.project_issue_state)
 272                 }
 273             }
 274     """
 275     Import Project Issue(Bugs)
 276     """
 277     project_issue_state = {
 278             'New' : 'draft',
 279             'Assigned':'open',
 280             'Closed': 'done',
 281             'Pending': 'pending',
 282             'Rejected': 'cancel',
 283     }
 284
 285     def get_project_issue_priority(self, val):
 286         priority_dict = {
 287                 'Urgent': '1',
 288                 'High': '2',
 289                 'Medium': '3',
 290                 'Low': '4'
 291          }
 292         return priority_dict.get(val.get('priority'), '')
 293
 294     def get_bug_project_id(self, dict, val):
 295         fields = ['name']
 296         data = [val]
 297         return self.import_object(fields, data, 'project.project', 'project_issue', val)
 298
 299     def get_project_issue_mapping(self):
 300         return {
 301                 'model' : 'project.issue',
 302                 'dependencies' : [self.TABLE_USER, self.TABLE_PROJECT, self.TABLE_PROJECT_TASK],
 303                 'map' : {
 304                     'name': 'name',
 305                     'project_id/id': call(self.get_bug_project_id, 'sugarcrm_bugs'),
 306                     'categ_id/id': call(self.get_category, 'project.issue', value('type')),
 307                     'description': ppconcat('description', 'bug_number', 'fixed_in_release_name', 'source', 'fixed_in_release', 'work_log', 'found_in_release', 'release_name', 'resolution'),
 308                     'priority': self.get_project_issue_priority,
 309                     'state': map_val('status', self.project_issue_state)
 310                 }
 311             }
 312
 313     """
 314     import Project Tasks
 315     """
 316     project_task_state = {
 317             'Not Started': 'draft',
 318             'In Progress': 'open',
 319             'Completed': 'done',
 320             'Pending Input': 'pending',
 321             'Deferred': 'cancelled',
 322      }
 323
 324     def get_project_task_priority(self, val):
 325       priority_dict = {
 326             'High': '0',
 327             'Medium': '2',
 328             'Low': '3'
 329         }
 330       return priority_dict.get(val.get('priority'), '')
 331
 332     def get_project_task_mapping(self):
 333         return {
 334                 'model' : 'project.task',
 335                 'dependencies' : [self.TABLE_USER, self.TABLE_PROJECT],
 336                 'map' : {
 337                     'name': 'name',
 338                     'date_start': 'date_start',
 339                     'date_end': 'date_finish',
 340                     'progress': 'progress',
 341                     'project_id/id': ref(self.TABLE_PROJECT, 'project_id'),
 342                     'planned_hours': 'planned_hours',
 343                     'total_hours': 'total_hours',
 344                     'priority': self.get_project_task_priority,
 345                     'description': ppconcat('description','milestone_flag', 'project_task_id', 'task_number'),
 346                     'user_id/id': ref(self.TABLE_USER, 'assigned_user_id'),
 347                     'partner_id/id': 'partner_id/id',
 348                     'contact_id/id': 'contact_id/id',
 349                     'state': map_val('status', self.project_task_state)
 350                 }
 351             }
 352
 353     """
 354     import Projects
 355     """
 356     project_state = {
 357             'Draft' : 'draft',
 358             'In Review': 'open',
 359             'Published': 'close'
 360      }
 361     def import_project_account(self, val):
 362         partner_id = False
 363         partner_invoice_id = False
 364         sugar_project_account = sugar.relation_search(self.context.get('port'), self.context.get('session_id'), 'Project', module_id=val.get('id'), related_module=self.TABLE_ACCOUNT, query=None, deleted=None)
 365         sugar_project_contact = sugar.relation_search(self.context.get('port'), self.context.get('session_id'), 'Project', module_id=val.get('id'), related_module=self.TABLE_CONTACT, query=None, deleted=None)
 366         for contact_id in sugar_project_contact:
 367             partner_invoice_id = self.get_mapped_id(self.TABLE_CONTACT, contact_id)
 368         for account_id in sugar_project_account:
 369             partner_id = self.get_mapped_id(self.TABLE_ACCOUNT, account_id)
 370         return partner_id, partner_invoice_id
 371
 372     def import_project(self, val):
 373         partner_id, partner_invoice_id  = self.import_project_account(val)
 374         val['partner_id/.id'] = partner_id
 375         val['contact_id/.id'] = partner_invoice_id
 376         return val
 377
 378     def get_project_mapping(self):
 379         return {
 380                 'model' : 'project.project',
 381                 'dependencies' : [self.TABLE_CONTACT, self.TABLE_ACCOUNT, self.TABLE_USER],
 382                 'hook' : self.import_project,
 383                 'map' : {
 384                     'name': 'name',
 385                     'date_start': 'estimated_start_date',
 386                     'date': 'estimated_end_date',
 387                     'user_id/id': ref(self.TABLE_USER, 'assigned_user_id'),
 388                     'partner_id/.id': 'partner_id/.id',
 389                     'contact_id/.id': 'contact_id/.id',
 390                     'state': map_val('status', self.project_state)
 391                 }
 392             }
 393
 394     """
 395     import Tasks
 396     """
 397     task_state = {
 398             'Completed' : 'done',
 399             'Not Started':'draft',
 400             'In Progress': 'open',
 401             'Pending Input': 'draft',
 402             'deferred': 'cancel'
 403         }
 404
 405     def import_task(self, val):
 406         val['date'] = val.get('date_start') or datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
 407         val['date_deadline'] = val.get('date_due') or datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
 408         return val
 409
 410     def get_task_mapping(self):
 411         return {
 412                 'model' : 'crm.meeting',
 413                 'dependencies' : [self.TABLE_CONTACT, self.TABLE_ACCOUNT, self.TABLE_USER],
 414                 'hook' : self.import_task,
 415                 'map' : {
 416                     'name': 'name',
 417                     'date': 'date',
 418                     'date_deadline': 'date_deadline',
 419                     'user_id/id': ref(self.TABLE_USER, 'assigned_user_id'),
 420                     'categ_id/id': call(self.get_category, 'crm.meeting', const('Tasks')),
 421                     'partner_id/id': related_ref(self.TABLE_ACCOUNT),
 422                     'partner_address_id/id': ref(self.TABLE_CONTACT,'contact_id'),
 423                     'state': map_val('status', self.task_state)
 424                 }
 425             }
 426
 427     """
 428     import Calls
 429     """
 430     call_state = {
 431             'Planned' : 'open',
 432             'Held':'done',
 433             'Not Held': 'pending',
 434         }
 435
 436     def get_calls_mapping(self):
 437         return {
 438                 'model' : 'crm.phonecall',
 439                 'dependencies' : [self.TABLE_ACCOUNT, self.TABLE_CONTACT, self.TABLE_OPPORTUNITY, self.TABLE_LEAD],
 440                 'map' : {
 441                     'name': 'name',
 442                     'date': 'date_start',
 443                     'duration': call(self.get_float_time, value('duration_hours'), value('duration_minutes')),
 444                     'user_id/id':  ref(self.TABLE_USER, 'assigned_user_id'),
 445                     'partner_id/id': related_ref(self.TABLE_ACCOUNT),
 446                     'partner_address_id/id': related_ref(self.TABLE_CONTACT),
 447                     'categ_id/id': call(self.get_category, 'crm.phonecall', value('direction')),
 448                     'opportunity_id/id': related_ref(self.TABLE_OPPORTUNITY),
 449                     'description': ppconcat('description'),
 450                     'state': map_val('status', self.call_state)
 451                 }
 452             }
 453
 454     """
 455         import meeting
 456     """
 457     meeting_state = {
 458             'Planned' : 'draft',
 459             'Held': 'open',
 460             'Not Held': 'draft',
 461         }
 462 #TODO
 463     def get_attendee_id(self, cr, uid, module_name, module_id):
 464         contact_id = False
 465         user_id = False
 466         attendee_id= []
 467         attendee_dict = sugar.user_get_attendee_list(self.context.get('port'), self.context.get('session_id'), module_name, module_id)
 468         for attendee in attendee_dict:
 469             user_id = self.xml_id_exist(self.TABLE_USER, attendee.get('id', False))
 470             if user_id:
 471                 contact_id = False
 472             else:
 473                 contact_id = self.xml_id_exist(self.TABLE_CONTACT, attendee.get('id', False))
 474             fields = ['user_id/id', 'email', 'partner_address_id/id']
 475             data = [user_id or False, attendee.get('email1'), contact_id]
 476             attendee_xml_id = self.import_object(fields, data, 'calendar.attendee', self.TABLE_ATTENDEE, user_id or contact_id or attendee.get('email1'), ['|',('user_id', '=', attendee.get('id')),('partner_address_id','=',attendee.get('id')),('email', '=', attendee.get('email1'))])
 477             attendee_id.append(attendee_xml_id)
 478         return ','.join(attendee_id)
 479
 480     def get_alarm_id(self, dict_val, val):
 481         alarm_dict = {
 482             '60': '1 minute before',
 483             '300': '5 minutes before',
 484             '600': '10 minutes before',
 485             '900': '15 minutes before',
 486             '1800':'30 minutes before',
 487             '3600': '1 hour before',
 488         }
 489         return self.mapped_id_if_exist('res.alarm', [('name', 'like', alarm_dict.get(val))], 'alarm', val)
 490
 491     #TODO attendees
 492     def import_meeting(self, val):
 493         attendee_id = self.get_attendee_id(self.cr, self.uid, 'Meetings', val.get('id')) #TODO
 494         val['attendee_ids/id'] = attendee_id
 495         return val
 496
 497     def get_meeting_mapping(self):
 498         return {
 499                 'model' : 'crm.meeting',
 500                 'dependencies' : [self.TABLE_CONTACT, self.TABLE_OPPORTUNITY, self.TABLE_LEAD],
 501                 'hook': self.import_meeting,
 502                 'map' : {
 503                     'name': 'name',
 504                     'date': 'date_start',
 505                     'duration': call(self.get_float_time, value('duration_hours'), value('duration_minutes')),
 506                     'location': 'location',
 507                     'attendee_ids/id':'attendee_ids/id',
 508                     'alarm_id/id': call(self.get_alarm_id, value('reminder_time')),
 509                     'user_id/id': ref(self.TABLE_USER, 'assigned_user_id'),
 510                     'partner_id/id': related_ref(self.TABLE_ACCOUNT),
 511                     'partner_address_id/id': related_ref(self.TABLE_CONTACT),
 512                     'state': map_val('status', self.meeting_state)
 513                 }
 514             }
 515
 516     """
 517         import Opportunity
 518     """
 519     opp_state = {
 520             'Need Analysis' : 'New',
 521             'Closed Lost': 'Lost',
 522             'Closed Won': 'Won',
 523             'Value Proposition': 'Proposition',
 524             'Negotiation/Review': 'Negotiation'
 525         }
 526
 527     def get_opportunity_status(self, sugar_val):
 528         fields = ['name', 'type']
 529         name = 'Opportunity_' + sugar_val['sales_stage']
 530         data = [sugar_val['sales_stage'], 'Opportunity']
 531         return self.import_object(fields, data, 'crm.case.stage', self.TABLE_STAGE, name, [('type', '=', 'opportunity'), ('name', 'ilike', sugar_val['sales_stage'])])
 532
 533     def import_opportunity_contact(self, val):
 534         sugar_opportunities_contact = set(sugar.relation_search(self.context.get('port'), self.context.get('session_id'), 'Opportunities', module_id=val.get('id'), related_module='Contacts', query=None, deleted=None))
 535
 536         partner_contact_id = False
 537         partner_contact_email = False
 538         partner_address_obj = self.obj.pool.get('res.partner.address')
 539         partner_xml_id = self.name_exist(self.TABLE_ACCOUNT, val['account_name'], 'res.partner')
 540
 541         for contact in sugar_opportunities_contact:
 542             address_id = self.get_mapped_id(self.TABLE_CONTACT, contact)
 543             if address_id:
 544                 address = partner_address_obj.browse(self.cr, self.uid, address_id)
 545                 partner_name = address.partner_id and address.partner_id.name or False
 546                 if not partner_name: #link with partner id
 547                     fields = ['partner_id/id']
 548                     data = [partner_xml_id]
 549                     self.import_object(fields, data, 'res.partner.address', self.TABLE_CONTACT, contact, self.DO_NOT_FIND_DOMAIN)
 550                 if not partner_name or partner_name == val.get('account_name'):
 551                     partner_contact_id = self.xml_id_exist(self.TABLE_CONTACT, contact)
 552                     partner_contact_email = address.email
 553         return partner_contact_id, partner_contact_email
 554
 555     def import_opp(self, val):
 556         partner_contact_name, partner_contact_email = self.import_opportunity_contact(val)
 557         val['partner_address_id/id'] = partner_contact_name
 558         val['email_from'] = partner_contact_email
 559         return val
 560
 561     def get_opp_mapping(self):
 562         return {
 563             'model' : 'crm.lead',
 564             'dependencies' : [self.TABLE_USER, self.TABLE_ACCOUNT, self.TABLE_CONTACT,self.TABLE_COMPAIGN],
 565             'hook' : self.import_opp,
 566             'map' :  {
 567                 'name': 'name',
 568                 'probability': 'probability',
 569                 'partner_id/id': refbyname(self.TABLE_ACCOUNT, 'account_name', 'res.partner'),
 570                 'title_action': 'next_step',
 571                 'partner_address_id/id': 'partner_address_id/id',
 572                 'planned_revenue': 'amount',
 573                 'date_deadline': 'date_closed',
 574                 'user_id/id' : ref(self.TABLE_USER, 'assigned_user_id'),
 575                 'stage_id/id' : self.get_opportunity_status,
 576                 'type' : const('opportunity'),
 577                 'categ_id/id': call(self.get_category, 'crm.lead', value('opportunity_type')),
 578                 'email_from': 'email_from',
 579                 'state': map_val('status', self.opp_state)  , #TODO
 580             }
 581         }
 582
 583     """
 584     import campaign
 585     """
 586
 587     def get_compaign_mapping(self):
 588         return {
 589             'model' : 'crm.case.resource.type',
 590             'map' : {
 591                 'name': 'name',
 592                 }
 593         }
 594
 595     """
 596         import lead
 597     """
 598     def get_lead_status(self, sugar_val):
 599         fields = ['name', 'type']
 600         name = 'lead_' + sugar_val.get('status', '')
 601         data = [sugar_val.get('status', ''), 'lead']
 602         return self.import_object(fields, data, 'crm.case.stage', self.TABLE_STAGE, name, [('type', '=', 'lead'), ('name', 'ilike', sugar_val.get('status', ''))])
 603
 604     lead_state = {
 605         'New' : 'draft',
 606         'Assigned':'open',
 607         'In Progress': 'open',
 608         'Recycled': 'cancel',
 609         'Dead': 'done',
 610         'Converted': 'done',
 611     }
 612
 613
 614     def import_lead(self, val):
 615         if val.get('opportunity_id'): #if lead is converted into opp, don't import as lead
 616             return False
 617         if val.get('primary_address_country'):
 618             country_id = self.get_all_countries(val.get('primary_address_country'))
 619             val['country_id/id'] =  country_id
 620             val['state_id/id'] =  self.get_all_states(val.get('primary_address_state'), country_id)
 621         return val
 622
 623     def get_lead_mapping(self):
 624         return {
 625             'model' : 'crm.lead',
 626             'dependencies' : [self.TABLE_COMPAIGN],
 627             'hook' : self.import_lead,
 628             'map' : {
 629                 'name': concat('first_name', 'last_name'),
 630                 'contact_name': concat('first_name', 'last_name'),
 631                 'description': ppconcat('description', 'refered_by', 'lead_source', 'lead_source_description', 'website', 'email2', 'status_description', 'lead_source_description', 'do_not_call'),
 632                 'partner_name': 'account_name',
 633                 'email_from': 'email1',
 634                 'phone': 'phone_work',
 635                 'mobile': 'phone_mobile',
 636                 'title/id': call(self.get_job_title, value('salutation')),
 637                 'function':'title',
 638                 'street': 'primary_address_street',
 639                 'street2': 'alt_address_street',
 640                 'zip': 'primary_address_postalcode',
 641                 'city':'primary_address_city',
 642                 'user_id/id' : ref(self.TABLE_USER, 'assigned_user_id'),
 643                 'stage_id/id' : self.get_lead_status,
 644                 'type' : const('lead'),
 645                 'state': map_val('status', self.lead_state) ,
 646                 'fax': 'phone_fax',
 647                 'referred': 'refered_by',
 648                 'optout': 'do_not_call',
 649                 'channel_id/id': call(self.get_channel_id, value('lead_source')),
 650                 'type_id/id': ref(self.TABLE_COMPAIGN, 'campaign_id'),
 651                 'country_id/id': 'country_id/id',
 652                 'state_id/id': 'state_id/id'
 653                 }
 654         }
 655
 656     """
 657         import contact
 658     """
 659     def get_email(self, val):
 660         email_address = sugar.get_contact_by_email(self.context.get('port'), self.context.get('username'), self.context.get('password'), val.get('email1'))
 661         if email_address:
 662             return ','.join(email_address)
 663
 664     def import_contact(self, val):
 665         if val.get('primary_address_country'):
 666             country_id = self.get_all_countries(val.get('primary_address_country'))
 667             state = self.get_all_states(val.get('primary_address_state'), country_id)
 668             val['country_id/id'] =  country_id
 669             val['state_id/id'] =  state
 670         return val
 671
 672     def get_contact_mapping(self):
 673         return {
 674             'model' : 'res.partner.address',
 675             'dependencies' : [self.TABLE_ACCOUNT],
 676             'hook' : self.import_contact,
 677             'map' :  {
 678                 'name': concat('first_name', 'last_name'),
 679                 'partner_id/id': ref(self.TABLE_ACCOUNT,'account_id'),
 680                 'phone': 'phone_work',
 681                 'mobile': 'phone_mobile',
 682                 'fax': 'phone_fax',
 683                 'function': 'title',
 684                 'street': 'primary_address_street',
 685                 'zip': 'primary_address_postalcode',
 686                 'city': 'primary_address_city',
 687                 'country_id/id': 'country_id/id',
 688                 'state_id/id': 'state_id/id',
 689                 'email': self.get_email,
 690                 'type': const('contact')
 691             }
 692         }
 693
 694     """
 695         import Account
 696     """
 697     def get_address_type(self, val, type):
 698         if type == 'invoice':
 699             type_address = 'billing'
 700         else:
 701             type_address = 'shipping'
 702
 703         map_partner_address = {
 704             'name': 'name',
 705             'phone': 'phone_office',
 706             'mobile': 'phone_mobile',
 707             'fax': 'phone_fax',
 708             'type': 'type',
 709             'street': type_address + '_address_street',
 710             'zip': type_address +'_address_postalcode',
 711             'city': type_address +'_address_city',
 712              'country_id/id': 'country_id/id',
 713              'type': 'type',
 714             }
 715
 716         if val.get(type_address +'_address_country'):
 717             country_id = self.get_all_countries(val.get(type_address +'_address_country'))
 718             state = self.get_all_states(val.get(type_address +'_address_state'), country_id)
 719             val['country_id/id'] =  country_id
 720             val['state_id/id'] =  state
 721         val['type'] = type
 722         val['id_new'] = val['id'] + '_address_' + type
 723         return self.import_object_mapping(map_partner_address, val, 'res.partner.address', self.TABLE_CONTACT, val['id_new'], self.DO_NOT_FIND_DOMAIN)
 724
 725     def get_partner_address(self, val):
 726         address_id=[]
 727         type_dict = {'billing_address_street' : 'invoice', 'shipping_address_street' : 'delivery'}
 728         for key, type_value in type_dict.items():
 729             if val.get(key):
 730                 id = self.get_address_type(val, type_value)
 731                 address_id.append(id)
 732
 733         return ','.join(address_id)
 734
 735     def get_partner_mapping(self):
 736         return {
 737                 'model' : 'res.partner',
 738                 'dependencies' : [self.TABLE_USER],
 739                 'map' : {
 740                     'name': 'name',
 741                     'website': 'website',
 742                     'user_id/id': ref(self.TABLE_USER,'assigned_user_id'),
 743                     'ref': 'sic_code',
 744                     'comment': ppconcat('description', 'employees', 'ownership', 'annual_revenue', 'rating', 'industry', 'ticker_symbol'),
 745                     'customer': const('1'),
 746                     'supplier': const('0'),
 747                     'address/id':'address/id',
 748                     'parent_id/id_parent' : 'parent_id',
 749                     'address/id' : self.get_partner_address,
 750                 }
 751         }
 752
 753     """
 754         import Employee
 755     """
 756     def get_ressource(self, val):
 757         map_resource = {
 758             'name': concat('first_name', 'last_name'),
 759         }
 760         return self.import_object_mapping(map_resource, val, 'resource.resource', self.TABLE_RESSOURCE, val['id'], self.DO_NOT_FIND_DOMAIN)
 761
 762     def get_job_id(self, val):
 763         fields = ['name']
 764         data = [val.get('title')]
 765         return self.import_object(fields, data, 'hr.job', 'hr_job', val.get('title'))
 766
 767     def get_user_address(self, val):
 768         map_user_address = {
 769             'name': concat('first_name', 'last_name'),
 770             'city': 'address_city',
 771             'country_id/id': 'country_id/id',
 772             'state_id/id': 'state_id/id',
 773             'street': 'address_street',
 774             'zip': 'address_postalcode',
 775             'fax': 'fax',
 776             'phone': 'phone_work',
 777             'mobile':'phone_mobile',
 778             'email': 'email1'
 779         }
 780
 781         if val.get('address_country'):
 782             country_id = self.get_all_countries(val.get('address_country'))
 783             state_id = self.get_all_states(val.get('address_state'), country_id)
 784             val['country_id/id'] =  country_id
 785             val['state_id/id'] =  state_id
 786
 787         return self.import_object_mapping(map_user_address, val, 'res.partner.address', self.TABLE_CONTACT, val['id'], self.DO_NOT_FIND_DOMAIN)
 788
 789     def get_employee_mapping(self):
 790         return {
 791             'model' : 'hr.employee',
 792             'dependencies' : [self.TABLE_USER],
 793             'map' : {
 794                 'resource_id/id': self.get_ressource,
 795                 'name': concat('first_name', 'last_name'),
 796                 'work_phone': 'phone_work',
 797                 'mobile_phone':  'phone_mobile',
 798                 'user_id/id': ref(self.TABLE_USER, 'id'),
 799                 'address_home_id/id': self.get_user_address,
 800                 'notes': ppconcat('messenger_type', 'messenger_id', 'description'),
 801                 'job_id/id': self.get_job_id,
 802             }
 803      }
 804
 805     """
 806         import user
 807     """
 808     def import_user(self, val):
 809         user_obj = self.obj.pool.get('res.users')
 810         user_ids = user_obj.search(self.cr, self.uid, [('login', '=', val.get('user_name'))])
 811         if user_ids:
 812             val['.id'] = str(user_ids[0])
 813         else:
 814             val['password'] = 'sugarcrm' #default password for all user #TODO needed in documentation
 815
 816         val['context_lang'] = self.context.get('lang','en_US')
 817         return val
 818
 819     def get_users_department(self, val):
 820         dep = val.get('department')
 821         fields = ['name']
 822         data = [dep]
 823         if not dep:
 824             return False
 825         return self.import_object(fields, data, 'hr.department', 'hr_department_user', dep)
 826
 827     def get_user_mapping(self):
 828         return {
 829             'model' : 'res.users',
 830             'hook' : self.import_user,
 831             'map' : {
 832                 'name': concat('first_name', 'last_name'),
 833                 'login': 'user_name',
 834                 'context_lang' : 'context_lang',
 835                 'password' : 'password',
 836                 '.id' : '.id',
 837                 'context_department_id/id': self.get_users_department,
 838             }
 839         }
 840
 841     def get_mapping(self):
 842         return {
 843             self.TABLE_USER : self.get_user_mapping(),
 844             self.TABLE_EMPLOYEE : self.get_employee_mapping(),
 845             self.TABLE_ACCOUNT : self.get_partner_mapping(),
 846             self.TABLE_CONTACT : self.get_contact_mapping(),
 847             self.TABLE_LEAD : self.get_lead_mapping(),
 848             self.TABLE_OPPORTUNITY : self.get_opp_mapping(),
 849             self.TABLE_MEETING : self.get_meeting_mapping(),
 850             self.TABLE_CALL : self.get_calls_mapping(),
 851             self.TABLE_TASK : self.get_task_mapping(),
 852             self.TABLE_PROJECT : self.get_project_mapping(),
 853             self.TABLE_PROJECT_TASK: self.get_project_task_mapping(),
 854             self.TABLE_BUG: self.get_project_issue_mapping(),
 855             self.TABLE_CASE: self.get_crm_claim_mapping(),
 856             self.TABLE_NOTE: self.get_history_mapping(),
 857             self.TABLE_EMAIL: self.get_email_mapping(),
 858             self.TABLE_DOCUMENT: self.get_document_mapping(),
 859             self.TABLE_COMPAIGN: self.get_compaign_mapping()
 860
 861         }
 862     def get_email_subject(self, result):
 863         return "your sugarcrm data were successfully imported at %s" % self.date_ended
 864
 865     def get_body_header(self, result):
 866         return "Sugarcrm import : report of last import"
 867
 868
 869 class import_sugarcrm(osv.osv):
 870     """Import SugarCRM DATA"""
 871
 872     _name = "import.sugarcrm"
 873     _description = __doc__
 874     _columns = {
 875
 876         'username': fields.char('User Name', size=64, required=True),
 877         'password': fields.char('Password', size=24,required=True),
 878          'url' : fields.char('Service', size=264, required=True, help="Connection with Sugarcrm Using Soap Protocol Services and For that Path should be 'http://localhost/sugarcrm/soap.php' Format."),
 879
 880         'opportunity': fields.boolean('Leads and Opportunities', help="If Opportunities are checked, SugarCRM opportunities data imported in OpenERP crm-Opportunity form"),
 881         'user': fields.boolean('Users', help="If Users  are checked, SugarCRM Users data imported in OpenERP Users form"),
 882         'contact': fields.boolean('Contacts', help="If Contacts are checked, SugarCRM Contacts data imported in OpenERP partner address form"),
 883         'account': fields.boolean('Accounts', help="If Accounts are checked, SugarCRM  Accounts data imported in OpenERP partners form"),
 884         'employee': fields.boolean('Employee', help="If Employees is checked, SugarCRM Employees data imported in OpenERP employees form"),
 885         'meeting': fields.boolean('Meetings', help="If Meetings is checked, SugarCRM Meetings data imported in OpenERP meetings form"),
 886         'call': fields.boolean('Calls', help="If Calls is checked, SugarCRM Calls data imported in OpenERP phonecalls form"),
 887         'claim': fields.boolean('Claims', help="If Claims is checked, SugarCRM Claims data imported in OpenERP Claims form"),
 888         'email': fields.boolean('Emails', help="If Emails is checked, SugarCRM Emails data imported in OpenERP Emails form"),
 889         'project': fields.boolean('Projects', help="If Projects is checked, SugarCRM Projects data imported in OpenERP Projects form"),
 890         'project_task': fields.boolean('Project Tasks', help="If Project Tasks is checked, SugarCRM Project Tasks data imported in OpenERP Project Tasks form"),
 891         'task': fields.boolean('Tasks', help="If Tasks is checked, SugarCRM Tasks data imported in OpenERP Meetings form"),
 892         'bug': fields.boolean('Bugs', help="If Bugs is checked, SugarCRM Bugs data imported in OpenERP Project Issues form"),
 893         'attachment': fields.boolean('Attachments', help="If Attachments is checked, SugarCRM Notes data imported in OpenERP's Related module's History with attachment"),
 894         'document': fields.boolean('Documents', help="If Documents is checked, SugarCRM Documents data imported in OpenERP Document Form"),
 895         'email_from': fields.char('Notify End Of Import To:', size=128),
 896         'instance_name': fields.char("Instance's Name", size=64, help="Prefix of SugarCRM id to differentiate xml_id of SugarCRM models datas come from different server."),
 897
 898     }
 899     _defaults = {#to be set to true, but easier for debugging
 900        'opportunity': False,
 901        'user' : False,
 902        'contact' : False,
 903        'account' : False,
 904         'employee' : False,
 905         'meeting' : False,
 906         'task' : False,
 907         'call' : False,
 908         'claim' : False,
 909         'email' : False,
 910         'project' : False,
 911         'project_task': False,
 912         'bug': False,
 913         'document': False,
 914         'instance_name': 'sugarcrm',
 915         'email_from': 'tfr@openerp.com',
 916         'username' : 'tfr',
 917         'password' : 'a',
 918         'url':  "http://localhost/sugarcrm/soap.php"
 919     }
 920
 921     def get_key(self, cr, uid, ids, context=None):
 922         """Select Key as For which Module data we want import data."""
 923         if not context:
 924             context = {}
 925         key_list = []
 926         for current in self.browse(cr, uid, ids, context):
 927             context.update({'username': current.username, 'password': current.password, 'url': current.url, 'email_user': current.email_from or False, 'instance_name': current.instance_name or False})
 928             if current.opportunity:
 929                 key_list.append('Leads')
 930                 key_list.append('Opportunities')
 931             if current.user:
 932                 key_list.append('Users')
 933             if current.contact:
 934                 key_list.append('Contacts')
 935             if current.account:
 936                 key_list.append('Accounts')
 937             if current.employee:
 938                 key_list.append('Employees')
 939             if current.meeting:
 940                 key_list.append('Meetings')
 941             if current.task:
 942                 key_list.append('Tasks')
 943             if current.call:
 944                 key_list.append('Calls')
 945             if current.claim:
 946                 key_list.append('Cases')
 947             if current.email:
 948                 key_list.append('Emails')
 949             if current.project:
 950                 key_list.append('Project')
 951             if current.project_task:
 952                 key_list.append('ProjectTask')
 953             if current.bug:
 954                 key_list.append('Bugs')
 955             if current.attachment:
 956                 key_list.append('Notes')
 957             if current.document:
 958                 key_list.append('DocumentRevisions')
 959         return key_list
 960
 961
 962     def do_import_all(self, cr, uid, *args):
 963         """
 964         scheduler Method
 965         """
 966         print 'args of schedule method', args
 967         context = {'username': args[4], 'password': args[5], 'url': args[3], 'instance_name': args[3]}
 968         print context
 969         imp = sugar_import(self, cr, uid, args[2], "import_sugarcrm", [args[1]], context)
 970         imp.set_table_list(args[0])
 971         imp.start()
 972         return True
 973
 974     def import_from_scheduler_all(self, cr, uid, ids, context=None):
 975         keys = self.get_key(cr, uid, ids, context)
 976         if not keys:
 977             raise osv.except_osv(_('Warning !'), _('Select Module to Import.'))
 978         cron_obj = self.pool.get('ir.cron')
 979         args = (keys,context.get('email_user'), context.get('instance_name'), context.get('url'), context.get('username'), context.get('password') )
 980         new_create_id = cron_obj.create(cr, uid, {'name': 'Import SugarCRM datas','interval_type': 'hours','interval_number': 1, 'numbercall': -1,'model': 'import.sugarcrm','function': 'do_import_all', 'args': args, 'active': False})
 981         return {
 982             'name': 'SugarCRM Scheduler',
 983             'view_type': 'form',
 984             'view_mode': 'form,tree',
 985             'res_model': 'ir.cron',
 986             'res_id': new_create_id,
 987             'type': 'ir.actions.act_window',
 988         }
 989
 990     def import_all(self, cr, uid, ids, context=None):
 991
 992 #        """Import all sugarcrm data into openerp module"""
 993         keys = self.get_key(cr, uid, ids, context)
 994         imp = sugar_import(self, cr, uid, context.get('instance_name'), "import_sugarcrm", [context.get('email_user')], context)
 995         imp.set_table_list(keys)
 996         imp.start()
 997
 998         obj_model = self.pool.get('ir.model.data')
 999         model_data_ids = obj_model.search(cr,uid,[('model','=','ir.ui.view'),('name','=','import.message.form')])
1000         resource_id = obj_model.read(cr, uid, model_data_ids, fields=['res_id'])
1001         return {
1002                 'view_type': 'form',
1003                 'view_mode': 'form',
1004                 'res_model': 'import.message',
1005                 'views': [(resource_id,'form')],
1006                 'type': 'ir.actions.act_window',
1007                 'target': 'new',
1008             }
1009
1010 import_sugarcrm()