Merge lp:~unifield-team/unifield-server/us-966-clean into lp:unifield-server

[Quentin THEURET @Amaris]

=== modified file 'bin/addons/import_data/import_data.py'
--- bin/addons/import_data/import_data.py	2016-01-05 14:50:57 +0000
+++ bin/addons/import_data/import_data.py	2016-05-26 09:26:36 +0000
@@ -190,12 +190,23 @@
         'import_mode': lambda *a: 'create',
     }
 
-    def _import(self, dbname, uid, ids, context=None):
+    def _import(self, cr, uid, ids, context=None, use_new_cursor=True, auto_import=False):
         """if context includes 'import_data_field_max_size' dict,
         this dict specifies the max tolerated field length at import
         (key: field name, value: field size)
         """
-        cr = pooler.get_db(dbname).cursor()
+        dbname = cr.dbname
+        if use_new_cursor:
+            cr = pooler.get_db(cr.dbname).cursor()
+
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        processed = []
+        rejected = []
 
         obj = self.read(cr, uid, ids[0])
         import_mode = obj.get('import_mode')
@@ -282,7 +293,9 @@
                 self._cache[dbname]['product.international.status']['name'].update({iv['name']: iv['id']})
 
         errorfile = TemporaryFile('w+')
-        writer = csv.writer(errorfile, quotechar='"', delimiter=';')
+        writer = False
+        if not auto_import:
+            writer = csv.writer(errorfile, quotechar='"', delimiter=';')
 
         fields_def = impobj.fields_get(cr, uid, context=context)
         i = 0
@@ -342,6 +355,13 @@
 
             raise osv.except_osv(_('Warning !'), _('%s does not exist')%(value,))
 
+        def write_error_row(row, index, error=""):
+            if not auto_import and writer:
+                row.append(error)
+                writer.writerow(row)
+            else:
+                rejected.append((index, row, error))
+
         i = 1
         nb_error = 0
         nb_succes = 0
@@ -350,7 +370,8 @@
         if self.pre_hook.get(impobj._name):
             # for headers mod.
             col_datas = self.pre_hook[impobj._name](impobj, cr, uid, headers, {}, col_datas)
-        writer.writerow(headers)
+        if not auto_import and writer:
+            writer.writerow(headers)
 
         for row in reader:
             newo2m = False
@@ -394,9 +415,8 @@
                                 logging.getLogger('import data').info(
                                     'Error %s'% (msg, ))
                                 cr.rollback()
-                                row.append("Line %s, row: %s, %s" % (i, n,
-                                    msg, ))
-                                writer.writerow(row)
+                                error = "Line %s, row: %s, %s" % (i, n, msg, )
+                                write_error_row(row, i, error)
                                 nb_error += 1
                                 line_ok = False
                                 break
@@ -464,62 +484,64 @@
                     impobj.create(cr, uid, data, context={'from_import_menu': True})
                     nb_succes += 1
                     cr.commit()
+                processed.append((i, row))
             except osv.except_osv, e:
                 logging.getLogger('import data').info('Error %s'%e.value)
                 cr.rollback()
-                row.append("Line %s, row: %s, %s"%(i, n, e.value))
-                writer.writerow(row)
+                error = "Line %s, row: %s, %s"%(i, n, e.value)
+                write_error_row(row, i, error)
                 nb_error += 1
             except Exception, e:
                 cr.rollback()
                 logging.getLogger('import data').info('Error %s'%e)
-                row.append("Line %s, row: %s, %s"%(i, n, e))
-                writer.writerow(row)
+                error = "Line %s, row: %s, %s"%(i, n, e)
+                write_error_row(row, i, error)
                 nb_error += 1
 
         if self.post_load_hook.get(impobj._name):
             self.post_load_hook[impobj._name](impobj, cr, uid)
         fileobj.close()
-        import_type = 'Import'
-        if import_mode == 'update':
-            import_type = 'Update'
-            summary = '''Datas Import Summary:
-Object: %s
-Records updated: %s
-Records created: %s
-'''%(objname, nb_update_success, nb_succes)
-        else:
-            summary = '''Datas Import Summary:
-Object: %s
-Records created: %s
-'''%(objname, nb_succes)
-
-        if nb_error:
-            summary += '''Records rejected: %s
-
-Find in attachment the rejected lines'''%(nb_error)
-
-        request_obj = self.pool.get('res.request')
-        req_id = request_obj.create(cr, uid,
-            {'name': "%s %s"%(import_type, objname,),
-            'act_from': uid,
-            'act_to': uid,
-            'body': summary,
-            })
-        if req_id:
-            request_obj.request_send(cr, uid, [req_id])
-
-        if nb_error:
-            errorfile.seek(0)
-            attachment = self.pool.get('ir.attachment')
-            attachment.create(cr, uid, {
-                'name': 'rejected-lines.csv',
-                'datas_fname': 'rejected-lines.csv',
-                'description': 'Rejected Lines',
-                'res_model': 'res.request',
-                'res_id': req_id,
-                'datas': base64.encodestring(errorfile.read()),
-            })
+        if not auto_import:
+            import_type = 'Import'
+            if import_mode == 'update':
+                import_type = 'Update'
+                summary = '''Datas Import Summary:
+    Object: %s
+    Records updated: %s
+    Records created: %s
+    '''%(objname, nb_update_success, nb_succes)
+            else:
+                summary = '''Datas Import Summary:
+    Object: %s
+    Records created: %s
+    '''%(objname, nb_succes)
+
+            if nb_error:
+                summary += '''Records rejected: %s
+
+    Find in attachment the rejected lines'''%(nb_error)
+
+            request_obj = self.pool.get('res.request')
+            req_id = request_obj.create(cr, uid,
+                {'name': "%s %s"%(import_type, objname,),
+                'act_from': uid,
+                'act_to': uid,
+                'body': summary,
+                })
+            if req_id:
+                request_obj.request_send(cr, uid, [req_id])
+
+            if nb_error:
+                errorfile.seek(0)
+                attachment = self.pool.get('ir.attachment')
+                attachment.create(cr, uid, {
+                    'name': 'rejected-lines.csv',
+                    'datas_fname': 'rejected-lines.csv',
+                    'description': 'Rejected Lines',
+                    'res_model': 'res.request',
+                    'res_id': req_id,
+                    'datas': base64.encodestring(errorfile.read()),
+                })
 
         if impobj == 'product.product':
             # Clear the cache
@@ -528,10 +550,14 @@
 
         errorfile.close()
         cr.commit()
-        cr.close(True)
+        if use_new_cursor:
+            cr.close(True)
+
+        if auto_import:
+            return processed, rejected, headers
 
     def import_csv(self, cr, uid, ids, context=None):
-        thread = threading.Thread(target=self._import, args=(cr.dbname, uid, ids, context))
+        thread = threading.Thread(target=self._import, args=(cr, uid, ids, context))
         thread.start()
         return {'type': 'ir.actions.act_window_close'}
 

=== modified file 'bin/addons/msf_homere_interface/hr.py'
--- bin/addons/msf_homere_interface/hr.py	2016-01-04 13:16:43 +0000
+++ bin/addons/msf_homere_interface/hr.py	2016-05-26 09:26:36 +0000
@@ -326,5 +326,20 @@
 
         return super(hr_employee, self).name_search(cr, uid, name, args, operator, context, limit)
 
+    def auto_import(self, cr, uid, file_to_import):
+        import base64
+        import os
+        processed = []
+        rejected = []
+        headers = []
+
+        import_obj = self.pool.get('hr.expat.employee.import')
+        import_id = import_obj.create(cr, uid, {
+            'file': base64.encodestring(open(file_to_import, 'r').read()),
+            'filename': os.path.split(file_to_import)[1],
+        })
+        processed, rejected, headers = import_obj.button_validate(cr, uid, [import_id], auto_import=True)
+        return processed, rejected, headers
+
 hr_employee()
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== modified file 'bin/addons/msf_homere_interface/wizard/hr_expat_import.py'
--- bin/addons/msf_homere_interface/wizard/hr_expat_import.py	2015-03-24 08:40:43 +0000
+++ bin/addons/msf_homere_interface/wizard/hr_expat_import.py	2016-05-26 09:26:36 +0000
@@ -37,7 +37,7 @@
         'filename': fields.char(string="Imported filename", size=256),
     }
 
-    def button_validate(self, cr, uid, ids, context=None):
+    def button_validate(self, cr, uid, ids, context=None, auto_import=False):
         """
         Import XLS file
         """
@@ -46,12 +46,22 @@
                 line.cells[cell_index] and line.cells[cell_index].data \
                 or False
 
+        def manage_error(line_index, msg, name='', code='', status=''):
+            if auto_import:
+                rejected_lines.append((line_index, [name, code, status], msg))
+            else:
+                raise osv.except_osv(_('Error'), _(msg))
+
+        processed_lines = []
+        rejected_lines = []
+        headers = [_('Name'), _('Code'), _('Status')]
         hr_emp_obj = self.pool.get('hr.employee')
         # Some verifications
         if not context:
             context = {}
         if isinstance(ids, (int, long)):
             ids = [ids]
+
         for wiz in self.browse(cr, uid, ids):
             # Prepare some values
             created = 0
@@ -72,25 +82,28 @@
                 # get cells
                 name = get_xml_spreadheet_cell_value(0)
                 if not name:
+                    manage_error(line_index, 'No name defined')
                     continue
                 code = get_xml_spreadheet_cell_value(1)
                 if not code:
                     msg = "At least one employee in the import file does not" \
                         " have an ID number; make sure all employees in the" \
                         " file have an ID number and run the import again."
-                    raise osv.except_osv(_('Error'), _(msg))
+                    manage_error(line_index, msg, name)
                 active_str = get_xml_spreadheet_cell_value(2)
                 if not active_str:
-                    msg = "Active column is missing or empty at line %d"
-                    raise osv.except_osv(_('Error'), _(msg) % (line_index, ))
+                    msg = "Active column is missing or empty at line %d" % line_index
+                    manage_error(line_index, msg, name, code)
                 active_str = active_str.lower()
                 if active_str not in ('active', 'inactive'):
                     msg = "Active column invalid value line %d" \
-                        " (should be Active/Inactive)"
-                    raise osv.except_osv(_('Error'), _(msg) % (line_index, ))
+                        " (should be Active/Inactive)" % line_index
+                    manage_error(line_index, msg, name, code, active_str)
                 active = active_str == 'active' or False
 
                 processed += 1
+                if auto_import:
+                    processed_lines.append((line_index, [name, code, active_str]))
 
                 ids = hr_emp_obj.search(cr, uid,
                     [('identification_id', '=', code)])
@@ -114,6 +127,9 @@
 
             context.update({'message': ' ', 'from': 'expat_import'})
 
+            if auto_import:
+                return processed_lines, rejected_lines, headers
+
             view_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'msf_homere_interface', 'payroll_import_confirmation')
             view_id = view_id and view_id[1] or False
 

=== modified file 'bin/addons/msf_tools/__init__.py'
--- bin/addons/msf_tools/__init__.py	2012-04-04 07:07:34 +0000
+++ bin/addons/msf_tools/__init__.py	2016-05-26 09:26:36 +0000
@@ -15,8 +15,11 @@
 #    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/>.
+#    along with this progrimport automated_import_job_progressam.  If not, see <http://www.gnu.org/licenses/>.
 #
 ##############################################################################
 
 import msf_tools
+import automated_import_function
+import automated_import
+import automated_import_job

=== modified file 'bin/addons/msf_tools/__openerp__.py'
--- bin/addons/msf_tools/__openerp__.py	2013-03-18 16:15:46 +0000
+++ bin/addons/msf_tools/__openerp__.py	2016-05-26 09:26:36 +0000
@@ -24,6 +24,7 @@
     "version": "1.0",
     "depends": ["base",
                 "product",
+                "object_query",
                 ],
     "author": "MSF, TeMPO Consulting",
     "website": "",
@@ -33,7 +34,13 @@
     """,
     "init_xml": [
     ],
-    'update_xml': ['security/ir.model.access.csv',],
+    'update_xml': [
+        'views/automated_import_view.xml',
+        'views/automated_import_function_view.xml',
+        'views/automated_import_job_view.xml',
+        'security/ir.model.access.csv',
+        'automated_import_data.xml',
+    ],
     'demo_xml': [
     ],
     'test': [# tests should be performed in base classes to avoid cyclic dependencies

=== added file 'bin/addons/msf_tools/automated_import.py'
--- bin/addons/msf_tools/automated_import.py	1970-01-01 00:00:00 +0000
+++ bin/addons/msf_tools/automated_import.py	2016-05-26 09:26:36 +0000
@@ -0,0 +1,443 @@
+# -*- coding: utf-8 -*-
+##############################################################################
+#
+#    OpenERP, Open Source Management Solution
+#    Copyright (C) 2016 TeMPO Consulting, MSF
+#
+#    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 os
+import time
+
+from osv import osv
+from osv import fields
+
+from tools.translate import _
+
+
+class automated_import(osv.osv):
+    _name = 'automated.import'
+
+    def _check_paths(self, cr, uid, ids, context=None):
+        """
+        Check if given paths are accessible and make checks that src path is not same path as report or dest path.
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls the method
+        :param ids: List of ID of automated.import on which checks are made
+        :param context: Context of the call
+        :return: Return True or raise an error
+        """
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        for imp_brw in self.browse(cr, uid, ids, context=context):
+            for path in [('src_path', 'r'), ('dest_path', 'w'), ('report_path', 'w')]:
+                if imp_brw[path[0]]:
+                    self.path_is_accessible(imp_brw[path[0]], path[1])
+
+            if imp_brw.src_path:
+                if imp_brw.src_path == imp_brw.dest_path:
+                    raise osv.except_osv(
+                        _('Error'),
+                        _('You cannot have same directory for \'Source Path\' and \'Destination Path\''),
+                    )
+                if imp_brw.src_path == imp_brw.report_path:
+                    raise osv.except_osv(
+                        _('Error'),
+                        _('You cannot have same directory for \'Source Path\' and \'Report Path\''),
+                    )
+            if imp_brw.active and not (imp_brw.src_path and imp_brw.dest_path and imp_brw.report_path):
+                raise osv.except_osv(
+                    _('Error'),
+                    _('Before activation, the different paths should be set.')
+                )
+
+        return True
+
+    _columns = {
+        'name': fields.char(
+            size=128,
+            string='Name',
+            required=True,
+        ),
+        'src_path': fields.char(
+            size=512,
+            string='Source Path',
+        ),
+        'dest_path': fields.char(
+            size=512,
+            string='Destination Path',
+        ),
+        'report_path': fields.char(
+            size=512,
+            string='Report Path',
+        ),
+        'start_time': fields.datetime(
+            string='Date and time of first planned execution',
+        ),
+        'interval': fields.integer(
+            string='Interval number',
+        ),
+        'interval_unit': fields.selection(
+            selection=[
+                ('minutes', 'Minutes'),
+                ('hours', 'Hours'),
+                ('work_days', 'Work Days'),
+                ('days', 'Days'),
+                ('weeks', 'Weeks'),
+               ('months', 'Months'),
+            ],
+            string='Interval Unit',
+        ),
+        'function_id': fields.many2one(
+            'automated.import.function',
+            string='Functionality',
+            required=True,
+        ),
+        'active': fields.boolean(
+            string='Active',
+            readonly=True,
+        ),
+        'cron_id': fields.many2one(
+            'ir.cron',
+            string='Associated cron job',
+            readonly=True,
+        ),
+        'priority': fields.integer(
+            string='Priority',
+            required=True,
+            help="""Defines the priority of the automated import processing because some of them needs other data
+to import well some data (e.g: Product Categories needs Product nomenclatures)."""
+        ),
+    }
+
+    _defaults = {
+        'interval': lambda *a: 1,
+        'interval_unit': lambda *a: 'hours',
+        'active': lambda *a: False,
+        'priority': lambda *a: 10,
+    }
+
+    _sql_constraints = [
+        (
+            'import_name_uniq',
+            'unique(name)',
+            _('Another Automated import with same name already exists (maybe inactive). Automated import name must be unique. Please select an other name.'),
+        ),
+        (
+            'import_function_id_uniq',
+            'unique(function_id)',
+            _('Another Automated import with same functionality already exists (maybe inactive). Only one automated import must be created for a '\
+              'same functionality. Please select an other functionality.'),
+        ),
+        (
+            'import_positive_interval',
+            'CHECK(interval >= 0)',
+            _('Interval number cannot be negative !'),
+        ),
+    ]
+
+    _constraints = [
+        (_check_paths, _('There is a problem with paths'), ['active', 'src_path', 'dest_path', 'report_path']),
+    ]
+
+    def job_in_progress(self, cr, uid, ids, context=None):
+        """
+        Check if there is job in progress for this automated import.
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls the method
+        :param ids: List of ID of automated.import on which the test is made
+        :param context: Context of the call
+        :return: Return True if there are jobs in progress
+        """
+        job_progress_obj = self.pool.get('automated.import.job.progress')
+
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        # Use uid=1 to avoid return of only osv.memory that belongs to the current user
+        return job_progress_obj.search(cr, 1, [('import_id', 'in', ids)], limit=1, context=context)
+
+    def path_is_accessible(self, path, mode='r'):
+        """
+        Returns if the given path is accessible in the given mode
+        :param path: Local path to test
+        :param mode: Mode to test (can be 'r' for read, 'w' for write)
+        :return: True if the path is accessible or the error if not
+        """
+        msg = None
+        if not os.access(path, os.F_OK):
+            msg = _('Path \'%s\' doesn\'t exist!') % path
+        elif 'r' in mode and not os.access(path, os.R_OK):
+            msg =  _('Read is not allowed on \'%s\'!') % path
+        elif 'w' in mode and not os.access(path, os.W_OK):
+            msg = _('Write is not allowed on \'%s\'!') % path
+
+        if msg:
+            raise osv.except_osv(_('Error'), msg)
+
+        return True
+
+    def run_job_manually(self, cr, uid, ids, context=None, params=None):
+        """
+        Create a new job with automated import parameters and display a view
+        to add a file to import. Then, run it if user clicks on Run or delete
+        it if user clicks on Cancel
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of ID of automated.import that must be ran
+        :param context: Context of the call
+        :param params: Manual parameters in case of manual customized run
+        :return: An action to go to the view of automated.import.job to add a file to import
+        """
+        job_obj = self.pool.get('automated.import.job')
+        data_obj = self.pool.get('ir.model.data')
+
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        if params is None:
+            params = {}
+
+        for import_brw in self.browse(cr, uid, ids, context=context):
+            if not import_brw.src_path or not import_brw.dest_path or not import_brw.report_path:
+                raise osv.except_osv(
+                    _('Error'),
+                    _('You should define all paths before run manually this job !'),
+                )
+            params = {
+                'import_id': import_brw.id,
+                'state': 'draft',
+            }
+            job_id = job_obj.create(cr, uid, params, context=context)
+
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': job_obj._name,
+            'res_id': job_id,
+            'view_type': 'form',
+            'view_mode': 'form',
+            'view_id': [data_obj.get_object_reference(cr, uid, 'msf_tools', 'automated_import_job_file_view')[1]],
+            'target': 'new',
+            'context': context,
+        }
+
+
+    def run_job(self, cr, uid, ids, context=None, params=None):
+        """
+        Create a new job with automated import parameters and run it
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of ID of automated.import that must be ran
+        :param context: Context of the call
+        :param params: Manual parameters in case of manual customized run
+        :return: An action to go to the view of automated.import.job
+        """
+        job_obj = self.pool.get('automated.import.job')
+
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        if params is None:
+            params = {}
+
+        for import_id in ids:
+            params = {
+                'import_id': import_id,
+                'state': 'in_progress',
+            }
+            job_id = job_obj.create(cr, uid, params, context=context)
+            cr.commit()
+            res = job_obj.process_import(cr, uid, [job_id], context=context)
+            cr.commit()
+
+        return res
+
+    def _generate_ir_cron(self, import_brw):
+        """
+        Returns the values for the ir.cron to create according to automated.import values
+        :param import_brw: automated.import browse_record
+        :return: A dictionary with values for ir.cron
+        """
+        # If no interval defined, stop the scheduled action
+        numbercall = -1
+        if not import_brw.interval:
+            numbercall = 0
+
+        return {
+            'name': _('[Automated import] %s') % import_brw.name,
+            'user_id': 1,
+            'active': import_brw.active,
+            'interval_number': import_brw.interval,
+            'interval_type': import_brw.interval_unit,
+            'numbercall': numbercall,
+            'nextcall': import_brw.start_time or time.strftime('%Y-%m-%d %H:%M:%S'),
+            'model': self._name,
+            'function': 'run_job',
+            'args': '(%s,)' % import_brw.id,
+            'priority': import_brw.priority,
+        }
+
+    def create(self, cr, uid, vals, context=None):
+        """
+        Create the automated.import record.
+        Make some checks (uniqueness of name, uniqueness of functionality...)
+        Create an ir_cron record and linked it to the new automated.import
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls the method
+        :param vals: Values for the new automated.import record
+        :param context: Context of the call
+        :return: The ID of the new automated.import created record
+        """
+        cron_obj = self.pool.get('ir.cron')
+
+        if context is None:
+            context = {}
+
+        # Call the super create
+        new_id = super(automated_import, self).create(cr, uid, vals, context=context)
+
+        # Generate new ir.cron
+        import_brw = self.browse(cr, uid, new_id, context=context)
+        cron_id = cron_obj.create(cr, uid, self._generate_ir_cron(import_brw), context=context)
+        self.write(cr, uid, [new_id], {'cron_id': cron_id}, context=context)
+
+        return new_id
+
+    def write(self, cr, uid, ids, vals, context=None):
+        """
+        Make some checks on new values (uniqueness of name, uniqueness of functionality...)
+        Update the ir_cron
+        Write new values on existing automated.import records
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls the method
+        :param ids: List of ID of automated.import records to write
+        :param vals: Values for the new automated.import record
+        :param context: Context of the call
+        :return: True
+        """
+        cron_obj = self.pool.get('ir.cron')
+
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        res = super(automated_import, self).write(cr, uid, ids, vals, context=context)
+
+        for import_brw in self.browse(cr, uid, ids, context=context):
+            cron_vals = self._generate_ir_cron(import_brw)
+            if import_brw.cron_id:
+                cron_obj.write(cr, uid, [import_brw.cron_id.id], cron_vals, context=context)
+            elif not vals.get('cron_id', False):
+                cron_id = cron_obj.create(cr, uid, cron_vals, context=context)
+                self.write(cr, uid, [import_brw.id], {'cron_id': cron_id}, context=context)
+
+        return res
+
+    def unlink(self, cr, uid, ids, context=None):
+        """
+        Delete the associated ir_cron
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of automated.import ID to remove
+        :param context: Context of the call
+        :return: True
+        """
+        cron_obj = self.pool.get('ir.cron')
+        job_obj = self.pool.get('automated.import.job')
+
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        if job_obj.search(cr, uid, [('import_id', 'in', ids)], limit=1, order='NO_ORDER', context=context):
+            raise osv.except_osv(
+                _('Error'),
+                _('Please delete the automated import jobs that are linked to the Automatic import you try to delete!'),
+            )
+
+        for import_brw in self.browse(cr, uid, ids, context=context):
+            if import_brw.cron_id:
+                cron_obj.unlink(cr, uid, [import_brw.cron_id.id], context=context)
+
+        return super(automated_import, self).unlink(cr, uid, ids, context=context)
+
+    def copy(self, cr, uid, import_id, new_vals=None, context=None):
+        """
+        Display an error on copy as copy is not allowed on automated.import
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param import_id: ID of the automated.import to copy
+        :param new_vals: Default values for the new automated.import record
+        :param context: Context of the call
+        :return: The ID of the new automated.import record
+        """
+        raise osv.except_osv(
+            _('Error'),
+            _('Copy is not allowed for Automated imports!'),
+        )
+
+    def active_import(self, cr, uid, ids, context=None):
+        """
+        Make the automated.import as active
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of ID of automated.import to activate
+        :param context: Context of the call
+        :return: True
+        """
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        return self.write(cr, uid, ids, {'active': True}, context=context)
+
+    def deactive_import(self, cr, uid, ids, context=None):
+        """
+        Make the automated.import as inactive
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of ID of automated.import to activate
+        :param context: Context of the call
+        :return: True
+        """
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        return self.write(cr, uid, ids, {'active': False}, context=context)
+
+automated_import()

=== added file 'bin/addons/msf_tools/automated_import_data.xml'
--- bin/addons/msf_tools/automated_import_data.xml	1970-01-01 00:00:00 +0000
+++ bin/addons/msf_tools/automated_import_data.xml	2016-05-26 09:26:36 +0000
@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<openerp>
+    <data>
+
+        <record id="auto_import_fnct_res_partner" model="automated.import.function">
+            <field name="name">Import Suppliers</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'res.partner')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_account_account" model="automated.import.function">
+            <field name="name">Import G/L Accounts</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'account.account')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_account_journal" model="automated.import.function">
+            <field name="name">Import G/L Journals</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'account.journal')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_analytic_account" model="automated.import.function">
+            <field name="name">Import Analytic Accounts</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'account.analytic.account')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_analytic_journal" model="automated.import.function">
+            <field name="name">Import Analytic Journals</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'account.analytic.journal')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_destination_account" model="automated.import.function">
+            <field name="name">Import Links between destinations and GL accounts</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'account.analytic.account')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_sync_product_nomenclature" model="automated.import.function">
+            <field name="name">Import Product Nomenclatures</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'product.nomenclature')]" />
+            <field name="method_to_call">import_data_with_wizard</field>
+        </record>
+
+        <record id="auto_import_fnct_product_categories" model="automated.import.function">
+            <field name="name">Import Product Categories</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'product.category')]" />
+            <field name="method_to_call">import_data_with_wizard</field>
+        </record>
+
+        <record id="auto_import_fnct_employee" model="automated.import.function">
+            <field name="name">Import Employees</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'hr.employee')]" />
+            <field name="method_to_call">auto_import</field>
+        </record>
+
+        <record id="auto_import_fnct_product" model="automated.import.function">
+            <field name="name">Import Products</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'product.product')]" />
+            <field name="method_to_call">import_data_with_wizard</field>
+        </record>
+
+        <record id="auto_import_fnct_access_control_list" model="automated.import.function">
+            <field name="name">Import Access Control Lists</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'ir.model.access')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_record_rules" model="automated.import.function">
+            <field name="name">Import Record Rules</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'ir.rule')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_window_actions" model="automated.import.function">
+            <field name="name">Import Window Actions</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'ir.actions.act_window')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_field_access_rule" model="automated.import.function">
+            <field name="name">Import Field Access Rules</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'msf_field_access_rights.field_access_rule')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_field_access_rule_lines" model="automated.import.function">
+            <field name="name">Import Field Access Rule Lines</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'msf_field_access_rights.field_access_rule_line')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_button_access_rules" model="automated.import.function">
+            <field name="name">Import Button Access Rules</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'msf_button_access_rights.button_access_rule')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+    </data>
+</openerp>

=== added file 'bin/addons/msf_tools/automated_import_function.py'
--- bin/addons/msf_tools/automated_import_function.py	1970-01-01 00:00:00 +0000
+++ bin/addons/msf_tools/automated_import_function.py	2016-05-26 09:26:36 +0000
@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+##############################################################################
+#
+#    OpenERP, Open Source Management Solution
+#    Copyright (C) 2016 TeMPO Consulting, MSF
+#
+#    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/>.
+#
+##############################################################################
+
+from osv import osv
+from osv import fields
+
+from tools.translate import _
+
+
+class automated_import_function(osv.osv):
+    _name = 'automated.import.function'
+
+    _columns = {
+        'name': fields.char(
+            size=64,
+            string='Name',
+            required=True,
+        ),
+        'model_id': fields.many2one(
+            'ir.model',
+            string='Model',
+            required=True,
+        ),
+        'method_to_call': fields.char(
+            size=128,
+            string='Method to call',
+            required=True,
+        ),
+    }
+
+    _defaults = {
+        'method_to_call': lambda *a: 'import_data_from_csv',
+    }
+
+    def check_method_to_call(self, cr, uid, model_id, method):
+        """
+        Check if the model implements the method
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls the method
+        :param model: ID of ir.model
+        :param method: method name
+        :return: Return True or False
+        """
+        model = self.pool.get('ir.model').browse(cr, uid, model_id)
+        if not hasattr(self.pool.get(model.model), method):
+            raise osv.except_osv(
+                _('Error'),
+                _('The method \'%s\' of the model \'%s\' is not callable') % (model.model, method),
+            )
+        return True
+
+    def create(self, cr, uid, vals, context=None):
+        """
+        Run the check on method to call before create the new record
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param vals: Values to put on the new record
+        :param context: Context of the call
+        :return: ID of the new automated.import.function
+        """
+        if vals.get('model_id') and vals.get('method_to_call'):
+            self.check_method_to_call(cr, uid, vals.get('model_id'), vals.get('method_to_call'))
+
+        return super(automated_import_function, self).create(cr, uid, vals, context=context)
+
+    def write(self, cr, uid, ids, vals, context=None):
+        """
+        Run the check on method to call before update the record(s)
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of ID of automated.import.function record to update
+        :param vals: Values to put on the new record
+        :param context: Context of the call
+        :return: True
+        """
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        if vals.get('model_id') and vals.get('method_to_call'):
+            self.check_method_to_call(cr, uid, vals.get('model_id'), vals.get('method_to_call'))
+        elif vals.get('model_id') or vals.get('method_to_call'):
+            for rec in self.browse(cr, uid, ids, context=context):
+                model = vals.get('model_id', rec.model_id)
+                func = vals.get('method_to_call', rec.method_to_call)
+                self.check_method_to_call(cr, uid, model, func)
+
+        return super(automated_import_function, self).write(cr, uid, ids, vals, context=context)
+
+automated_import_function()
\ No newline at end of file

=== added file 'bin/addons/msf_tools/automated_import_job.py'
--- bin/addons/msf_tools/automated_import_job.py	1970-01-01 00:00:00 +0000
+++ bin/addons/msf_tools/automated_import_job.py	2016-05-26 09:26:36 +0000
@@ -0,0 +1,366 @@
+# -*- coding: utf-8 -*-
+##############################################################################
+#
+#    OpenERP, Open Source Management Solution
+#    Copyright (C) 2016 TeMPO Consulting, MSF
+#
+#    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 os
+import csv
+import time
+import shutil
+import base64
+import hashlib
+
+from osv import osv
+from osv import fields
+
+from tools.translate import _
+
+
+def all_files_under(path):
+    """
+    Iterates through all files that are under the given path.
+    :param path: Path on which we want to iterate
+    """
+    for cur_path, dirnames, filenames in os.walk(path):
+        for filename in filenames:
+            yield os.path.join(cur_path, filename)
+
+
+def move_to_process_path(file, src_path, dest_path):
+    """
+    Move the file `file` from `src_path` to `dest_path`
+    :param file: Name of the file to move
+    :param src_path: Source folder
+    :param dest_path: Destination folder
+    :return: return True
+    """
+    srcname = os.path.join(src_path, file)
+    renamed = os.path.join(dest_path, '%s_%s' % (time.strftime('%Y%m%d_%H%M%S'), file))
+    shutil.move(srcname, renamed)
+    return True
+
+
+class automated_import_job(osv.osv):
+    _name = 'automated.import.job'
+
+    def _get_name(self, cr, uid, ids, field_name, args, context=None):
+        """
+        Build the name of the job by using the function_id and the date and time
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this issue
+        :param ids: List of ID of automated.import.job to compute name
+        :param field_name: The name of the field to compute (here: name)
+        :param args: Additional parameters
+        :param context: Context of the call
+        :return: A dictionnary with automated.import.job ID as key and computed name as value
+        """
+        if context is None:
+            context = {}
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        res = {}
+        for job in self.browse(cr, uid, ids, context=context):
+            res[job.id] = '%s - %s' % (job.import_id.function_id.name, job.start_time or _('Not started'))
+
+        return res
+
+    _columns = {
+        'name': fields.function(
+            _get_name,
+            method=True,
+            type='char',
+            size=128,
+            string='Name',
+            store=True,
+        ),
+        'import_id': fields.many2one(
+            'automated.import',
+            string='Automated import',
+            required=True,
+            readonly=True,
+        ),
+        'file_to_import': fields.binary(
+            string='File to import',
+        ),
+        'filename': fields.char(
+            size=128,
+            string='Name of the file to import',
+        ),
+        'file_sum': fields.char(
+            string='Check sum',
+            size=256,
+            readonly=True,
+        ),
+        'start_time': fields.datetime(
+            string='Start time',
+            readonly=True,
+        ),
+        'end_time': fields.datetime(
+            string='End time',
+            readonly=True,
+        ),
+        'nb_processed_records': fields.integer(
+            string='# of processed records',
+            readonly=True,
+        ),
+        'nb_rejected_records': fields.integer(
+            string='# of rejected records',
+            readonly=True,
+        ),
+        'comment': fields.text(
+            string='Comment',
+            readonly=True,
+        ),
+        'state': fields.selection(
+            selection=[
+                ('draft', 'Draft'),
+                ('in_progress', 'In progress'),
+                ('done', 'Done'),
+                ('error', 'Exception'),
+            ],
+            string='State',
+            readonly=True,
+            required=True,
+        ),
+    }
+
+    _defaults = {
+        'state': lambda *a: 'draft',
+    }
+
+    def process_import(self, cr, uid, ids, context=None):
+        """
+        First, browse the source path, then select the oldest file and run import on this file.
+        After the processing of import, generate a report and move the processed file to the
+        processed folder.
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of ID of automated.import.job to process
+        :param context: Context of the call
+        :return: True
+        """
+        import_obj = self.pool.get('automated.import')
+        data_obj = self.pool.get('ir.model.data')
+
+        if context is None:
+            context = []
+
+        if isinstance(ids, (int, long)):
+            ids = [ids]
+
+        for job in self.browse(cr, uid, ids, context=context):
+            nb_rejected = 0
+            nb_processed = 0
+            start_time = time.strftime('%Y-%m-%d %H:%M:%S')
+            no_file = False
+            md5 = False
+            error = None
+            data64 = None
+            filename = False
+
+            try:
+                for path in [('src_path', 'r'), ('dest_path', 'w'), ('report_path', 'w')]:
+                    import_obj.path_is_accessible(job.import_id[path[0]], path[1])
+            except osv.except_osv as e:
+                error = str(e)
+                # In case of manual processing, raise the error
+                if job.file_to_import:
+                    raise e
+
+            if not job.file_to_import:
+                try:
+                    oldest_file = min(all_files_under(job.import_id.src_path), key=os.path.getmtime)
+                    filename = os.path.split(oldest_file)[1]
+                    md5 = hashlib.md5(open(oldest_file).read()).hexdigest()
+                    data64 = base64.encodestring(open(oldest_file).read())
+                except ValueError:
+                    no_file = True
+
+                if not error:
+                    if no_file:
+                        error = _('No file to import in %s !') % job.import_id.src_path
+                    elif md5 and self.search(cr, uid, [('import_id', '=', job.import_id.id), ('file_sum', '=', md5)], limit=1, order='NO_ORDER', context=context):
+                        error = _('A file with same checksum has been already imported !')
+                        move_to_process_path(filename, job.import_id.src_path, job.import_id.dest_path)
+
+                if error:
+                    self.write(cr, uid, [job.id], {
+                        'filename': filename,
+                        'file_to_import': data64,
+                        'start_time': start_time,
+                        'end_time': time.strftime('%Y-%m-%d'),
+                        'nb_processed_records': 0,
+                        'nb_rejected_records': 0,
+                        'comment': error,
+                        'file_sum': md5,
+                        'state': 'error',
+                    }, context=context)
+                    continue
+            else:
+                oldest_file = open(os.path.join(job.import_id.src_path, job.filename), 'wb+')
+                oldest_file.write(base64.decodestring(job.file_to_import))
+                oldest_file.close()
+                md5 = hashlib.md5(job.file_to_import).hexdigest()
+
+                if job.file_sum != md5:
+                    if self.search(cr, uid, [('file_sum', '=', md5), ('id', '!=', job.id)], limit=1, order='NO_ORDER', context=context):
+                        self.write(cr, uid, [job.id], {'file_sum': md5}, context=context)
+                        return {
+                            'type': 'ir.actions.act_window',
+                            'res_model': self._name,
+                            'res_id': ids[0],
+                            'view_type': 'form',
+                            'view_mode': 'form,tree',
+                            'target': 'new',
+                            'view_id': [data_obj.get_object_reference(cr, uid, 'msf_tools', 'automated_import_job_file_view')[1]],
+                            'context': context,
+                        }
+
+                oldest_file = os.path.join(job.import_id.src_path, job.filename)
+                filename = job.filename
+                data64 = base64.encodestring(job.file_to_import)
+
+            # Process import
+            try:
+                processed, rejected, headers = getattr(
+                    self.pool.get(job.import_id.function_id.model_id.model),
+                    job.import_id.function_id.method_to_call
+                )(cr, uid, oldest_file)
+                if processed:
+                    nb_processed = self.generate_file_report(cr, uid, job, processed, headers)
+
+                if rejected:
+                    nb_rejected = self.generate_file_report(cr, uid, job, rejected, headers, rejected=True)
+
+                self.write(cr, uid, [job.id], {
+                    'filename': filename,
+                    'start_time': start_time,
+                    'end_time': time.strftime('%Y-%m-%d %H:%M:%S'),
+                    'nb_processed_records': nb_processed,
+                    'nb_rejected_records': nb_rejected,
+                    'file_sum': md5,
+                    'file_to_import': data64,
+                    'state': 'done',
+                }, context=context)
+            except Exception as e:
+                self.write(cr, uid, [job.id], {
+                    'filename': False,
+                    'start_time': start_time,
+                    'end_time': time.strftime('%Y-%m-%d'),
+                    'nb_processed_records': 0,
+                    'nb_rejected_records': 0,
+                    'comment': str(e),
+                    'file_sum': md5,
+                    'file_to_import': data64,
+                    'state': 'error',
+                }, context=context)
+            finally:
+                move_to_process_path(filename, job.import_id.src_path, job.import_id.dest_path)
+
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': self._name,
+            'res_id': ids[0],
+            'view_type': 'form',
+            'view_mode': 'form,tree',
+            'target': 'current',
+            'context': context,
+        }
+
+
+    def generate_file_report(self, cr, uid, job_brw, data_lines, headers, rejected=False):
+        """
+        Create a csv file that contains the processed lines and put this csv file
+        on the report_path directory and attach it to the automated.import.job.
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param job_brw: browse_record of the automated.import.job that need a report
+        :param data_lines: List of tuple containing the line index and the line data
+        :param headers: List of field names in the file
+        :param rejected: If true, the data_lines tuple is composed of 3 members, else, composed of 2 members
+        :return: # of lines in file
+        """
+        att_obj = self.pool.get('ir.attachment')
+
+        filename = '%s_%s_%s.csv' % (
+            time.strftime('%Y%m%d_%H%M%S'),
+            job_brw.import_id.function_id.model_id.model,
+            rejected and 'rejected' or 'processed'
+        )
+        pth_filename = os.path.join(job_brw.import_id.report_path, filename)
+        delimiter = ','
+        quotechar = '"'
+
+        with open(pth_filename, 'wb') as csvfile:
+            spamwriter = csv.writer(csvfile, delimiter=delimiter, quotechar=quotechar, quoting=csv.QUOTE_MINIMAL)
+            headers_row = [_('Line number')] + headers
+            if rejected:
+                headers_row += [_('Error')]
+            spamwriter.writerow(headers_row)
+            for pl in data_lines:
+                pl_row = [pl[0]] + pl[1]
+                if rejected:
+                    pl_row += [pl[2]]
+                spamwriter.writerow(pl_row)
+
+        csvfile = open(pth_filename, 'r')
+        att_obj.create(cr, uid, {
+            'name': filename,
+            'datas_fname': filename,
+            'description': '%s Lines' % (rejected and _('Rejected') or _('Processed')),
+            'res_model': 'automated.import.job',
+            'res_id': job_brw.id,
+            'datas': base64.encodestring(csvfile.read())
+        })
+
+        return len(data_lines)
+
+    def cancel_file_import(self, cr, uid, ids, context=None):
+        """
+        Delete the automated.import.job and close the wizard.
+        :param cr: Cursor to the database
+        :param uid: ID of the res.users that calls this method
+        :param ids: List of automated.import.job to delete
+        :param context: Context of the call
+        :return: The action to close the wizard
+        """
+        self.unlink(cr, uid, ids, context=context)
+        return {'type': 'ir.actions.act_window_close'}
+
+automated_import_job()
+
+
+class automated_import_job_progress(osv.osv_memory):
+    _name = 'automated.import.job.progress'
+
+    _columns = {
+        'job_id': fields.many2one(
+            'automated.import.job',
+            string='Import job',
+            required=True,
+        ),
+        'import_id': fields.related(
+            'automated.import',
+            string='Import',
+        ),
+    }
+
+automated_import_job_progress()

=== modified file 'bin/addons/msf_tools/msf_tools.py'
--- bin/addons/msf_tools/msf_tools.py	2016-04-11 08:10:35 +0000
+++ bin/addons/msf_tools/msf_tools.py	2016-05-26 09:26:36 +0000
@@ -624,10 +624,7 @@
         tr_split = name.split(',')
         res_id = self.pool.get('ir.model.data').find_sd_ref(cr, 1, sdref, field='res_id', context=context)
         if res_id and tr_split[0] == 'product.template':
-            prod = self.pool.get('product.product').read(cr, 1, [res_id], ['product_tmpl_id'], context=context)
-            if not prod:
-                return False
-            prod = prod[0]
+            prod = self.pool.get('product.product').read(cr, 1, [res_id], ['product_tmpl_id'], context=context)[0]
             if prod['product_tmpl_id']:
                 return prod['product_tmpl_id'][0]
         return res_id

=== added directory 'bin/addons/msf_tools/views'
=== added file 'bin/addons/msf_tools/views/automated_import_function_view.xml'
--- bin/addons/msf_tools/views/automated_import_function_view.xml	1970-01-01 00:00:00 +0000
+++ bin/addons/msf_tools/views/automated_import_function_view.xml	2016-05-26 09:26:36 +0000
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<openerp>
+    <data>
+
+        <record id="automated_import_function_search_view" model="ir.ui.view">
+            <field name="name">automated.import.function.search.view</field>
+            <field name="model">automated.import.function</field>
+            <field name="type">search</field>
+            <field name="arch" type="xml">
+                <search string="Automated import functions">
+                    <field name="name" />
+                    <field name="model_id" />
+                    <field name="method_to_call" />
+                </search>
+            </field>
+        </record>
+
+        <record id="automated_import_function_tree_view" model="ir.ui.view">
+            <field name="name">automated.import.function.tree.view</field>
+            <field name="model">automated.import.function</field>
+            <field name="type">tree</field>
+            <field name="arch" type="xml">
+                <tree string="Automated import functions">
+                    <field name="name" />
+                    <field name="model_id" />
+                    <field name="method_to_call" />
+                </tree>
+            </field>
+        </record>
+
+        <record id="automated_import_function_form_view" model="ir.ui.view">
+            <field name="name">automated.import.function.form.view</field>
+            <field name="model">automated.import.function</field>
+            <field name="type">form</field>
+            <field name="arch" type="xml">
+                <form string="Automated import function">
+                    <field name="name" />
+                    <newline />
+                    <field name="model_id" />
+                    <field name="method_to_call" />
+                </form>
+            </field>
+        </record>
+
+        <record id="automated_import_function_action" model="ir.actions.act_window">
+            <field name="name">Automated import functions</field>
+            <field name="res_model">automated.import.function</field>
+            <field name="view_type">form</field>
+            <field name="view_mode">tree,form</field>
+        </record>
+
+        <menuitem
+            id="automated_import_function_menu"
+            action="automated_import_function_action"
+            parent="automated_import_menu" />
+
+    </data>
+</openerp>
\ No newline at end of file

=== added file 'bin/addons/msf_tools/views/automated_import_job_view.xml'
--- bin/addons/msf_tools/views/automated_import_job_view.xml	1970-01-01 00:00:00 +0000
+++ bin/addons/msf_tools/views/automated_import_job_view.xml	2016-05-26 09:26:36 +0000
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<openerp>
+    <data>
+
+        <record id="automated_import_job_search_view" model="ir.ui.view">
+            <field name="name">automated.import.job.search.view</field>
+            <field name="model">automated.import.job</field>
+            <field name="type">search</field>
+            <field name="arch" type="xml">
+                <search string="Import job requests">
+                    <filter icon="terp-document-new" string="Draft" name="draft" domain="[('state', '=', 'draft')]" help="Draft jobs" /> 
+                    <filter icon="terp-gnome-cpu-frequency-applet+" string="In progress" name="in_progress" domain="[('state', '=', 'in_progress')]" help="In progress jobs" /> 
+                    <filter icon="terp-dialog-close" string="Done" name="done" domain="[('state', '=', 'done')]" help="Done jobs" /> 
+                    <filter icon="terp-emblem-important" string="Exception" name="exceptions" domain="[('state', '=', 'error')]" help="Jobs with error" /> 
+                    <separator orientation="vertical" />
+                    <field name="import_id" />
+                    <field name="start_time" />
+                    <field name="end_time" />
+                </search>
+            </field>
+        </record>
+
+        <record id="automated_import_job_tree_view" model="ir.ui.view">
+            <field name="name">automated.import.job.tree.view</field>
+            <field name="model">automated.import.job</field>
+            <field name="type">tree</field>
+            <field name="arch" type="xml">
+                <tree string="Import job reports" noteditable="True" hide_new_button="True">
+                    <field name="import_id" />
+                    <field name="start_time" />
+                    <field name="end_time" />
+                    <field name="state" />
+                </tree>
+            </field>
+        </record>
+
+        <record id="automated_import_job_form_view" model="ir.ui.view">
+            <field name="name">automated.import.job.form.view</field>
+            <field name="model">automated.import.job</field>
+            <field name="type">form</field>
+            <field name="arch" type="xml">
+                <form string="Import job report">
+                    <field name="import_id" />
+                    <field name="start_time" />
+                    <field name="end_time" />
+                    <separator colspan="4" string="Import file" />
+                    <field name="file_to_import" readonly="True" filename="filename" />
+                    <field name="filename" invisible="1" />
+                    <separator colspan="4" string="Import results" />
+                    <field name="nb_processed_records" />
+                    <field name="nb_rejected_records" />
+                    <field name="comment" colspan="4" />
+                    <separator colspan="4" string="States" />
+                    <field name="state" />
+                    <button name="process_import" type="object" states="draft" string="Process import" icon="gtk-execute" />
+                </form>
+            </field>
+        </record>
+
+        <record id="automated_import_job_file_view" model="ir.ui.view">
+            <field name="name">automated.import.job.file.view</field>
+            <field name="model">automated.import.job</field>
+            <field name="type">form</field>
+            <field name="priority" eval="99" />
+            <field name="arch" type="xml">
+                <form string="Automated import job">
+                    <field name="file_sum" invisible="1" />
+                    <separator colspan="4" string="Import file" />
+                    <group colspan="4" attrs="{'invisible': [('file_sum', '!=', False)]}">
+                        <html>
+                            <style>
+                                #explanation_message_unifield div
+                                {
+                                    font-weight: bold;
+                                    font-size: 1.2em;
+                                }
+                            </style>
+                            <div id="explanation_message_unifield">
+                                <label colspan="4" string="If no file is selected, the system will try to get the oldest file in the source path." align="0.0" />
+                            </div>
+                        </html>
+                    </group>
+                    <group colspan="4" attrs="{'invisible': [('file_sum', '=', False)]}">
+                        <html>
+                            <style>
+                                #warning_message_unifield div
+                                {
+                                    font-weight: bold;
+                                    font-size: 1.2em;
+                                    color: red;
+                                }
+                            </style>
+                            <div id="warning_message_unifield">
+                                <label colspan="4" string="The file you selected has already been imported in the past. Are you sure you want to import it ?" align="0.0" />
+                            </div>
+                        </html>
+                    </group>
+                    <field name="file_to_import" filename="filename" />
+                    <field name="filename" invisible="1" />
+                    <separator colspan="4" string="Actions" />
+                    <button name="cancel_file_import" type="object" string="Cancel" icon="gtk-cancel" colspan="2" />
+                    <button name="process_import" type="object" string="Run job" icon="gtk-execute" colspan="2" />
+                </form>
+            </field>
+        </record>
+
+        <record id="automated_import_job_action" model="ir.actions.act_window">
+            <field name="name">Import job reports</field>
+            <field name="res_model">automated.import.job</field>
+            <field name="view_type">form</field>
+            <field name="view_mode">tree,form</field>
+        </record>
+
+        <menuitem
+            id="automated_import_job_menu"
+            action="automated_import_job_action"
+            parent="automated_import_menu" />
+
+    </data>
+</openerp>

=== added file 'bin/addons/msf_tools/views/automated_import_view.xml'
--- bin/addons/msf_tools/views/automated_import_view.xml	1970-01-01 00:00:00 +0000
+++ bin/addons/msf_tools/views/automated_import_view.xml	2016-05-26 09:26:36 +0000
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<openerp>
+    <data>
+
+        <record id="automated_import_search_view" model="ir.ui.view">
+            <field name="name">automated.import.search.view</field>
+            <field name="model">automated.import</field>
+            <field name="type">search</field>
+            <field name="arch" type="xml">
+                <search string="Automated imports">
+                    <filter name="active" domain="[('active', '=', False)]" string="Inactive" icon="gtk-undo" />
+                    <field name="name" />
+                    <field name="function_id" />
+                </search>
+            </field>
+        </record>
+
+        <record id="automated_import_tree_view" model="ir.ui.view">
+            <field name="name">automated.import.tree.view</field>
+            <field name="model">automated.import</field>
+            <field name="type">tree</field>
+            <field name="arch" type="xml">
+                <tree string="Automated imports">
+                    <field name="name" />
+                    <field name="function_id" />
+                    <field name="start_time" />
+                    <field name="interval" />
+                    <field name="interval_unit" />
+                </tree>
+            </field>
+        </record>
+
+        <record id="automated_import_form_view" model="ir.ui.view">
+            <field name="name">automated.import.form.view</field>
+            <field name="model">automated.import</field>
+            <field name="type">form</field>
+            <field name="arch" type="xml">
+                <form string="Automated import">
+                    <separator colspan="4" string="General configuration" />
+                    <field name="name" />
+                    <field name="function_id" widget="selection" />
+                    <field name="active" />
+                    <button name="run_job_manually" string="Run job manually" colspan="2" type="object" icon="gtk-execute" />
+                    <separator colspan="4" string="Paths configuration" />
+                    <field name="src_path" colspan="4" attrs="{'required': [('active', '=', True)]}" />
+                    <field name="dest_path" colspan="4" attrs="{'required': [('active', '=', True)]}" />
+                    <field name="report_path" colspan="4" attrs="{'required': [('active', '=', True)]}" />
+                    <separator colspan="4" string="Scheduler configuration" />
+                    <group colspan="4" col="6">
+                        <field name="priority" />
+                        <field name="interval" attrs="{'required': [('interval_unit', '&gt;', 0)]}" />
+                        <field name="interval_unit" />
+                        <field name="start_time" />
+                    </group>
+                    <separator colspan="4" string="Activation" />
+                    <group colspan="4" col="1">
+                        <button name="active_import" string="Activate" colspan="1" type="object" icon="gtk-execute" attrs="{'invisible': [('active', '=', True)]}" />
+                        <button name="deactive_import" string="De-activate" colspan="1" type="object" icon="gtk-execute" attrs="{'invisible': [('active', '=', False)]}" />
+                    </group>
+                </form>
+            </field>
+        </record>
+
+        <record id="automated_import_action" model="ir.actions.act_window">
+            <field name="name">Automated imports</field>
+            <field name="res_model">automated.import</field>
+            <field name="view_type">form</field>
+            <field name="view_mode">tree,form</field>
+        </record>
+
+        <menuitem
+            id="automated_import_menu"
+            action="automated_import_action"
+            parent="object_query.menu_preferences" />
+
+    </data>
+</openerp>

=== modified file 'bin/addons/sync_server/__openerp__.py'
--- bin/addons/sync_server/__openerp__.py	2015-01-12 10:46:48 +0000
+++ bin/addons/sync_server/__openerp__.py	2016-05-26 09:26:36 +0000
@@ -39,6 +39,7 @@
         'security/ir.model.access.csv',
         'data/cron.xml',
         'data/alert_email.xml',
+        'data/automated_import_sync_groups.xml',
     ],
     'demo_xml': [
     ],

=== added file 'bin/addons/sync_server/data/automated_import_sync_groups.xml'
--- bin/addons/sync_server/data/automated_import_sync_groups.xml	1970-01-01 00:00:00 +0000
+++ bin/addons/sync_server/data/automated_import_sync_groups.xml	2016-05-26 09:26:36 +0000
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<openerp>
+    <data>
+
+        <record id="auto_import_fnct_sync_groups" model="automated.import.function">
+            <field name="name">Import Sync. Groups</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'sync.server.entity_group')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+        <record id="auto_import_fnct_sync_group_type" model="automated.import.function">
+            <field name="name">Import Sync. Group Types</field>
+            <field name="model_id" model="ir.model" search="[('model', '=', 'sync.server.group_type')]" />
+            <field name="method_to_call">import_data_from_csv</field>
+        </record>
+
+    </data>
+</openerp>
\ No newline at end of file

=== modified file 'bin/osv/orm.py' (properties changed: +x to -x)
--- bin/osv/orm.py	2016-04-12 16:43:36 +0000
+++ bin/osv/orm.py	2016-05-26 09:26:36 +0000
@@ -48,6 +48,7 @@
 import time
 import traceback
 import types
+import csv
 
 import netsvc
 from lxml import etree
@@ -745,6 +746,48 @@
             datas += self.__export_row(cr, uid, row, fields_to_export, context)
         return {'datas': datas}
 
+    def import_data_with_wizard(self, cr, uid, csv_file, quotechar="'", delimiter=","):
+        import base64
+
+        import_obj = self.pool.get('import_data')
+        import_id = import_obj.create(cr, uid, {
+            'ignore': 1,
+            'file': base64.encodestring(open(csv_file, 'r').read()),
+            'object': self._name,
+            'import_mode': 'create',
+        })
+        processed, rejected, headers = import_obj._import(cr, uid, import_id, use_new_cursor=False, auto_import=True)
+        return processed, rejected, headers
+
+    def import_data_from_csv(self, cr, uid, csv_file, quotechar='"', delimiter=','):
+        headers = []
+        list_data = []
+        with open(csv_file, 'r') as fcsv:
+            reader = csv.reader(fcsv, quotechar=quotechar, delimiter=delimiter)
+            for row in reader:
+                if not headers:
+                    headers = row
+                else:
+                    list_data.append(row)
+
+        rejected = []
+        processed = []
+        i = 1
+        for d in list_data:
+            i += 1
+            try:
+                res = self.import_data(cr, uid, headers, [d])
+                if res[0] == -1:
+                    rejected.append((i, d, res[2]))
+                else:
+                    processed.append((i, d))
+                cr.commit()
+            except Exception as e:
+                rejected.append((i, d, str(e)))
+                cr.commit()
+
+        return processed, rejected, headers
+
     def import_data(self, cr, uid, fields, datas, mode='init', current_module='', noupdate=False, context=None, filename=None):
         """
         Import given data in given module