├── wizard
    ├── __init__.py
    ├── update_fields.xml
    └── import_wizard.py
├── .gitignore
├── __init__.py
├── models
    ├── payment.py
    ├── invoice.py
    ├── __init__.py
    ├── export_exception.py
    ├── import_exception.py
    ├── package.py
    ├── stock.py
    ├── category.py
    ├── tax.py
    ├── test.php
    ├── procurement.py
    ├── job.py
    ├── delivery.py
    ├── mapping.py
    ├── mage_api.py
    ├── country.py
    ├── defaults.py
    ├── create_mage_order.py
    ├── attribute.py
    ├── partner.py
    ├── mage.py
    └── product.py
├── jobs
    ├── __init__.py
    ├── shipworks.py
    ├── price.py
    ├── .sale.py.swp
    ├── users.py
    ├── category.py
    ├── mass_inventory.py
    ├── invoice.py
    ├── fix_shipments.py
    ├── grouped_relation.py
    ├── links.py
    ├── partner.py
    ├── create_product.py
    ├── backup_package
    ├── stock.py
    ├── metadata.py
    ├── attribute.py
    ├── product.py
    ├── package.py
    └── update_status.py
├── security
    └── mage2odoo_groups.xml
├── data
    └── mage_shipping.xml
├── views
    ├── product_category.xml
    ├── amazon.xml
    ├── stock.xml
    ├── model.xml
    ├── misc.xml
    ├── delivery.xml
    ├── import_exception.xml
    ├── export_exception.xml
    ├── import_export.xml
    ├── jobs.xml
    ├── core.xml
    ├── mapping.xml
    ├── product.xml
    ├── partner.xml
    ├── sites.xml
    ├── attribute.xml
    └── sale.xml
├── __openerp__.py
└── README.md


/wizard/__init__.py:
--------------------------------------------------------------------------------
1 | import import_wizard
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.save
3 | *.tmp
4 | *.DS_Store
5 | 


--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
1 | import models
2 | import wizard
3 | import jobs
4 | 


--------------------------------------------------------------------------------
/models/payment.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | 
 3 | 
 4 | class PaymentMethod(osv.osv):
 5 |     _inherit = 'payment.method'
 6 |     _columns = {
 7 | 	'mage_code': fields.char('Magento Code', select=True),
 8 | 
 9 |     }
10 | 


--------------------------------------------------------------------------------
/models/invoice.py:
--------------------------------------------------------------------------------
1 | from openerp.osv import osv, fields
2 | 
3 | class AccountInvoice(osv.osv):
4 |     _inherit = 'account.invoice'
5 |     _columns = {
6 | 	'mage_export_error': fields.boolean('Magento Export Error', copy=False),
7 | 	'external_id': fields.integer('Magento Invoice ID', copy=False, select=True),
8 |     }
9 | 


--------------------------------------------------------------------------------
/jobs/__init__.py:
--------------------------------------------------------------------------------
 1 | import attribute
 2 | import metadata
 3 | import product
 4 | import category
 5 | import sale
 6 | import invoice
 7 | import package
 8 | import partner
 9 | import links
10 | import grouped_relation
11 | import users
12 | import update_status
13 | import stock
14 | import create_product
15 | import fix_shipments
16 | import mass_inventory
17 | import shipworks
18 | 


--------------------------------------------------------------------------------
/security/mage2odoo_groups.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | <!--    <data noupdate="0"> -->
 4 | 
 5 |     <record id="group_mage2odoo_manager" model="res.groups">
 6 |         <field name="name">Mage2odoo Manager</field>
 7 |         <field name="category_id" ref="base.module_category_warehouse_management"/>
 8 |         <field name="implied_ids" eval="[(4, ref('base.group_user'))]"/>
 9 |     </record>
10 | 
11 |     </data>
12 | </openerp>
13 | 


--------------------------------------------------------------------------------
/models/__init__.py:
--------------------------------------------------------------------------------
 1 | import datamapper
 2 | import attribute
 3 | import product
 4 | import mage
 5 | import job
 6 | import mapping
 7 | import mage_api
 8 | import category
 9 | import sale
10 | import partner
11 | import country
12 | import payment
13 | import delivery
14 | import tax
15 | import invoice
16 | import stock
17 | import procurement
18 | import package
19 | import create_mage_order
20 | import import_exception
21 | import export_exception
22 | 


--------------------------------------------------------------------------------
/data/mage_shipping.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <openerp>
 3 |     <data noupdate="1">
 4 | 
 5 |         <record id="mage_shipping_item" model="product.product">
 6 |             <field name="name">Magento Shipping</field>
 7 | 	    <field name="default_code">mage_shipping</field>
 8 |             <field name="type">service</field>
 9 | 	    <field name="list_price">0.00</field>
10 | 	    <field name="purchase_ok">False</field>
11 |         </record>
12 |     </data>
13 | </openerp>
14 | 


--------------------------------------------------------------------------------
/models/export_exception.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | 
 3 | 
 4 | class MageExportException(osv.osv):
 5 |     _name = 'mage.export.exception'
 6 |     _columns = {
 7 | 	'name': fields.char('Name'),
 8 | 	'type': fields.char('Type'),
 9 | 	'external_id': fields.char('External Id'),
10 | 	'message': fields.text('Message'),
11 | 	'data': fields.text('Data'),
12 | 	'job': fields.many2one('mage.job', 'Job'),
13 |     }
14 | 
15 |     def retry_job_object(self, cr, uid, ids):
16 | 	return True
17 |     
18 | 


--------------------------------------------------------------------------------
/models/import_exception.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | 
 3 | 
 4 | class MageImportException(osv.osv):
 5 |     _name = 'mage.import.exception'
 6 |     _rec_name = 'external_id'
 7 |     _columns = {
 8 | 	'type': fields.char('Type'),
 9 | 	'external_id': fields.char('External Id'),
10 | 	'message': fields.text('Message'),
11 | 	'data': fields.text('Data'),
12 | 	'job': fields.many2one('mage.job', 'Job'),
13 |     }
14 | 
15 |     def retry_job_object(self, cr, uid, ids):
16 | 	return True
17 |     
18 | 


--------------------------------------------------------------------------------
/wizard/update_fields.xml:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 |     <record id="action_sale_order_make_invoice" model="ir.actions.act_window">
 5 | 	<field name="name">Make Invoices</field>
 6 | 	<field name="type">ir.actions.act_window</field>
 7 | 	<field name="res_model">sale.make.invoice</field>
 8 | 	<field name="view_type">form</field>
 9 | 	<field name="view_mode">form</field>
10 | 	<field name="view_id" ref="view_sale_order_make_invoice"/>
11 | 	<field name="target">new</field>
12 | 	<field name="multi">True</field>
13 |     </record>
14 | 


--------------------------------------------------------------------------------
/views/product_category.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 |     <record id="view_mage_product_category_form" model="ir.ui.view">
 4 |         <field name="name">Mage Product Category Form</field>
 5 |         <field name="model">product.category</field>
 6 | 	<field name="inherit_id" ref="product.product_category_form_view" />
 7 |         <field name="arch" type="xml">
 8 | 	    <group name="parent" position="after" >
 9 | 		<newline/>
10 | 		<group string="Magento">
11 | 		    <field name="position" />
12 | 		    <field name="mage_active" />
13 | 	            <field name="external_id" />
14 | 		</group>
15 |             </group>
16 | 	</field>
17 |     </record>
18 | -->
19 |     </data>
20 | </openerp>
21 | 


--------------------------------------------------------------------------------
/views/amazon.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | 	<record id="action_mage_amazon_processs" model="ir.actions.act_window">
 4 | 	    <field name="name">Amazon Orders</field>
 5 | 	    <field name="type">ir.actions.act_window</field>
 6 | 	    <field name="res_model">sale.order</field>
 7 | 	    <field name="view_type">form</field>
 8 | 	    <field name="view_mode">tree,form,calendar,graph</field>
 9 | 	    <field name="domain">[('amazon_process', '=', True)]</field>
10 | 	    <field name="search_view_id" ref="sale.view_sales_order_filter"/>
11 | 	    <field name="context">{}</field>
12 | 	</record>
13 | 
14 |         <menuitem id="menu_mage_amazon_processs"
15 |                 action="action_mage_amazon_processs" parent="base.menu_sales"
16 |                 sequence="10"/>
17 |     </data>
18 | </openerp>
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/jobs/shipworks.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | import pytz
 4 | from datetime import datetime, timedelta
 5 | 
 6 | class MageJob(osv.osv):
 7 |     _inherit = 'mage.job'
 8 | 
 9 | 
10 |     def reset_shipworks_orders(self, cr, uid, job, context=None):
11 |         now = datetime.utcnow()
12 |         central = pytz.timezone('US/Central')
13 |         utc = pytz.timezone('UTC')
14 |         utc_now = utc.localize(now)
15 | #       final_value = utc_now.astimezone(central) - timedelta(hour$
16 |         final_value = utc_now.astimezone(central)
17 |         stamp = final_value.strftime('%Y-%m-%d')
18 | 	query = "UPDATE stock_picking SET sw_exp = False, sw_pre_exp = False WHERE write_date > '%s' OR create_date > '%s'" % (stamp, stamp)
19 | 	cr.execute(query)
20 | 	return True
21 | 


--------------------------------------------------------------------------------
/models/package.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | 
 3 | 
 4 | class StockOutPackage(osv.osv):
 5 |     _inherit = 'stock.out.package'
 6 |     _columns = {
 7 | 	'sale': fields.many2one('sale.order', select=True),
 8 | 	'mage_package_state': fields.selection([('pending', 'Pending'),
 9 | 						('exception', 'Exception'),
10 | 						('done', 'Done')
11 | 	], 'Mage Package State', select=True),
12 |     }
13 | 
14 |     _defaults = {
15 | 	'mage_package_state': 'pending',
16 |     }
17 | 
18 | 
19 |     def create(self, cr, uid, data, context=None):
20 | 	if data.get('picking'):
21 | 	    picking = self.pool.get('stock.picking').browse(cr, uid, data['picking'])
22 | 	    if picking.sale:
23 | 		data['sale'] = picking.sale.id
24 | 
25 |         return super(StockOutPackage, self).create(cr, uid, data, context=context)
26 | 


--------------------------------------------------------------------------------
/models/stock.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | 
 3 | class StockPicking(osv.osv):
 4 |     _inherit = 'stock.picking'
 5 |     _columns = {
 6 | 	'mage_export_error': fields.boolean('Magento Export Error', copy=False),
 7 | 	'external_id': fields.integer('Magento Shipment ID', copy=False, select=True),
 8 |         'sale': fields.many2one('sale.order', 'Sale Order', select=True),
 9 |         'shipping_state': fields.related('partner_id', 'state_id', type='many2one', relation='res.country.state', string='Shipping State'),
10 |         'shipping_city': fields.related('partner_id', 'city', type='char', string='Shipping City'),
11 |         'mage_store': fields.related('sale', 'mage_store', type='many2one', relation='mage.store.view', string='Magento Store'),
12 |     }
13 | 
14 | 
15 | 
16 | class StockMove(osv.osv):
17 |     _inherit = 'stock.move'
18 |     _order = 'date desc'
19 | 


--------------------------------------------------------------------------------
/jobs/price.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | from datetime import datetime
 4 | from tzlocal import get_localzone
 5 | 
 6 | class product_product(osv.osv):
 7 |     _inherit = 'product.product'
 8 |     _columns = {
 9 | 	'tmp_price': fields.float('Temp Price'),
10 |     }
11 | 
12 | class MageIntegrator(osv.osv_memory):
13 | 
14 |     _inherit = 'mage.integrator'
15 | 
16 |     def update_product_cost(self, cr, uid, job, context=None):
17 | 	
18 | 	product_obj = self.pool.get('product.product')
19 | 	product_ids = product_obj.search(cr, uid, [])
20 | 	for product in product_obj.browse(cr, uid, product_ids):
21 | 	    price = product.standard_price
22 | 	    product_obj.write(cr, uid, product.id, {'tmp_price': price})
23 | 	    print 'Updated Price'
24 | 
25 | 
26 | 	cr.execute("UPDATE sale_order_line line SET purchase_price = product.tmp_price FROM product_product product WHERE product.id = line.product_id")
27 | 	cr.commit()
28 | 


--------------------------------------------------------------------------------
/views/stock.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | 
 4 | 	<record id="view_mage_picking_form" model="ir.ui.view">
 5 | 	    <field name="name">Mage Stock Picking Form</field>
 6 | 	    <field name="model">stock.picking</field>
 7 | 	    <field name="inherit_id" ref="stock.view_picking_form" />
 8 | 	    <field name="arch" type="xml">
 9 | 		<field name="date_done" position="replace" />
10 | 		<field name="min_date" position="after" >
11 | 		    <field name="date_done" string="Date Done" />
12 | 		</field>
13 | 		<field name="origin" position="replace" >
14 | 		    <field name="origin" attrs="{'invisible': [('sale', '!=', False)]}" />
15 | 		</field>
16 | 		<field name="backorder_id" position="after" >
17 | 		    <field name="sale" attrs="{'invisible': [('sale', '=', False)]}" readonly="1"/>
18 | 		    <field name="mage_store" attrs="{'invisible': [('mage_store', '=', False)]}" readonly="1" />
19 | 		</field>
20 | 	    </field>
21 | 	</record>
22 | 
23 |     </data>
24 | </openerp>
25 | 


--------------------------------------------------------------------------------
/models/category.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | 
 3 | 
 4 | class ProductCategory(osv.osv):
 5 |     _inherit = 'product.category'
 6 |     _columns = {
 7 | 	'external_id': fields.integer('External Id', select=True, copy=False),
 8 | 	'position': fields.integer('Position'),
 9 | 	'mage_active': fields.boolean('Mage Active'),
10 |     }
11 | 
12 | 
13 |     def get_or_create_odoo_record(self, cr, uid, job, external_id):
14 |         category_id = self.get_mage_record(cr, uid, external_id)
15 |         if not category_id:
16 |             category_id = self.get_and_create_mage_record(cr, uid, job, 'catalog_category.info', external_id)
17 | 
18 |         return self.browse(cr, uid, category_id)
19 | 
20 | 
21 |     def prepare_odoo_record_vals(self, cr, uid, job, record):
22 |         return {
23 |             'name': record['name'],
24 |             'parent_id': self.get_mage_record(cr, uid, record['parent_id']),
25 |             'external_id': record['category_id'],
26 | 
27 |         }
28 | 


--------------------------------------------------------------------------------
/jobs/.sale.py.swp:
--------------------------------------------------------------------------------
1 | b0nano 2.5.3!Irootubuntusale.py


--------------------------------------------------------------------------------
/jobs/users.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | from datetime import datetime
 4 | from tzlocal import get_localzone
 5 | 
 6 | class MageIntegrator(osv.osv_memory):
 7 | 
 8 |     _inherit = 'mage.integrator'
 9 | 
10 |     def sync_admin_users(self, cr, uid, job, context=None):
11 | 	user_obj = self.pool.get('res.users')
12 |         records = self._get_job_data(cr, uid, job, 'oo_websites.users', [])
13 | 	pp(records)
14 | 	for record in records:
15 | 	    vals = self.prepare_user_vals(cr, uid, record)
16 | 	    user_ids = user_obj.search(cr, uid, [('login', '=', record['email'])])
17 | 	    if user_ids:
18 | 		user_obj.write(cr, uid, user_ids[0], vals)
19 | 		print 'Updated User with ID: %s' % vals['external_id']
20 | 	    else:
21 | 		user_obj.create(cr, uid, vals)
22 | 		print 'Created User in Odoo with ID: %s' % vals['external_id']
23 | 
24 |         return True
25 | 
26 | 
27 |     def prepare_user_vals(self, cr, uid, record):
28 | 	vals = {
29 | 		'login': record['email'],
30 | 		'name': ' '.join([record['firstname'], record['lastname']]),
31 | 		'external_id': record['user_id']
32 | 	}
33 | 
34 | 	return vals
35 | 


--------------------------------------------------------------------------------
/views/model.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | 
 4 |         <record id="view_mage_model_tree" model="ir.ui.view">
 5 |             <field name="name">Mage Model Tree</field>
 6 |             <field name="model">ir.model</field>
 7 |             <field name="arch" type="xml">
 8 |                 <tree editable="top">
 9 |                     <field name="name" readonly="1"/>
10 |                     <field name="mage_create_mapping" />
11 | 		    <field name="mage_info_method" />
12 |                 </tree>
13 |             </field>
14 |         </record>
15 | 
16 | 
17 |         <record id="action_mage_model" model="ir.actions.act_window">
18 |             <field name="name">Model Mapping</field>
19 |             <field name="res_model">ir.model</field>
20 |             <field name="type">ir.actions.act_window</field>
21 |             <field name="view_type">form</field>
22 |             <field name="view_id" ref="view_mage_model_tree"/>
23 |         </record>
24 | 
25 |         <menuitem action="action_mage_model"
26 |         id="menu_mage_model"
27 |         parent="menu_mage_configuration"
28 |         sequence="40"/>
29 | 
30 |    </data>
31 | </openerp>
32 | 


--------------------------------------------------------------------------------
/__openerp__.py:
--------------------------------------------------------------------------------
 1 | {
 2 |     'name': 'Mage2Odoo',
 3 |     'version': '1.1',
 4 |     'author': 'Kyle Waid',
 5 |     'category': 'Sales Management',
 6 |     'depends': ['payment_method', 'delivery', 'stock_package', 'product_sku_upc', 'sale_stock', 'asin_label'],
 7 |     'website': 'https://www.gcotech.com',
 8 |     'description': """ 
 9 |     """,
10 |     'data': ['security/mage2odoo_groups.xml',
11 | 	     'views/core.xml',
12 | 	     'views/attribute.xml',
13 | 	     'views/sites.xml',
14 | 	     'views/mapping.xml',
15 | 	     'views/jobs.xml',
16 | 	     'views/product.xml',
17 | 	     'views/import_export.xml',
18 | 	     'views/product_category.xml',
19 | 	     'views/model.xml',
20 | 	     'views/misc.xml',
21 | 	     'views/sale.xml',
22 | 	     'views/stock.xml',
23 | 	     'views/delivery.xml',
24 | 	     'views/partner.xml',
25 | 	     'views/import_exception.xml',
26 | 	     'views/export_exception.xml',
27 | 	     'views/exception.xml',
28 | 	     'views/amazon.xml',
29 | 	     'data/mage_shipping.xml',
30 |     ],
31 |     'test': [
32 |     ],
33 |     'installable': True,
34 |     'auto_install': False,
35 |     'external_dependencies': {
36 | 	'python': ['magento', 'pycountry'],
37 |     },
38 | }
39 | 


--------------------------------------------------------------------------------
/wizard/import_wizard.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from openerp.tools.translate import _
 3 | import cStringIO
 4 | import csv
 5 | import base64
 6 | 
 7 | 
 8 | class MageImportWizard(osv.osv_memory):
 9 |     _name = 'mage.import.wizard'
10 |     _columns = {
11 |         'file': fields.binary('Input File'),
12 |         'file_name': fields.char('File Name', size=64),
13 |     }
14 | 
15 | 
16 |     def import_products(self, cr, uid, ids, context=None):
17 |         wizard = self.browse(cr, uid, ids[0], context=context)
18 |         file = wizard.file
19 |         data = base64.decodestring(file)
20 |         input = cStringIO.StringIO(data)
21 |         reader = csv.DictReader(input, quotechar='"', delimiter=',')
22 |         product_obj = self.pool.get('product.product')
23 |         error_count = 0
24 | 	columns = [
25 | 		'SKU',
26 | 		'NAME',
27 | 		'ATTRIBUTE_SET_ID',
28 | 		'STORE_ID',
29 | 		'TAX_CLASS_ID',
30 | 		'DESCRIPTION',
31 | 		'PRODUCT_TYPE',
32 | 		'CATEGORY_IDS',
33 | 		'WEBSITE_IDS',
34 | 		'WEIGHT',
35 | 		'PRICE'
36 | 	]
37 |         for row in reader:
38 | 	    prepare_product_vals
39 | 
40 | 	return True
41 | 
42 | 
43 | class MageExportWizard(osv.osv_memory):
44 |     _name = 'mage.export.wizard'
45 | 


--------------------------------------------------------------------------------
/jobs/category.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | 
 4 | class MageIntegrator(osv.osv_memory):
 5 | 
 6 |     _inherit = 'mage.integrator'
 7 | 
 8 |     def import_categories(self, cr, uid, job, context=None):
 9 | 	categories = self._get_job_data(cr, uid, job, 'catalog_category.tree', [])
10 | 	cat_obj = self.pool.get('product.category')
11 | 	mappinglines = self._get_mappinglines(cr, uid, job.mapping.id)
12 | 	vals = cat_obj.prepare_odoo_record_vals(cr, uid, job, categories)
13 | #	vals = self._transform_record(cr, uid, job, categories, 'from_mage_to_odoo', mappinglines)
14 | 	del vals['parent_id']
15 | 	result = cat_obj.upsert_mage_record(cr, uid, vals)
16 | 	print result
17 | 	self.process_category_tree(cr, uid, job, mappinglines, categories['children'])
18 | 
19 | 	return True
20 | 
21 | 
22 |     def process_category_tree(self, cr, uid, job, mappinglines, categories, context=None):
23 | 	cat_obj = self.pool.get('product.category')
24 | 	for category in categories:
25 | 	    vals = cat_obj.prepare_odoo_record_vals(cr, uid, job, category)
26 | 	    result = cat_obj.upsert_mage_record(cr, uid, vals)
27 | 	    print result
28 | 	    if category['children']:
29 | 		self.process_category_tree(cr, uid, job, mappinglines, category['children'])
30 | 
31 | 	return True
32 | 
33 | 


--------------------------------------------------------------------------------
/views/misc.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | 
 4 |         <record id="view_mage_order_status_mapping_tree" model="ir.ui.view">
 5 |             <field name="name">Mage Order Status Mapping Tree</field>
 6 |             <field name="model">mage.mapping.order.state</field>
 7 |             <field name="arch" type="xml">
 8 |                 <tree editable="top">
 9 |                     <field name="name" />
10 |                     <field name="mage_order_state" />
11 | 		    <field name="mage_order_status" />
12 | 		    <field name="mage_order_status_name" />
13 | 		    <field name="odoo_order_state" />
14 |                 </tree>
15 |             </field>
16 |         </record>
17 | 
18 |         <record id="action_mage_order_status_mapping" model="ir.actions.act_window">
19 |             <field name="name">Status Mappings</field>
20 |             <field name="res_model">mage.mapping.order.state</field>
21 |             <field name="type">ir.actions.act_window</field>
22 |             <field name="view_type">form</field>
23 |             <field name="view_id" ref="view_mage_order_status_mapping_tree"/>
24 |         </record>
25 | 
26 |         <menuitem
27 |         id="menu_mage_order_status_mapping"
28 |         parent="menu_mage_configuration"
29 |         action="action_mage_order_status_mapping"
30 |         sequence="100"/>
31 | 
32 |    </data>
33 | </openerp>
34 | 


--------------------------------------------------------------------------------
/views/delivery.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | 
 4 |         <record id="view_mage_delivery_carrier_tree" model="ir.ui.view">
 5 |             <field name="name">Mage Delivery Carrier Tree</field>
 6 |             <field name="model">delivery.carrier</field>
 7 |             <field name="inherit_id" ref="delivery.view_delivery_carrier_tree"/>
 8 |             <field name="arch" type="xml">
 9 |                 <field name="name" position="after">
10 |                     <field name="mage_code" />
11 | 		    <field name="mage_carrier_code" />
12 |                 </field>
13 |             </field>
14 |         </record>
15 | 
16 |         <record id="view_mage_delivery_carrier_form" model="ir.ui.view">
17 |             <field name="name">Mage Delivery Carrier Form</field>
18 |             <field name="model">delivery.carrier</field>
19 |             <field name="inherit_id" ref="delivery.view_delivery_carrier_form" />
20 |             <field name="arch" type="xml">
21 |                 <group name="general" position="after" >
22 | 		    <group colspan="4">
23 |                         <field name="mage_code" />
24 | 		        <field name="mage_carrier_code" />
25 | 		        <field name="channel_name" />
26 | 		        <field name="channel_color" />
27 | 		    </group>
28 |                 </group>
29 |             </field>
30 |         </record>
31 | 
32 |     </data>
33 | </openerp>
34 | 


--------------------------------------------------------------------------------
/models/tax.py:
--------------------------------------------------------------------------------
 1 | """
 2 |     account
 3 | 
 4 |     Account
 5 | 
 6 |     :copyright: (c) 2013 by Openlabs Technologies & Consulting (P) Limited
 7 |     :license: AGPLv3, see LICENSE for more details.
 8 | """
 9 | from openerp.osv import osv, fields
10 | 
11 | 
12 | class AccountTax(osv.Model):
13 |     "Account Tax"
14 |     _inherit = 'account.tax'
15 | 
16 |     _columns = {
17 |         'mage_tax': fields.boolean('Is this tax used on magento ?', copy=False),
18 |         'apply_on_magento_shipping': fields.boolean(
19 |             'Is this tax applied on magento shipping ?',
20 |             help='This tax should have *Tax Included in Price* set as True', copy=False
21 |         )
22 |     }
23 | 
24 |     def check_apply_on_magento_shipping(self, cursor, user, ids, context=None):
25 |         """
26 |         Checks that only one tax has been chosen to be applied on magento
27 |         shipping
28 | 
29 |         :param cursor: Database cursor
30 |         :param user: ID of current user
31 |         :param ids: IDs of records
32 |         :param context: Application context
33 |         :return: True or False
34 |         """
35 |         if len(self.search(cursor, user, [
36 |             ('apply_on_magento_shipping', '=', True)
37 |         ], context=context)) > 1:
38 |             return False
39 |         return True
40 | 
41 |     _constraints = [
42 |         (
43 |             check_apply_on_magento_shipping,
44 |             'Error: Only 1 tax can be chosen to apply on magento shipping',
45 |             []
46 |         )
47 |     ]
48 | 
49 |     def onchange_apply_on_magento_shipping(
50 |         self, cursor, user, ids, apply_on_magento_shipping, context=None
51 |     ):
52 |         """Set *Tax Included in Price* set as True
53 |         """
54 |         return {'value': {'price_include': apply_on_magento_shipping}}
55 | 


--------------------------------------------------------------------------------
/views/import_exception.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 |         <record id="view_mage_import_exceptions_search" model="ir.ui.view">
 4 |             <field name="name">Mage Import Exceptions Search</field>
 5 |             <field name="model">mage.import.exception</field>
 6 |             <field name="arch" type="xml">
 7 | 		<search>
 8 | 		    <field name="type" />
 9 | 		    <field name="external_id" />
10 | 		    <field name="message" />
11 | 		</search>
12 |             </field>
13 |         </record>
14 | 
15 | <!--
16 |         <record id="view_mage_import_exceptions_form" model="ir.ui.view">
17 |             <field name="name">Mage Import Exceptions Form</field>
18 |             <field name="model">mage.import.exception</field>
19 |             <field name="arch" type="xml">
20 | 		<group>
21 | 		</group>
22 | 	    </field>
23 | 	</record>
24 | -->
25 | 
26 |         <record id="mage_import_exceptions_tree" model="ir.ui.view">
27 |             <field name="name">Mage Import Exceptions Tree</field>
28 |             <field name="model">mage.import.exception</field>
29 |             <field name="arch" type="xml">
30 | 		<tree>
31 | 		    <field name="external_id" />
32 | 		    <field name="type" />
33 | 		    <field name="message" />
34 | 		</tree>
35 | 	    </field>
36 | 	</record>
37 | 
38 | 
39 | 	<record id="action_mage_import_exceptions" model="ir.actions.act_window">
40 | 	    <field name="name">Import Exceptions</field>
41 | 	    <field name="type">ir.actions.act_window</field>
42 | 	    <field name="res_model">mage.import.exception</field>
43 | 	    <field name="view_type">form</field>
44 | 	    <field name="context">{}</field>
45 | 	    <field name="view_id" ref="mage_import_exceptions_tree"/>
46 | 	    <field name="view_mode">tree,form</field>
47 | 	    <field name="search_view_id" ref="view_mage_import_exceptions_search"/>
48 | 	</record>
49 | 
50 |         <menuitem id="menu_mage_import_exceptions"
51 |                 action="action_mage_import_exceptions" parent="menu_mage_jobs"
52 |                 sequence="10"/>
53 |     </data>
54 | </openerp>
55 | 
56 | 


--------------------------------------------------------------------------------
/jobs/mass_inventory.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import fields, osv, orm
 2 | import openerp.addons.decimal_precision as dp
 3 | from openerp.tools.translate import _
 4 | from openerp import tools
 5 | 
 6 | class MageJob(osv.osv):
 7 |     _inherit = "mage.job"
 8 | 
 9 |     def zero_all_negative(self, cr, uid, job, context=None):
10 |         if context is None:
11 |             context = {}
12 | 
13 | 	location = 12
14 | 	location_name = 'Stock'
15 | 
16 |         inventory_obj = self.pool.get('stock.inventory')
17 |         inventory_line_obj = self.pool.get('stock.inventory.line')
18 | 	product_obj = self.pool.get('product.product')
19 | 
20 |         filter = 'partial'
21 |         inventory_id = inventory_obj.create(cr, uid, {
22 | 	    'name': 'Zero Inventory For Location: %s' % location_name,
23 |             'filter': filter,
24 |             'location_id': location,
25 | 	}, context=context)
26 | 
27 | 	product_ids = product_obj.search(cr, uid, [])
28 | 	ok = False
29 |         for product in product_obj.browse(cr, uid, product_ids, context={'location_id': location, 'location': location}):
30 | 	    product_qty_available = product.qty_available
31 | 	    if product_qty_available < 0:
32 | 		ok = True
33 | 	        print 'SKU: %s' % product.default_code
34 | 	        print 'Quantity Available: %s' % product.qty_available
35 | 
36 |                 product = product.with_context(location=location, lot_id=False)
37 |                 th_qty = product.qty_available
38 |                 line_data = {
39 |                     'inventory_id': inventory_id,
40 |                     'product_qty': 0,
41 |                     'location_id': location,
42 |                     'product_id': product.id,
43 |                     'product_uom_id': product.uom_id.id,
44 |                     'theoretical_qty': th_qty,
45 |                     'prod_lot_id': False
46 |                 }
47 |                 inventory_line_obj.create(cr , uid, line_data, context=context)
48 | 
49 | #	if ok:
50 | #            inventory_obj.action_done(cr, uid, [inventory_id], context=context)
51 |         return True
52 | 


--------------------------------------------------------------------------------
/views/export_exception.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 |         <record id="view_mage_export_exceptions_search" model="ir.ui.view">
 4 |             <field name="name">Mage Export Exceptions Search</field>
 5 |             <field name="model">mage.export.exception</field>
 6 |             <field name="arch" type="xml">
 7 | 		<search>
 8 | 		    <field name="type" />
 9 | 		    <field name="name" />
10 | 		    <field name="message" />
11 | 		</search>
12 |             </field>
13 |         </record>
14 | 
15 | <!--
16 |         <record id="view_mage_export_exceptions_form" model="ir.ui.view">
17 |             <field name="name">Mage export Exceptions Form</field>
18 |             <field name="model">mage.export.exception</field>
19 |             <field name="arch" type="xml">
20 | 		<group>
21 | 		</group>
22 | 	    </field>
23 | 	</record>
24 | -->
25 | 
26 |         <record id="mage_export_exceptions_tree" model="ir.ui.view">
27 |             <field name="name">Mage export Exceptions Tree</field>
28 |             <field name="model">mage.export.exception</field>
29 |             <field name="arch" type="xml">
30 | 		<tree>
31 | 		    <field name="name" />
32 | 		    <field name="type" />
33 | 		    <field name="message" />
34 | 		    <button string="Retry" />
35 | 		</tree>
36 | 	    </field>
37 | 	</record>
38 | 
39 | 
40 | 	<record id="action_mage_export_exceptions" model="ir.actions.act_window">
41 | 	    <field name="name">Export Exceptions</field>
42 | 	    <field name="type">ir.actions.act_window</field>
43 | 	    <field name="res_model">mage.export.exception</field>
44 | 	    <field name="view_type">form</field>
45 | 	    <field name="context">{}</field>
46 | 	    <field name="view_id" ref="mage_export_exceptions_tree"/>
47 | 	    <field name="view_mode">tree,form</field>
48 | 	    <field name="search_view_id" ref="view_mage_export_exceptions_search"/>
49 | 	</record>
50 | 
51 |         <menuitem id="menu_mage_export_exceptions"
52 |                 action="action_mage_export_exceptions" parent="menu_mage_jobs"
53 |                 sequence="10"/>
54 |     </data>
55 | </openerp>
56 | 
57 | 


--------------------------------------------------------------------------------
/jobs/invoice.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | 
 4 | class MageIntegrator(osv.osv_memory):
 5 | 
 6 |     _inherit = 'mage.integrator'
 7 | 
 8 |     #This is a temoporary method. Ideal solution does not involve a direct sql query
 9 |     def get_pending_invoices(self, cr, uid, storeview_id):
10 | 	query = "SELECT rel.order_id, rel.invoice_id" \
11 | 		"\nFROM sale_order_invoice_rel rel" \
12 | 		"\nJOIN sale_order sale ON (sale.id = rel.order_id)" \
13 | 		"\nJOIN account_invoice invoice ON (invoice.id = rel.invoice_id)" \
14 | 		"\nWHERE invoice.state = 'paid'" \
15 | 		"\nAND invoice.mage_export_error IS NOT True" \
16 | 		"\nAND sale.mage_invoice_complete IS NOT True" \
17 | 		"\nAND sale.mage_store = %s" % storeview_id
18 | 
19 | 	cr.execute(query)
20 | 	return cr.dictfetchall()
21 | 
22 | 
23 |     def sync_invoices(self, cr, uid, job, context=None):
24 |         storeview_obj = self.pool.get('mage.store.view')
25 |         store_ids = storeview_obj.search(cr, uid, [('do_not_import', '=', False)])
26 | 	for storeview in storeview_obj.browse(cr, uid, store_ids):
27 | 	    invoice_data = self.get_pending_invoices(cr, uid, storeview.id)
28 | 	    if invoice_data:
29 | 		self.send_invoices(cr, uid, job, invoice_data)
30 | 
31 | 	return True
32 | 
33 | 
34 |     def send_invoices(self, cr, uid, job, invoice_data):
35 | 	invoice_obj = self.pool.get('account.invoice')
36 | 	sale_obj = self.pool.get('sale.order')
37 | 	for collection in invoice_data:
38 | 
39 | 
40 | 	    invoice = invoice_obj.browse(cr, uid, collection['invoice_id'])
41 | 	    sale = sale_obj.browse(cr, uid, collection['order_id'])
42 | 	    comment = 'Payment Captured'
43 | 	    if sale.mage_invoice_complete:
44 | 		continue
45 | 
46 | 	    try:
47 |                 mage_id = self._get_job_data(cr, uid, job, \
48 |                     'sales_order_invoice.capture_create', [sale.mage_order_number, comment, False, False])
49 | 	        sale.mage_invoice_complete = True
50 | 		print 'Successfully Created and Captured Invoice in Magento'
51 | 
52 | 	    except Exception, e:
53 | 		print 'Error', e
54 | 		invoice.mage_export_error = True
55 | 
56 | 
57 | 	return True
58 | 


--------------------------------------------------------------------------------
/models/test.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 |     function multinfo($productIds, $includeLinks = false) {
 3 | 	/* Fetch multiple products info */
 4 | 
 5 | 	$store = null;
 6 | 	$filters = null;
 7 |     $taxData = $this->getTaxInfo();
 8 | 	$collection = Mage::getModel('catalog/product')
 9 |                 ->getCollection()
10 |                 ->addAttributeToFilter('entity_id', array('in' => $productIds))
11 |                 ->addAttributeToSelect('*');
12 | 
13 |         $result = array ();
14 | 
15 |         foreach ($collection as $collection_item) {
16 |             $coll_array = $collection_item->toArray();
17 |             $coll_array['categories'] = $collection_item->getCategoryIds();
18 |             $coll_array['websites'] = $collection_item->getWebsiteIds();
19 | 	        //If you want all kinds of links. Will make the call exponentially slower depending on number of links
20 | 	        if ($includeLinks) {
21 |                 if ($collection_item->getTypeId() == 'grouped') {
22 |                     $coll_array['grouped'] = $this->getProductLinks($collection_item, Mage_Catalog_Model_Product_Link::LINK_TYPE_GROUPED);
23 |                 }
24 |                 $coll_array['up_sell'] = $this->getProductLinks($collection_item, Mage_Catalog_Model_Product_Link::LINK_TYPE_UPSELL);
25 |                 $coll_array['cross_sell'] = $this->getProductLinks($collection_item, Mage_Catalog_Model_Product_Link::LINK_TYPE_CROSSSELL);
26 |                 $coll_array['related'] = $this->getProductLinks($collection_item, Mage_Catalog_Model_Product_Link::LINK_TYPE_RELATED);
27 | 	        }
28 | 
29 |             /*TODO: Put this into a single function as its used more than once */
30 |             if ($collection_item->getTypeId() == 'configurable') {
31 |                 $attribute_array = $collection_item->getTypeInstance(true)->getConfigurableAttributesAsArray($collection_item);
32 |                 $attrs = array();
33 |                 foreach ($attribute_array as $attr) {
34 |                     $attrs[] = $attr['attribute_id'];
35 | 
36 |                 }
37 | 
38 |                 $coll_array['super_attributes'] = $attrs;
39 | 	        }
40 | 
41 |             $result[] = $coll_array;
42 | 
43 |         }
44 | 
45 |         return $result;
46 |     }
47 | 


--------------------------------------------------------------------------------
/models/procurement.py:
--------------------------------------------------------------------------------
 1 | from openerp import SUPERUSER_ID, api
 2 | from openerp.osv import osv, fields
 3 | 
 4 | 
 5 | class StockMove(osv.osv):
 6 |     _inherit = 'stock.move'
 7 |     _columns = {
 8 | 	'sale_price': fields.float('Original Sale Price'),
 9 | 	'sale_line_id': fields.many2one('sale.order.line', 'Sale Line ID'),
10 |     }
11 | 
12 |     def add_sale_vals(self, cr, uid, sale, context=None):
13 | 	vals = {
14 | 	    'sale': sale.id,
15 | 	    'mage_store': sale.mage_store.id,
16 | 	}
17 | 
18 | 	if sale.carrier_id:
19 | 	    vals['carrier_id'] = sale.carrier_id.id
20 | 
21 | 	return vals
22 | 
23 | 
24 |     @api.cr_uid_ids_context
25 |     def _picking_assign(self, cr, uid, move_ids, procurement_group, \
26 |                 location_from, location_to, context=None):
27 | 
28 |         picking_obj = self.pool.get('stock.picking')
29 | 
30 |         res = super(StockMove, self)._picking_assign(cr, uid, move_ids, procurement_group, \
31 |                 location_from, location_to, context=context)
32 | 
33 |         moves = self.browse(cr, uid, move_ids)
34 | 	for move in moves:
35 |             sale_line_id, price = self.find_sale_line_reference(cr, uid, move.product_id.id, move.procurement_id.sale_line_id.order_id.id)
36 | 	    if not sale_line_id:
37 | 		continue
38 | 	    move.sale_line_id = sale_line_id
39 | 	    move.sale_price = price
40 | 	    
41 |         if moves[0].procurement_id.sale_line_id:
42 | 	    picking = moves[0].picking_id
43 | 	    vals = self.add_sale_vals(cr, uid, moves[0].procurement_id.sale_line_id.order_id)
44 |             picking_obj.write(cr, uid, picking.id, vals)
45 | 
46 |         for move in moves:
47 |             sale_line_id, price = self.find_sale_line_reference(cr, uid, move.product_id.id, move.procurement_id.sale_line_id.order_id.id)
48 |             if not sale_line_id:
49 |                 print 'NO SALE LINE ID'
50 |                 continue
51 |             move.sale_line_id = sale_line_id
52 |             move.sale_price = price
53 | 
54 |         return res
55 | 
56 | 
57 |     def find_sale_line_reference(self, cr, uid, product_id, order_id):
58 |         sale_line_obj = self.pool.get('sale.order.line')
59 |         sale_line_ids = sale_line_obj.search(cr, uid, [('product_id', '=', product_id), ('order_id', '=', order_id)])
60 |         if not sale_line_ids:
61 |             return (False, False)
62 |         sale_line = sale_line_obj.browse(cr, uid, sale_line_ids[0])
63 |         return (sale_line.id, sale_line.price_unit)
64 | 


--------------------------------------------------------------------------------
/jobs/fix_shipments.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | 
 3 | 
 4 | class MageIntegrator(osv.osv_memory):
 5 | 
 6 |     _inherit = 'mage.integrator'
 7 | 
 8 |     def fix_holded_pending(self, cr, uid, ids, context=None):
 9 | 	picking_obj = self.pool.get('stock.picking')
10 | 	sale_obj = self.pool.get('sale.order')
11 | 
12 | 	sale_ids = sale_obj.search(cr, uid, [('mage_custom_status', 'in', ['pending'])])
13 | 	for sale in sale_obj.browse(cr, uid, sale_ids):
14 | 	    print 'SALE REVERT', sale.name
15 | 	    for picking in sale.picking_ids:
16 | 		if picking.state in ['partially_available', 'confirmed', 'assigned']:
17 | 		    picking_obj.action_cancel(cr, uid, [picking.id])
18 | 		    picking.action_back_to_draft()
19 | 	    cr.commit()
20 | 
21 | 
22 |     def check_order_status(self, cr, uid, job, context=None):
23 |         import csv
24 | 	sale_obj = self.pool.get('sale.order')
25 | 	stock_obj = self.pool.get('stock.picking')
26 | 
27 |         input = open('/usr/local/openerp/community/mage2odoo/jobs/orders.csv', 'r')
28 |         reader = csv.DictReader(input, quotechar='"', delimiter=',')
29 |         for line in reader:
30 | 	    status = line['status']
31 | 	    order_no = line['increment_id']
32 | 	    order_ids = sale_obj.search(cr, uid, [('mage_order_number', '=', order_no)])
33 | 	    if not order_ids:
34 | 		print 'ORDER NOT FOUND', order_no
35 | 		continue
36 | 
37 | 	    print 'ORDER', order_no
38 | 	    sale = sale_obj.browse(cr, uid, order_ids[0])
39 | #	    stat = sale.mage_custom_status
40 | 	    self.mage_status_complete(cr, uid, sale)
41 | #	    if stat != status:
42 | #		sale.mage_custom_status = status
43 | 
44 | #	    if status not in ['pending', 'canceled', 'closed']:
45 | #	    if status != 'o_complete':
46 | #		continue
47 | #	    cr.commit()
48 | 	    continue
49 | 
50 | #	    cancel = False
51 | #	    print 'SALE', sale.name
52 | #	    for picking in sale.picking_ids:
53 | #		if picking.state in ['cancel', 'draft']:
54 | #		    stock_obj.action_confirm(cr, uid, [picking.id], context=context)
55 | #
56 | #		if picking.state == 'done':
57 | #		    stock_obj.action_revert_done(cr, uid, [picking.id])
58 | #		    stock_obj.action_cancel(cr, uid, [picking.id])
59 | 
60 | #		elif picking.state != 'draft':
61 | #		    picking.action_back_to_draft()
62 |  
63 | #		if status in ['canceled', 'closed']:
64 | #		    cancel = True
65 | #		    stock_obj.action_cancel(cr, uid, [picking.id])
66 | #
67 | #	    if cancel:
68 | #		try:
69 | #		    sale_obj.action_cancel(cr, uid, [sale.id])
70 | ##		except Exception, e:
71 | #		    print e
72 | 
73 | #	    cr.commit()
74 | 


--------------------------------------------------------------------------------
/jobs/grouped_relation.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | from datetime import datetime
 4 | from tzlocal import get_localzone
 5 | 
 6 | class MageIntegrator(osv.osv_memory):
 7 | 
 8 |     _inherit = 'mage.integrator'
 9 | 
10 |     def test_attribute_options(self, cr, uid, job, context=None):
11 |         records = self._get_job_data(cr, uid, job, 'sales_order.shipping_methods', [])
12 | 
13 | 	return True
14 | 
15 | 
16 |     def import_grouped_product_relation(self, cr, uid, job, context=None):
17 | 	product_obj = self.pool.get('product.product')
18 | 
19 | 	product_ids = product_obj.search(cr, uid, ['|',('external_id', '!=', False), ('external_id', '!=', 0)])
20 | 	product_data = product_obj.read(cr, uid, product_ids, fields=['external_id'])
21 | 	external_ids = [x['external_id'] for x in product_data]
22 | 	print 'IDS', len(external_ids) 
23 |         datas = [external_ids[i:i+900] for i in range(0, len(external_ids), 900)]
24 |         mappinglines = self._get_mappinglines(cr, uid, job.mapping.id)
25 | 
26 |         for data in datas:
27 |             try:
28 |                 records = self._get_job_data(cr, uid, job, 'oo_catalog_product.multinfo', [data, True])
29 |                 self.process_mage_grouped_products_response(cr, uid, job, mappinglines, records)
30 | #                cr.commit()
31 |             except Exception, e:
32 |                 print e
33 | 
34 |         return True
35 | 
36 | 
37 |     def process_mage_grouped_products_response(self, cr, uid, job, mappinglines, records):
38 | #        target_obj = self.pool.get(job.mapping.model_id.model)
39 | 	product_obj = self.pool.get('product.product')
40 | 
41 |         for record in records:
42 | #	    pp(record)
43 | 	    grouped_data = []
44 | 	    #Solves bug with null sku
45 | 	    if not record['sku']:
46 | 		continue
47 | 	    pp(record['sku'])
48 | 
49 | 	    product = product_obj.get_or_create_odoo_record(cr, uid, job, record['entity_id'], False)
50 | 	    if record.get('grouped'):
51 | 		cr.execute('DELETE FROM mage_grouped_product WHERE product_tmpl_id = %s'%product.product_tmpl_id.id)
52 | 		for grouped_item in record.get('grouped'):
53 | 		    vals = {
54 | 			'product': product_obj.get_or_create_odoo_record(cr, uid, job, grouped_item['product_id'], False),
55 | 			'product_tmpl_id': product.product_tmpl_id.id,
56 | 			'qty': grouped_item['qty'],
57 | 			'position': grouped_item['position'],
58 | 		    }
59 | 		    grouped_data.append((0, 0, vals))
60 | 
61 | 		pp(grouped_data)
62 | 		product.grouped_products = grouped_data
63 | 		cr.commit()
64 |         return True
65 | 
66 | 
67 | 


--------------------------------------------------------------------------------
/views/import_export.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | 
 4 |         <menuitem name="Import/Export"
 5 |         id="menu_mage_import_export"
 6 |         parent="menu_mage_core"
 7 |         sequence="50"/>
 8 | 
 9 | 	<record model="ir.ui.view" id="view_mage_import_form">
10 | 	    <field name="name">Import Products Wizard</field>
11 | 	    <field name="model">mage.import.wizard</field>
12 | 	    <field name="arch" type="xml">
13 | 		<form>
14 | 		    <group string="Upload File" >
15 | 		        <field name="file" required="1"/>
16 | 		    </group>
17 |                     <button name="import_products" string="Go"
18 |                     type="object"/>
19 | 		</form>
20 | 	    </field>
21 | 	</record>
22 | 
23 |         <record id="action_mage_import_products" model="ir.actions.act_window">
24 |             <field name="name">Import Products</field>
25 |             <field name="res_model">mage.import.wizard</field>
26 |             <field name="type">ir.actions.act_window</field>
27 |             <field name="view_type">form</field>
28 | 	    <field name="view_mode">form</field>
29 | 	    <field name="target">new</field>
30 |             <field name="view_id" ref="view_mage_import_form"/>
31 |         </record>
32 | 
33 |         <record model="ir.ui.view" id="view_mage_export_form">
34 |             <field name="name">Export Products Wizard</field>
35 |             <field name="model">mage.export.wizard</field>
36 |             <field name="arch" type="xml">
37 |                 <form>
38 |                     <group string="Select Export" >
39 |                     </group>
40 |                     <button name="export_products" string="Go"
41 |                     type="object"/>
42 |                 </form>
43 |             </field>
44 |         </record>
45 | 
46 |         <record id="action_mage_export_products" model="ir.actions.act_window">
47 |             <field name="name">Export Products</field>
48 |             <field name="res_model">mage.export.wizard</field>
49 |             <field name="type">ir.actions.act_window</field>
50 |             <field name="view_type">form</field>
51 | 	    <field name="view_mode">form</field>
52 | 	    <field name="target">new</field>
53 |             <field name="view_id" ref="view_mage_export_form"/>
54 |         </record>
55 | 
56 | 	<menuitem id="menu_import_products"
57 | 	action="action_mage_import_products"
58 | 	parent="menu_mage_import_export"
59 | 	sequence="10"/>
60 | 
61 | 	<menuitem id="menu_export_products"
62 | 	action="action_mage_export_products"
63 | 	parent="menu_mage_import_export"
64 | 	sequence="20"/>
65 | 
66 | 
67 |     </data>
68 | </openerp>
69 | 


--------------------------------------------------------------------------------
/jobs/links.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | from datetime import datetime
 4 | from tzlocal import get_localzone
 5 | 
 6 | class MageIntegrator(osv.osv_memory):
 7 | 
 8 |     _inherit = 'mage.integrator'
 9 | 
10 |     def test_attribute_options(self, cr, uid, job, context=None):
11 |         records = self._get_job_data(cr, uid, job, 'sales_order.shipping_methods', [])
12 | 
13 | 	return True
14 | 
15 | 
16 |     def import_product_links(self, cr, uid, job, context=None):
17 | 	product_obj = self.pool.get('product.product')
18 | 
19 | 	product_ids = product_obj.search(cr, uid, ['|',('external_id', '!=', False), ('external_id', '!=', 0)])
20 | 	product_data = product_obj.read(cr, uid, product_ids, fields=['external_id'])
21 | 	external_ids = [x['external_id'] for x in product_data]
22 | 	print 'IDS', len(external_ids)
23 |         datas = [external_ids[i:i+900] for i in range(0, len(external_ids), 900)]
24 |         mappinglines = self._get_mappinglines(cr, uid, job.mapping.id)
25 | 
26 |         for data in datas:
27 |             try:
28 |                 records = self._get_job_data(cr, uid, job, 'oo_catalog_product.multinfo', [data, True])
29 |                 self.process_mage_product_links_response(cr, uid, job, mappinglines, records)
30 | #                cr.commit()
31 |             except Exception, e:
32 |                 print e
33 | 
34 |         return True
35 | 
36 | 
37 |     def process_mage_product_links_response(self, cr, uid, job, mappinglines, records):
38 | #        target_obj = self.pool.get(job.mapping.model_id.model)
39 | 	product_obj = self.pool.get('product.product')
40 | 
41 |         for record in records:
42 | #	    pp(record)
43 | 	    related_data = []
44 | 	    #Solves bug with null sku
45 | 	    if not record['sku']:
46 | 		continue
47 | 	    if record['sku'] == 'sbls12-12':
48 | 		raise
49 | 
50 | 	    print 'SKU', record['sku']
51 | 	    product = product_obj.get_or_create_odoo_record(cr, uid, job, record['entity_id'], False)
52 | 	    if record.get('related'):
53 | 		cr.execute('DELETE FROM product_link WHERE product_tmpl_id = %s'%product.product_tmpl_id.id)
54 | 		for related in record.get('related'):
55 | 		    vals = {
56 | 			'linked_product': product_obj.get_or_create_odoo_record(cr, uid, job, related['product_id'], False),
57 | 			'product_tmpl_id': product.product_tmpl_id.id,
58 | 			'linked_type': 'related',
59 | 			'position': related['position'],
60 | 		    }
61 | 		    related_data.append((0, 0, vals))
62 | 
63 | #		pp(related_data)
64 | 		product.product_links = related_data
65 | 		cr.commit()
66 |         return True
67 | 
68 | 
69 | 


--------------------------------------------------------------------------------
/jobs/partner.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | from datetime import datetime
 4 | from tzlocal import get_localzone
 5 | 
 6 | class MageIntegrator(osv.osv_memory):
 7 | 
 8 |     _inherit = 'mage.integrator'
 9 | 
10 | 
11 |     def import_updated_partners(self, cr, uid, job, context=None):
12 | 	instance = job.mage_instance
13 | 	filters = {}
14 | 	if instance.last_imported_customer:
15 | 	    filters = {'entity_id': {'gt': instance.last_imported_customer}}
16 | 
17 | 
18 |         tz = get_localzone()
19 |         now = datetime.utcnow()
20 |         dt = tz.localize(now)
21 |         string = dt.strftime('%Y-%m-%d')
22 |         updated = {'updated_at': {'gteq': string}}
23 | 	filters.update(updated)
24 | 
25 |         partner_ids = self._get_job_data(cr, uid, job, 'oo_customer.search', [filters])
26 | 
27 | 	if not partner_ids:
28 | 	    return True
29 | 
30 | 	return self.import_partners(cr, uid, job, partner_ids)
31 | 
32 | 
33 |     def import_all_partners(self, cr, uid, job, context=None):
34 |         instance = job.mage_instance
35 |         filters = False
36 |         if instance.last_imported_customer:
37 |             filters = {'entity_id': {'gt': instance.last_imported_customer}}
38 | 
39 |         partner_ids = self._get_job_data(cr, uid, job, 'oo_customer.search', [filters])
40 | 
41 |         if not partner_ids:
42 |             return True
43 | 
44 |         return self.import_partners(cr, uid, job, partner_ids)
45 | 
46 | 
47 |     def import_partners(self, cr, uid, job, partner_ids, context=None):
48 |         datas = [partner_ids[i:i+900] for i in range(0, len(partner_ids), 900)]
49 |  #       mappinglines = self._get_mappinglines(cr, uid, job.mapping.id)
50 | 	instance = job.mage_instance
51 | 	mappinglines = False
52 |         for data in datas:
53 |             records = self._get_job_data(cr, uid, job, 'oo_customer.multinfo', [data])
54 |             self.process_mage_partner_response(cr, uid, job, mappinglines, records)
55 |             cr.commit()
56 | 
57 |         return True
58 | 
59 | 
60 |     def process_mage_partner_response(self, cr, uid, job, mappinglines, records):
61 |         partner_obj = self.pool.get('res.partner')
62 | 	for record in records:
63 | 	    try:
64 | 	        partner = partner_obj.get_or_create_customer(cr, uid, record)
65 | 		print 'Successfully synced Customer with Id %s' % record['entity_id']
66 | 
67 | 	        if record['addresses']:
68 | 		    for address in record['addresses']:
69 | 		        partner_obj.get_or_create_partner_address(cr, uid, address, partner, address_type=False)
70 |                         print 'Synced Customer Address'
71 | 	    except Exception, e:
72 | 		print e
73 | 	return True
74 | 


--------------------------------------------------------------------------------
/models/job.py:
--------------------------------------------------------------------------------
 1 | from openerp import SUPERUSER_ID
 2 | from openerp.osv import osv, fields
 3 | from openerp.tools.translate import _
 4 | from pprint import pprint as pp
 5 | 
 6 | class MageJob(osv.osv):
 7 |     _name = 'mage.job'
 8 |     _columns = {
 9 |         'name': fields.char('Name', required=True),
10 | 	'core_job': fields.boolean('Core Job'),
11 | 	'mage_instance': fields.many2one('mage.setup', 'Magento Instance', required=True),
12 | 	'scheduler': fields.many2one('ir.cron', 'Scheduler', readonly=True),
13 | 	'mapping': fields.many2one('mage.mapping', 'Mapping'),
14 | 	'element_inspector': fields.text('Element Inspector'),
15 | 	'job_type': fields.selection([('direct_import', 'Direct Import'),
16 | 				      ('custom', 'Python Code'),
17 | 				      ('system', 'System')], 'Job Type', required=True),
18 | 	'threaded': fields.boolean('Threaded Job'),
19 | 	'python_model': fields.many2one('ir.model', 'Python Model'),
20 | 	'python_function_name': fields.char('Python Function Name'),
21 |     }
22 | 
23 | 
24 |     def button_execute_job(self, cr, uid, ids, context=None):
25 |         job = self.browse(cr, uid, ids[0])
26 |         result = self.import_resources(cr, uid, job)
27 | #        if result and result != 'False':
28 |  #           raise osv.except_osv(_("API Response Error!"), _(result))
29 | 
30 |         return True
31 | 
32 | 
33 |     def import_resources(self, cr, uid, job, context=None):
34 |         """
35 |         """
36 | 	job_obj = self.pool.get(job.python_model.name)
37 |         #If we are using a custom code implementation
38 |         if job.job_type == 'direct_import':
39 |             return getattr(job_obj, job.python_function_name)(cr, uid, job)
40 | 
41 |         elif job.job_type in ['custom', 'system']:
42 |             return getattr(job_obj, job.python_function_name)(cr, uid, job)
43 | 
44 | 
45 | 	return False
46 | 
47 | 
48 |     def button_schedule_mage_job(self, cr, uid, ids, context=None):
49 | 	for job in self.browse(cr, uid, ids):
50 | 	    if job.scheduler:
51 | 		continue
52 | 	    cron_id = self.create_mage_schedule(cr, uid, job.id, job.name)
53 | 	    self.write(cr, uid, job.id, {'scheduler': cron_id})
54 | 	return True
55 | 
56 | 
57 |     def create_mage_schedule(self, cr, uid, job_id, job_name, context=False):
58 |         vals = {'name': job_name,
59 |                 'active': False,
60 |                 'user_id': SUPERUSER_ID,
61 |                 'interval_number': 15,
62 |                 'interval_type': 'minutes',
63 |                 'numbercall': -1,
64 |                 'doall': False,
65 |                 'model': 'mage.job',
66 |                 'function': 'button_execute_job',
67 |                 'args': '([' + str(job_id) +'],)',
68 |         }
69 | 
70 |         return self.pool.get('ir.cron').create(cr, uid, vals, context)
71 | 


--------------------------------------------------------------------------------
/models/delivery.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from openerp.tools.translate import _
 3 | CARRIER_MAP = {'ups': 'UPS', 'fedex': 'FedEx'}
 4 | 
 5 | class DeliveryCarrier(osv.osv):
 6 |     _inherit = 'delivery.carrier'
 7 |     _columns = {
 8 | 	'display_in_ui': fields.boolean('Display in Searches'),
 9 | 	'mage_code': fields.char('Magento ID', select=True, copy=False),
10 | 	'mage_carrier_code': fields.char('Magento Carrier Code'),
11 | 	'channel_name': fields.char('Channel Name'),
12 | 	'channel_color': fields.char('Channel Color'),
13 | 	'mage_carrier': fields.selection([('ups', 'UPS'),
14 | 					  ('usps', 'USPS'),
15 | 					  ('fedex', 'FedEx'),
16 | 					  ('dhl', 'DHL'),
17 | 	], 'Carrier', select=True),
18 |     }
19 | 
20 |     def search(self, cr, uid, args, offset=0, limit=None, order=None,
21 |             context=None, count=False):
22 |         """ Check presence of key 'consolidate_children' in context to include also the Consolidated Children
23 |             of found accounts into the result of the search
24 |         """
25 | 
26 | 	args.append(('display_in_ui', '=', True))
27 |         res = super(DeliveryCarrier, self).search(cr, uid, args, offset, limit,
28 |                 order, context=context, count=count)
29 | 	return res
30 | 
31 | 
32 |     def prepare_odoo_record_vals(self, cr, uid, job, record):
33 | 	mage = job.mage_instance
34 | 
35 | 	if not mage.default_shipping_partner:
36 | 	    raise osv.except_osv(_('Config Error'), _('No Shipping Partner Defined!'))
37 | 
38 | 	if not mage.shipping_product:
39 | 	    raise osv.except_osv(_('Config Error'), _('No Shipping Product Defined!'))
40 | 
41 | 	method = record.get('method_title') or record.get('code')
42 | 
43 | 	method = method.replace('UPS ', '')
44 | 	code_name = CARRIER_MAP.get(record.get('carrier_code')) or ''
45 | 	vals = {'mage_code': method,
46 | 		'display_in_ui': True,
47 | 		'name': ' '.join([code_name, method]) if record.get('carrier_code') else method,
48 | 		'mage_carrier_code': record.get('carrier_code'),
49 | 		'product_id': mage.shipping_product.id,
50 | 		'partner_id': mage.default_shipping_partner.id,
51 | 
52 | 	}
53 | 
54 | 	return vals
55 | 
56 | 
57 |     #Override to use code field instead of internal id
58 |     def get_mage_record(self, cr, uid, external_id):
59 |         existing_ids = self.search(cr, uid, [('mage_code', '=', external_id)])
60 |         if existing_ids:
61 |             return existing_ids[0]
62 | 
63 |         return False
64 | 
65 | 
66 |     def upsert_mage_record(self, cr, uid, vals, record_id=False):
67 |         if record_id:
68 |             self.write(cr, uid, record_id, vals)
69 |             return record_id
70 | 
71 |         existing_id = self.get_mage_record(cr, uid, vals['mage_code'])
72 | 
73 |         if existing_id:
74 |             self.write(cr, uid, existing_id, vals)
75 |             return existing_id
76 | 
77 |         else:
78 |             return self.create(cr, uid, vals)
79 | 


--------------------------------------------------------------------------------
/views/jobs.xml:
--------------------------------------------------------------------------------
 1 | <openerp>
 2 |     <data>
 3 | 
 4 |         <menuitem name="Jobs"
 5 |         id="menu_mage_jobs"
 6 |         parent="menu_mage_core"
 7 |         sequence="40"/>
 8 | 
 9 | 
10 |         <record id="view_mage_job_tree" model="ir.ui.view">
11 |             <field name="name">Mage Job Tree</field>
12 |             <field name="model">mage.job</field>
13 |             <field name="arch" type="xml">
14 |                 <tree>
15 |                     <field name="name" />
16 |                 </tree>
17 |             </field>
18 |         </record>
19 | 
20 |         <record id="mage_job_form" model="ir.ui.view">
21 |             <field name="name">External Jobs Form</field>
22 |             <field name="model">mage.job</field>
23 |             <field name="type">form</field>
24 |             <field name="arch" type="xml">
25 |                 <form>
26 |                     <header>
27 | 			<button name="button_execute_job" type="object" string="Execute Job" />
28 | 			<button name="button_sample_data" type="object" string="Sample Job" />
29 | 			<button name="button_schedule_mage_job" type="object" string="Schedule this Job" attrs="{'invisible': [('scheduler', '!=', False)]}"/>
30 | 		    </header>
31 |                     <sheet>
32 |                         <h1>
33 |                             <field name="name" class="oe_inline" />
34 |                         </h1>
35 | 		        <group colspan="2" >
36 | 			    <field name="mage_instance" />
37 | 		            <field name="mapping" />
38 | 		        </group>
39 |                          <group name="standard_configuration" colspan="4" >
40 |                             <separator string="Job Configuration" colspan="4" />
41 | 				<field name="job_type" />
42 | 				<field name="scheduler" readonly="1"/>
43 | 				<field name="threaded" />
44 |                                 <newline/>
45 | 				<field name="python_model" attrs="{'required': 
46 | 								[('job_type', '=', 'custom')],
47 | 								'invisible': [('job_type', '!=', 'custom')]}"/>
48 | 				<field name="python_function_name" attrs="{'required': 
49 | 								[('job_type', '=', 'custom')],
50 |                                                                 'invisible': [('job_type', '!=', 'custom')]}"/>
51 | 		        </group>
52 | 			    <separator string="Element Inspector" colspan="4"/>
53 | 			    <newline/>
54 | 			    <field name="element_inspector" readonly="1"/>
55 | 		    </sheet>
56 | 	        </form>
57 | 	    </field>
58 | 	</record>
59 | 
60 |         <record id="action_mage_job" model="ir.actions.act_window">
61 |             <field name="name">Jobs</field>
62 |             <field name="res_model">mage.job</field>
63 |             <field name="type">ir.actions.act_window</field>
64 |             <field name="view_type">form</field>
65 |             <field name="view_id" ref="view_mage_job_tree"/>
66 |         </record>
67 | 
68 |         <menuitem action="action_mage_job"
69 |         id="menu_mage_job"
70 |         parent="menu_mage_jobs"
71 |         sequence="10"/>
72 | 
73 |    </data>
74 | </openerp>
75 | 


--------------------------------------------------------------------------------
/jobs/create_product.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | from magento import API
 4 | from datetime import datetime
 5 | from openerp.tools.translate import _
 6 | import logging
 7 | _logger = logging.getLogger(__name__)
 8 | 
 9 | class MageIntegrator(osv.osv):
10 |     _inherit = 'mage.integrator'
11 | 
12 |     def create_mage_products(self, cr, uid, job):
13 |         
14 | 	query = " SELECT product.id FROM product_product product" + \
15 | 		" JOIN product_template template ON (product.product_tmpl_id = template.id)" + \
16 | 		" WHERE template.sync_to_mage = True" + \
17 | 		" AND external_id = 0 OR external_id IS NULL" \
18 | 		" AND product.default_code IS NOT NULL" \
19 | 		" AND mage_last_sync_date IS NULL"
20 | #		" AND template.write_date AT TIME ZONE 'UTC' > mage_last_sync_date AT TIME ZONE 'UTC' IS NULL"
21 | 	cr.execute(query)
22 | 	product_data = cr.dictfetchall()
23 | 	product_ids = [p['id'] for p in product_data]
24 | 
25 | 	print 'Product IDS', product_ids
26 | 
27 | 	credentials = self.get_external_credentials(cr, uid)
28 | 	product_obj = self.pool.get('product.product')
29 | 	for product in product_obj.browse(cr, uid, product_ids):
30 | 	    shell_data = self.prepare_shell_product(cr, uid, product)
31 | 	    storeview = False
32 | 	    result = self.upsert_shell_product(cr, uid, credentials, \
33 | 		shell_data, product, storeview
34 | 	    )
35 | 	return True
36 | 
37 | 
38 |     def prepare_shell_product(self, cr, uid, product):
39 | 	#visibility - 1 not visible individually
40 | 	#2 Catalog
41 | 	#3 search
42 | 	#4 Catalog, Search
43 | 
44 | 	#Tax Class - 0 None
45 | 	#2 Taxable Goods
46 | 	#4 Shipping
47 | 	#7 EOD Taxable Products
48 | 
49 | 	#status 1 Enabled
50 | 	#2 Disabled
51 | 
52 | #	cat_ids = [cat.external_id for cat in product.categ_ids]
53 | 	cat_ids = []
54 | 	web_ids = [web.external_id for web in product.websites]
55 | 
56 | 	vals = {
57 | 		'name': product.name,
58 | 		'description': product.description,
59 | 		'short_description': product.short_description,
60 | 		'weight': product.weight,
61 | 		'status': 2,
62 | 		'url_key': product.url_key or None,
63 | #		'url_path':
64 | 		'visibility': 1,
65 | 		'category_ids': cat_ids,
66 | 		'website_ids': web_ids,
67 | 		'price': 86753.09,
68 | 		'tax_class_id': product.mage_tax_class.external_id,
69 | 	}
70 | 	
71 | 
72 | 	return vals
73 | 
74 | 
75 |     def upsert_shell_product(self, cr, uid, credentials, shell_data, product, storeview):
76 |         try:
77 |             with API(credentials['url'], credentials['username'], credentials['password']) as product_api:
78 |                 external_id = product_api.call('oo_catalog_product.create', [product.mage_type, product.set.external_id, product.default_code, shell_data, storeview])
79 | 		self.pool.get('product.product').write(cr, uid, product.id, {'external_id': external_id, 'mage_last_sync_date': datetime.utcnow()})
80 |         except Exception, e:
81 |             raise osv.except_osv(_('Magento API Error!'),_(str(e)))
82 | 	    #TODO: Create Exception Object
83 |         return True
84 | 


--------------------------------------------------------------------------------
/jobs/backup_package:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | 
 4 | class MageIntegrator(osv.osv_memory):
 5 | 
 6 |     _inherit = 'mage.integrator'
 7 | 
 8 |     def sync_packages(self, cr, uid, job, context=None):
 9 | 	#This implementation is not good nor adaptable. This will need a rework
10 | 	package_obj = self.pool.get('stock.out.package')
11 |         storeview_obj = self.pool.get('mage.store.view')
12 |         store_ids = storeview_obj.search(cr, uid, [('do_not_import', '=', False)])
13 |         for storeview in storeview_obj.browse(cr, uid, store_ids):
14 | 	    package_ids = self.get_pending_packages(cr, uid, storeview.id)
15 | 	    for package in package_obj.browse(cr, uid, package_ids):
16 | 		if package.picking.sale.mage_shipment_complete and package.picking.external_id:
17 | 		    result = self.send_one_package(cr, uid, job, package.picking.external_id, package, True)
18 | 		    package.mage_package_state = 'done'
19 | 		    cr.commit()
20 | 		else:
21 | 		    shipping_id = self.send_one_package(cr, uid, job, package.picking.sale.mage_order_number, package, False)
22 | 		    if shipping_id:
23 | 			package.picking.external_id = shipping_id
24 | 			package.picking.mage_export_error = False
25 | 			package.mage_package_state = 'done'
26 | 			if not package.picking.sale.mage_shipment_complete:
27 | 			    package.picking.sale.mage_shipment_complete = True
28 | 
29 | 		    else:
30 | 			package.mage_package_state = 'exception'
31 | 			package.picking.mage_export_error = True
32 | 
33 | 		    cr.commit()
34 |         return True
35 | 
36 | 
37 |     #This is a temoporary method. Ideal solution does not involve a direct sql query
38 |     def get_pending_packages(self, cr, uid, storeview_id):
39 | 	query = "SELECT package.id" \
40 | 		" FROM stock_out_package package" \
41 | 		" JOIN stock_picking picking ON (package.picking = picking.id)" \
42 | 		" JOIN delivery_carrier carrier ON (picking.carrier_id = carrier.id)" \
43 | 		" JOIN sale_order sale ON (sale.id = picking.sale)" \
44 | 		" WHERE package.mage_package_state = 'pending'" \
45 | 		" AND sale.mage_store = %s LIMIT 100" % storeview_id
46 | 
47 |         cr.execute(query)
48 |         return [id[0] for id in cr.fetchall()]
49 | 
50 | 
51 |     def send_one_package(self, cr, uid, job, incrementid, package, track_only):
52 | 	#This is yucky business
53 | 	base_carrier = package.picking.carrier_id.mage_carrier
54 | 
55 | 	if track_only:
56 | 	    try:
57 | 		response = self._get_job_data(cr, uid, job, \
58 | 			'sales_order_shipment.addTrack', [incrementid, base_carrier, \
59 | 			'Shipped', package.tracking_number])
60 | 	    except Exception, e:
61 | 		print 'Exception', e
62 | 		return False
63 | 	else:
64 |             try:
65 | 		response = self._get_job_data(cr, uid, job, \
66 |                 	'sales_order_invoice.create_tracking', [incrementid, False, \
67 |                         False, False, package.tracking_number, base_carrier, 'Shipped'])
68 |             except Exception, e:
69 | 		print 'Exception', e
70 | 		return False
71 | 
72 | 
73 |         return response
74 | 


--------------------------------------------------------------------------------
/models/mapping.py:
--------------------------------------------------------------------------------
 1 | from openerp.osv import osv, fields
 2 | from pprint import pprint as pp
 3 | 
 4 | class MageMapping(osv.osv):
 5 |     _name = 'mage.mapping'
 6 | 
 7 | 
 8 |     def _get_related_model_ids(self, cr, uid, ids, name, arg, context=None):
 9 |         "Used to retrieve model field one can map without ambiguity. Fields come from Inherited objects"
10 |         res = {}
11 |         for mapping in self.browse(cr, uid, ids, context): #FIXME: could be fully recursive instead of only 1 level
12 |             main_model = mapping.model_id.model
13 |             inherits_model = [x for x in self.pool.get(main_model)._inherits]
14 |             model_ids = [mapping.model_id.id] + self.pool.get('ir.model').search(cr, uid, [['model','in', inherits_model]], context=context)
15 |             res[mapping.id] = model_ids
16 |         return res
17 | 
18 | 
19 |     def _related_model_ids(self, cr, uid, model, context=None):
20 |         inherits_model = [x for x in self.pool.get(model.model)._inherits]
21 |         model_ids = [model.id] + self.pool.get('ir.model').search(cr, uid, [['model','in', inherits_model]], context=context)
22 |         return model_ids
23 | 
24 | 
25 |     _columns = {
26 |         'name': fields.char('Name', required=True),
27 | 	'magento_id_fieldname': fields.char('Magento Id Fieldname'),
28 | 	'related_model_ids': fields.function(_get_related_model_ids, type="many2many", relation="ir.model", string='Related Inherited Models'),
29 |         'model_id': fields.many2one('ir.model', 'Odoo Object', required=True, ondelete='cascade'),
30 |         'model':fields.related('model_id', 'model', type='char', string='Object Name'),
31 |         'mapping_lines': fields.one2many('mage.mapping.line',
32 |                                         'mapping',
33 |                                         'Mapping Lines'),
34 |     }
35 | 
36 | 
37 | class MageMappingLine(osv.osv):
38 |     _name = 'mage.mapping.line'
39 |     _rec_name = 'field'
40 |     _columns = {
41 |         'mapping': fields.many2one('mage.mapping', "Mapping", select=True),
42 | 	'field': fields.many2one('ir.model.fields', 'Odoo Field', ondelete='cascade'),
43 | 	'internal_type': fields.related('field','ttype', type="char", relation='ir.model.field', string='Internal Type'),
44 | 	'relation': fields.related('field', 'relation', type="char", string="Relation"),
45 | 	'type': fields.selection([('in_out', 'Magento <-> Odoo'), ('in', 'Magento -> Odoo'), ('out', 'Magento <- Odoo')], 'Type'),
46 | 	'internal_field': fields.related('field', 'name', type='char', relation='ir.model.field', string='Field name',readonly=True),
47 | 	'datetime_format': fields.char('Datetime Format', size=32),
48 |         'child_mapping': fields.many2one('mage.mapping', 'Child Mapping'),
49 |         'mage_fieldname': fields.char('External Field Name', size=128),
50 |         'mapping_type': fields.selection([('sub-mapping','Sub Mapping Line'),
51 |                 			  ('direct', 'Direct Mapping'),
52 | 					  ('function', 'Function'),
53 | 	], 'Evalution Type', required=True),
54 | 	'function_name': fields.char('Function Name', help="Function must inherit class mage.integrator"),
55 |         'external_type': fields.selection([('datetime', 'Datetime'), ('unicode', 'String'), ('bool', 'Boolean'), ('int', 'Integer'),
56 |                 ('float', 'Float'), ('list', 'List'), ('dict', 'Dictionary')], 'External Type', required=True)
57 |     }
58 | 
59 | 
60 |     _defaults = {
61 |          'type' : lambda * a: 'in_out',
62 |          'external_type': lambda *a: 'unicode',
63 |          'mapping_type': lambda *a: 'direct',
64 |     }
65 | 
66 | 
67 | class IrModel(osv.osv):
68 |     _inherit = 'ir.model'
69 |     _columns = {
70 | 	'mage_info_method': fields.char('Magento Info Method'),
71 | 	'mage_create_mapping': fields.many2one('mage.mapping', 'Info Mapping'),
72 | 
73 |     }
74 | 


--------------------------------------------------------------------------------
/jobs/stock.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | from magento import API
  4 | from openerp.tools.translate import _
  5 | from datetime import datetime, timedelta
  6 | 
  7 | class MageIntegrator(osv.osv_memory):
  8 | 
  9 |     _inherit = 'mage.integrator'
 10 | 
 11 |     def mage_core_sync_stock(self, cr, uid, job):
 12 | 	instance = job.mage_instance
 13 | 
 14 |         integrator_obj = self.pool.get('mage.integrator')
 15 |         credentials = integrator_obj.get_external_credentials(cr, uid)
 16 | 	if not instance.sync_policy:
 17 | 	    #TODO: Raise error or something
 18 | 	    return True
 19 | 
 20 | 	if instance.sync_policy == 'all':
 21 | 	    return self.synchronize_all_magento_stock(cr, uid, job)
 22 | 
 23 | 	last_sync_date = instance.last_inventory_sync_date
 24 | 	print 'Last Sync Date', last_sync_date
 25 | 	if not last_sync_date:
 26 | 	    last_sync_date = datetime.utcnow() - timedelta(days=1)
 27 | 
 28 | 	move_query = "SELECT DISTINCT product_id" + \
 29 | 		" FROM stock_move" + \
 30 | 		" WHERE state NOT IN ('draft', 'cancel')" + \
 31 | 		" AND create_date > '%s'" % last_sync_date
 32 | 
 33 | 	cr.execute(move_query)
 34 | 	move_data = cr.dictfetchall()
 35 | 	instance.last_sync_date = datetime.utcnow()
 36 | #	move_ids = [d['product_id'] for d in move_data]
 37 | 	move_ids = [44655]
 38 | 	if not move_ids:
 39 | 	    print 'No Move Data'
 40 | 	    return
 41 | 	bom_query = "SELECT product.id" + \
 42 | 		" FROM mrp_bom_line line" + \
 43 | 		" JOIN mrp_bom bom ON (line.bom_id = bom.id)" + \
 44 | 		" JOIN product_product product ON (bom.product_tmpl_id = product.product_tmpl_id)" + \
 45 | 		" WHERE line.product_id IN (%s)" % str(move_ids).replace('[', '').replace(']', '')
 46 | 	cr.execute(bom_query)
 47 | 	bom_data = cr.dictfetchall()
 48 | 	if bom_data:
 49 | 	    bom_ids = [b['id'] for b in bom_data]
 50 |             move_ids.extend(bom_ids)
 51 | 	print 'Move IDS', move_ids
 52 | 	return self.sync_mage_stock_product_ids(cr, uid, credentials, move_ids)
 53 | 
 54 | 
 55 |     def synchronize_all_magento_stock(self, cr, uid, job):
 56 |         integrator_obj = self.pool.get('mage.integrator')
 57 |         credentials = integrator_obj.get_external_credentials(cr, uid)
 58 | 
 59 | 	product_obj = self.pool.get('product.product')
 60 | 	product_ids = product_obj.search(cr, uid, [('sync_stock', '=', True), ('sync_to_mage', '=', True)])
 61 | 	return self.sync_mage_stock_product_ids(cr, uid, product_ids)
 62 | 
 63 | 
 64 |     def sync_mage_stock_product_ids(self, cr, uid, credentials, product_ids):
 65 | 	product_data = {}
 66 | 	product_obj = self.pool.get('product.product')
 67 | 	for product in product_obj.browse(cr, uid, product_ids):
 68 | 
 69 | 	    print product.name
 70 | 	    if not product.external_id or product.external_id < 1:
 71 | 		print 'Skipping'
 72 | 		continue
 73 | 	    qty = product.immediately_usable_qty
 74 | 	    always_in_stock = product.always_in_stock
 75 | 	    manage_stock = product.manage_stock
 76 | 	    use_config = product.use_config_manage_stock
 77 | 	    if always_in_stock:
 78 | 		is_in_stock = 1
 79 | 	    elif qty > 1:
 80 | 		is_in_stock = 1
 81 | 	    else:
 82 | 		is_in_stock = 0
 83 | 
 84 | 	    product_data[str(product.external_id)] = {
 85 | 		'is_in_stock': is_in_stock,
 86 | 		'qty': int(qty),
 87 | 		'manage_stock': 1 if manage_stock else 0,
 88 | 		'config_manage_stock': 1 if use_config else 0,
 89 | 	    }
 90 | 
 91 | 	print 'HERE'
 92 | 	return self.push_magento_product_stock(cr, uid, credentials, product_data)
 93 | 
 94 | 
 95 |     def push_magento_product_stock(self, cr, uid, credentials, product_data):
 96 | 	print 'CALLING FUNCTION'
 97 | 	try:
 98 | 	    pp(product_data)
 99 | 	    with API(credentials['url'], credentials['username'], credentials['password']) as product_api:
100 | 		results = product_api.call('oo_catalog_product.updateproductstock', [product_data])
101 | 		print 'Results', results
102 | 	except Exception, e:
103 | 	    raise osv.except_osv(_('Magento API Error!'),_(str(e)))
104 | 
105 |         return True
106 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Mage2Odoo - Turn Key Solution for Magento
  2 | ---------
  3 | 
  4 | Tested working with Odoo 8.0 Revision 04b252b72c3bb5568f002e05d2fa889a1b4aae90
  5 | 
  6 | 
  7 | General Requirements
  8 | --------------------
  9 | 
 10 | Requires Python libraries
 11 | -------------------------
 12 | 
 13 | PIL
 14 | 
 15 | pycountry
 16 | 
 17 | https://github.com/aliomattux/magento
 18 | 
 19 | 
 20 | Required Magento Module
 21 | -----------------------
 22 | https://github.com/aliomattux/Openobject_OpenobjectConnector
 23 | 
 24 | 
 25 | Requires Odoo Modules
 26 | --------------------
 27 | https://github.com/aliomattux/payment_method
 28 | 
 29 | delivery - Odoo Module
 30 | 
 31 | https://github.com/aliomattux/stock_package
 32 | 
 33 | https://github.com/aliomattux/product_sku_upc
 34 | 
 35 | 
 36 | Recommended Server patches
 37 | --------------------------
 38 | 
 39 | Repo: https://github.com/aliomattux/server_patches
 40 | 
 41 | Login Patch
 42 | 
 43 | This patch will prevent a frequent concurrent access update.
 44 | All scheduled jobs in Mage2Odoo run on the superuser account. If any one person logs in or clicks any button, performs any action,
 45 | The server will cancel the currenly running job because of a SELECT FOR UPDATE NOWAIT hack. This method def login also writes the last logged in
 46 | timestamp, which can cause cascading write concurrency issues.
 47 | 
 48 | Sale Order Line Patch
 49 | 
 50 | There is a bug in method create in sale module for sale_order_line class. The onchange method for product will reset all default values
 51 | if the field 'type' is not specified in the vals. This field does not exist so it will always do this. Remove this field from the methd
 52 | 
 53 | Updating relational many2many tables
 54 | 
 55 | The ORM will currently iterate over each item and execute a delete statement which is exponentially slow. This patch does a single DELETE FROM query
 56 | which will save serious time when performing large batching operations
 57 | 
 58 | 
 59 | Optional Addons
 60 | ---------------
 61 | 
 62 | https://github.com/aliomattux/mage2odoo_sale_automation
 63 | 
 64 | This module can automate synchronizing historical data. It can also auto pay/auto deliver sales orders that are paid/delivered in Magento
 65 | 
 66 | https://github.com/aliomattux/mage2odoo_cart_shippping_quote
 67 | 
 68 | This module will allow you to take your Odoo quote and get a shipping quote for every carrier you offer on Magento.
 69 | You can add the shipping cost to your Odoo quote
 70 | 
 71 | https://github.com/aliomattux/mage2odoo_authorizenet
 72 | 
 73 | This module in addition to our Authorize.net module will allow you to process credit card transactions in Odoo
 74 | Supports full/partial authorization and capture in Odoo. *Only supports secured payment tokens.
 75 | 
 76 | https://github.com/aliomattux/mage2odoo_operations
 77 | 
 78 | This module adds functionality to the delivery order object and adds information on the deliveries about your Magento Store
 79 | 
 80 | https://github.com/aliomattux/mage2odoo_salesman
 81 | 
 82 | Amasty Salesman module
 83 | 
 84 | This module will import salesman to Odoo when assigned to a sales order in Magento
 85 | 
 86 | https://github.com/aliomattux/mage2odoo_custom_shipping_account
 87 | 
 88 | This module adds functionality to the sales order similar to a custom Magento module that allows you to specify a customers shipping account for FedEx/UPS
 89 | 
 90 | https://github.com/aliomattux/mage2odoo_cart2quote
 91 | 
 92 | This module allows you to integrate Cart2Quote module for Magento with Odoo. This module can create Quotes in Magento that can be validated from Odoo
 93 | 
 94 | https://github.com/aliomattux/mage2odoo_product_links
 95 | 
 96 | This module allows you to import product upsell/cross sell from Magento. You can pop up window in sale order lines, just as you would in Magento to select options.
 97 | 
 98 | 
 99 | Donate to our project
100 | ---------------------
101 | 
102 | If you are interested in donating, or are interesting in funding enhancements please contact me kyle.waid@gcotech.com
103 | 


--------------------------------------------------------------------------------
/models/mage_api.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from openerp.tools.translate import _
  3 | from pprint import pprint as pp
  4 | from magento import API
  5 | import socket
  6 | import xmlrpclib
  7 | 
  8 | #class MageLog(osv.osv):
  9 | #    _name = 'mage.log'
 10 | #    _columns = {
 11 | #	'name': fields.char('Magento ID'),
 12 | #	'job': fields.many2one('mage.job', 'Job Failed on'),
 13 | #	'except_msg': fields.text('Exception Reason'),
 14 | #	'datetime': fields.datetime('Date Exception Occurred'),
 15 | #    }
 16 | 
 17 | 
 18 | class MageIntegrator(osv.osv):
 19 |     _name = 'mage.integrator'
 20 | 
 21 |     def get_external_credentials(self, cr, uid):
 22 | 	mage_obj = self.pool.get('mage.setup')
 23 | 	setup_ids = mage_obj.search(cr, uid, [], limit=1)
 24 | 	if setup_ids:
 25 | 	    instance = mage_obj.browse(cr, uid, setup_ids[0])
 26 | 	    return {
 27 | 		'url': instance.url,
 28 | 		'username': instance.username,
 29 | 		'password': instance.password,
 30 | 	    }
 31 | 	else:
 32 | 	    raise osv.except_osv(_('Config Error'), _('You must have already configured Magento to run this function!'))
 33 | 	    
 34 | 
 35 |     def _get_credentials(self, job):
 36 |         return {
 37 |                 'url': job.mage_instance.url,
 38 |                 'username': job.mage_instance.username,
 39 |                 'password': job.mage_instance.password,
 40 |         }
 41 | 
 42 | 
 43 |     def _get_job_data(self, cr, uid, job, method, arguments):
 44 |         credentials = self._get_credentials(job)
 45 | 	return self._mage_call(credentials, method, arguments)
 46 | 
 47 | 
 48 |     def get_magento_region_id(self, cr, uid, credentials, country_id, state_name):
 49 |         with API(credentials['url'], credentials['username'], credentials['password']) as mage_api:
 50 |             region_id = mage_api.call('sales_order.getregionid', [country_id, state_name])
 51 |             return region_id
 52 | 
 53 | 
 54 |     #This method copied from magentoerpconnect for v7
 55 |     def _mage_call(self, credentials, method, arguments):
 56 |         try:
 57 |             with API(credentials['url'],
 58 |                                 credentials['username'],
 59 |                                 credentials['password']) as mage_api:
 60 |                 return mage_api.call(method, arguments)
 61 | 
 62 |         except (socket.gaierror, socket.error, socket.timeout) as err:
 63 | 	    raise osv.except_osv(_('Network/URL Config Error'), _('Either you entered the URL in wrong or you have no internet connectivity'))
 64 |         except xmlrpclib.ProtocolError as err:
 65 |             if err.errcode in [502,   # Bad gateway
 66 |                                503,   # Service unavailable
 67 |                                504]:  # Gateway timeout
 68 | 		raise osv.except_osv(_('Connection Error'), _('Server Returned Error Code: %s')%err.errcode)
 69 |             else:
 70 | 		print 'ERROR CODE', err.errcode
 71 | 		raise osv.except_osv(_('Generic Connection Error'), _("Could Not Authenticate/Connect with Magento!\n" \
 72 | 			"Please verify that\n1. The Magento module is installed in the LOCAL folder on Magento.\n" \
 73 | 			"2. Your webservice user in Magento is setup with FULL Admin access.\n" \
 74 | 			"3. Verify your Odoo server can reach Magento.\n" \
 75 | 			"4. Verify that you have entered the correct Credentials"))
 76 | 
 77 | 	except Exception, e:
 78 | 	    raise osv.except_osv(_('Magento Returned an Error'), _('%s')%e)
 79 | 
 80 | 
 81 |     def _get_product_type_selections(self, cr, uid, job, conversion_type, \
 82 | 		mappingline, record):
 83 | 
 84 | 	type_obj = self.pool.get('mage.product.type')
 85 | 	print mappingline
 86 | 	print record
 87 | #	attribute_obj = self.pool.get('product.attribute')
 88 | #	assigned_types = field_value.split(',')
 89 | #	for type in assigned_types:
 90 | #	    type_id = type_obj.search(cr, uid, [('type', '=', type)])
 91 | #	    attribute_obj.write(cr, uid, 
 92 | 	return {}
 93 | 
 94 | 
 95 |     def _get_attribute_type_conversion(self, cr, uid, job, conversion_type, \
 96 | 		mappingline, record):
 97 | 
 98 | 	attribute_obj = self.pool.get('product.attribute')
 99 | 	transform_dict = attribute_obj._frontend_options()
100 | 	pp(record)
101 | 	return {'ttype': transform_dict[record[mappingline['mage_fieldname']]]}
102 | 


--------------------------------------------------------------------------------
/views/core.xml:
--------------------------------------------------------------------------------
  1 | <openerp>
  2 |     <data>
  3 |         <menuitem name="Mage2Odoo"
  4 |         id="menu_mage_core"
  5 | 	groups="group_mage2odoo_manager"
  6 |         sequence="60"/>
  7 | 
  8 |         <menuitem name="Configuration"
  9 |         id="menu_mage_configuration"
 10 |         parent="menu_mage_core"
 11 |         sequence="100"/>
 12 | 
 13 |         <record id="view_mage_setup_tree" model="ir.ui.view">
 14 |             <field name="name">Mage Setup Tree</field>
 15 |             <field name="model">mage.setup</field>
 16 |             <field name="arch" type="xml">
 17 |                 <tree>
 18 |                     <field name="name" />
 19 | 		    <field name="url" />
 20 |                 </tree>
 21 |             </field>
 22 |         </record>
 23 | 
 24 |         <record id="view_mage_setup_form" model="ir.ui.view">
 25 |             <field name="name">Mage Setup Form</field>
 26 |             <field name="model">mage.setup</field>
 27 |             <field name="arch" type="xml">
 28 | 		<form>
 29 | 		    <sheet>
 30 | 			<h1>
 31 | 			    <label string="Configure your Magento Integration" />
 32 | 			</h1>
 33 | 			<br/>
 34 | 			<group string="Integration Name">
 35 | 		            <h1>
 36 |                                 <field name="name" />
 37 | 		            </h1>
 38 | 			</group>
 39 | 		        <group colspan="4">
 40 |                             <field name="url" />
 41 | 		        </group>
 42 | 		        <group string="Credentials">
 43 | 			    <field name="username"/>
 44 | 			    <field name="password" password="1" />
 45 | 			    <field name="sentry_dsn" />
 46 | 			    <field name="debug_mode" />
 47 | 		        </group>
 48 | 			<group string="Order Policy Defaults">
 49 | 			    <field name="states_or_statuses" />
 50 | 			    <field name="picking_policy" />
 51 | 			    <field name="invoice_policy" />
 52 | 			</group>
 53 | 			<group string="Accounting">
 54 | 			    <field name="use_order_date" />
 55 | 			    <field name="pay_sale_if_paid" />
 56 | 			    <field name="use_invoice_date"
 57 | 				attrs="{'invisible': [('pay_sale_if_paid', '=', False)]}"/>
 58 | 			    <field name="default_fiscal_position" />
 59 | 			</group>
 60 | 			<group string="Inventory Sync">
 61 | 			   <field name="last_inventory_sync_date" />
 62 | 			   <field name="sync_policy" />
 63 | 			   <field name="include_boms" />
 64 | 			</group>
 65 | 			<group string="Shipping">
 66 | 			    <field name="default_shipping_partner" required="1" />
 67 | 			    <field name="shipping_product" required="1" />
 68 | 			    <field name="deliver_if_delivered" />
 69 | 			    <field name="use_order_date_as_delivery_date"
 70 | 				attrs="{'invisible': [('deliver_if_delivered', '=', False)]}"/>
 71 | 			</group>
 72 | 			<group string="Customers">
 73 | 			    <field name="last_imported_customer" />
 74 | 			</group>
 75 | 			<group string="Products" >
 76 | 			    <field name="integrity_product" />
 77 | 			    <field name="import_disabled_products" />
 78 | 			    <field name="default_product_tax" />
 79 | 			    <field name="nontaxable_tax_class_id" />
 80 | 			    <field name="import_images" />
 81 | 			    <field name="import_images_method"
 82 |                                 attrs="{'required': [('import_images', '=', True)],
 83 |                                         'invisible': [('import_images', '=', False)]}" />
 84 | 			    <field name="images_storage" 
 85 | 				attrs="{'required': [('import_images', '=', True)],
 86 | 					'invisible': [('import_images', '=', False)]}" />
 87 | 			</group>
 88 |                         <group string="Statuses" colspan="4">
 89 |                             <field name="order_statuses" colspan="4" nolabel="1" widget="many2many_tags">
 90 |                             </field>
 91 |                         </group>
 92 |                     </sheet>
 93 | 		</form>
 94 |             </field>
 95 |         </record>
 96 | 
 97 |         <record id="action_mage_setup" model="ir.actions.act_window">
 98 |             <field name="name">Magento Setup</field>
 99 |             <field name="res_model">mage.setup</field>
100 |             <field name="type">ir.actions.act_window</field>
101 |             <field name="view_type">form</field>
102 |             <field name="view_id" ref="view_mage_setup_tree"/>
103 |         </record>
104 | 
105 |         <menuitem action="action_mage_setup"
106 |         id="menu_mage_setup"
107 | 	parent="menu_mage_configuration"
108 |         sequence="50"/>
109 | 
110 |    </data>
111 | </openerp>
112 | 


--------------------------------------------------------------------------------
/views/mapping.xml:
--------------------------------------------------------------------------------
  1 | <openerp>
  2 |     <data>
  3 | 
  4 |         <record id="view_mage_mapping_tree" model="ir.ui.view">
  5 |             <field name="name">Mage Mapping Tree</field>
  6 |             <field name="model">mage.mapping</field>
  7 |             <field name="arch" type="xml">
  8 |                 <tree>
  9 |                     <field name="name" />
 10 | 		    <field name="model_id" />
 11 |                 </tree>
 12 |             </field>
 13 |         </record>
 14 | 
 15 | 
 16 |         <record id="mage_mapping_form" model="ir.ui.view">
 17 |             <field name="name">Mage Mapping Form</field>
 18 |             <field name="model">mage.mapping</field>
 19 |             <field name="arch" type="xml">
 20 | 		<form string="Object Mappings">
 21 | 		    <group colspan="4">
 22 | 		        <field name="name" />
 23 | 		        <field name="model_id" />
 24 | 			<field name="magento_id_fieldname" />
 25 | 		        <field name="related_model_ids" invisible="1" />
 26 | 		    </group>
 27 | 		    <newline/>
 28 | 		    <separator string="Mapping Lines" colspan="4" col="8" />
 29 | 		    <field colspan="4" name="mapping_lines" widget="one2many_list" context="{'model_id':model_id}" nolabel="1">
 30 | 		        <tree>
 31 | 			    <field name="mage_fieldname" />
 32 | 			    <field name="external_type" />
 33 | 			    <field name="field" />
 34 | 			    <field name="internal_type" />
 35 | 			    <field name="mapping_type" />
 36 | 			    <field name="type" />
 37 | 			</tree>
 38 | 			<form string="Mapping Lines">
 39 | 			    <field name="mapping" invisible="1"/>
 40 | 			    <group colspan="2">
 41 | 				<field name="mage_fieldname" />
 42 | 				<field name="datetime_format" attrs="{'invisible':[('external_type','!=','datetime')]}"/>
 43 |                 		<field name="external_type" />
 44 | 			    </group>
 45 | 			    <group colspan="2">
 46 |                                 <field name="field" domain="[('model_id','in',parent.related_model_ids[0][2])]"
 47 |                                                 attrs="{'required':[('mapping_type','in',['direct', 'sub-mapping'])],
 48 |                                                 'invisible':[('mapping_type', '=', 'function')]}"/>
 49 |                             	<field name="child_mapping" colspan="2"
 50 |                                     		attrs="{'invisible':[('mapping_type','!=','sub-mapping')],
 51 |                                                 'required':[('mapping_type','=','sub-mapping')]}"/>
 52 | 				<field name="internal_type" readonly="1" />
 53 | 			    <field name="relation" invisible="1" />
 54 | 			    </group>
 55 | 			    <group name="type_fields" >
 56 |                 		<field name="mapping_type" />
 57 | 				<field name="function_name" attrs="{'invisible': 
 58 | 				[('mapping_type', '!=', 'function')],
 59 | 				'required': [('mapping_type', '=', 'function')]}" />
 60 | 				<field name="type" />
 61 | 			    </group>
 62 | 			</form>
 63 | 		    </field>
 64 | 		</form>
 65 |             </field>
 66 |         </record>
 67 | 
 68 | 
 69 |         <record id="view_mage_mapping_line_tree" model="ir.ui.view">
 70 |             <field name="name">Mage Mapping Line Tree</field>
 71 |             <field name="model">mage.mapping.line</field>
 72 |             <field name="arch" type="xml">
 73 |                 <tree>
 74 | 		    <field name="mapping" />
 75 | 		    <field name="mage_fieldname" />
 76 | 		    <field name="external_type" />
 77 | 		    <field name="field" />
 78 | 		    <field name="internal_type" />
 79 |                 </tree>
 80 |             </field>
 81 |         </record>
 82 | 
 83 | 
 84 |         <record id="action_mage_mapping" model="ir.actions.act_window">
 85 |             <field name="name">Object Mappings</field>
 86 |             <field name="res_model">mage.mapping</field>
 87 |             <field name="type">ir.actions.act_window</field>
 88 |             <field name="view_type">form</field>
 89 |             <field name="view_id" ref="view_mage_mapping_tree"/>
 90 |         </record>
 91 | 
 92 |         <record id="action_mage_mapping_line" model="ir.actions.act_window">
 93 |             <field name="name">Object Line Mappings</field>
 94 |             <field name="res_model">mage.mapping.line</field>
 95 |             <field name="type">ir.actions.act_window</field>
 96 |             <field name="view_type">form</field>
 97 |             <field name="view_id" ref="view_mage_mapping_line_tree"/>
 98 |         </record>
 99 | 
100 |         <menuitem action="action_mage_mapping"
101 |         id="menu_mage_mapping"
102 | 	parent="menu_mage_configuration"
103 |         sequence="20"/>
104 | 
105 |         <menuitem action="action_mage_mapping_line"
106 |         id="menu_mage_mapping_line"
107 |         parent="menu_mage_configuration"
108 |         sequence="30"/>
109 | 
110 |    </data>
111 | </openerp>
112 | 


--------------------------------------------------------------------------------
/jobs/metadata.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | from openerp.tools.translate import _
  4 | 
  5 | class MageIntegrator(osv.osv_memory):
  6 | 
  7 |     _inherit = 'mage.integrator'
  8 | 
  9 | 
 10 |     def sync_mage_metadata(self, cr, uid, job, context=None):
 11 | 	try:
 12 |             self.import_websites(cr, uid, job)
 13 |             self.import_store_groups(cr, uid, job)
 14 |             self.import_store_views(cr, uid, job)
 15 |             self.sync_mage_carriers(cr, uid, job)
 16 | 	#TODO: Requires investigation
 17 | #	    self.sync_all_taxes(cr, uid, job)
 18 | #            self.sync_instance_order_statuses(cr, uid, job)
 19 | 
 20 | 	except Exception, e:
 21 | 	    raise osv.except_osv(_('Metadata Sync Error'), _(str(e)))
 22 | 
 23 |         return True
 24 | 
 25 | 
 26 |     def sync_mage_carriers(self, cr, uid, job, context=None):
 27 | 	records = self._get_job_data(cr, uid, job, 'sales_order.shipping_methods', [])
 28 |         carrier_obj = self.pool.get('delivery.carrier')
 29 | 
 30 |         for record in records:
 31 | 	    for method in record['methods']:
 32 |                 vals = carrier_obj.prepare_odoo_record_vals(cr, uid, job, method)
 33 |                 carrier = carrier_obj.upsert_mage_record(cr, uid, vals)
 34 |                 print carrier
 35 | 
 36 | 	return True
 37 | 
 38 | 
 39 |     def sync_all_taxes(self, cr, uid, job, context=None):
 40 |         records = self._get_job_data(cr, uid, job, 'sales_order.taxes_info', [])
 41 |         tax_obj = self.pool.get('account.tax')
 42 | 
 43 |         for tax in records:
 44 | 	    print tax
 45 | 	    tax_ids = tax_obj.search(cr, uid, [('name', '=', tax['code'])])
 46 | 	    if tax_ids:
 47 | 		continue
 48 | 	    else:
 49 | 		vals = {'name': tax['code'],
 50 | 			'amount': float(tax['rate']) / 100,
 51 | 			'mage_tax': True,
 52 | 			'description': tax['code'],
 53 | 		}
 54 | 		tax_id = tax_obj.create(cr, uid, vals)
 55 | 
 56 | 	return True
 57 | 
 58 | 
 59 |     def sync_instance_order_statuses(self, cr, uid, job, context=None):
 60 |         records = self._get_job_data(cr, uid, job, 'sales_order.get_order_states', [])
 61 |         mage_order_state_obj = self.pool.get('mage.mapping.order.state')
 62 |         for state, state_name in records.items():
 63 | 	    statuses = self._get_job_data(cr, uid, job, 'sales_order.get_order_statuses', [state])
 64 | 	    for k, v in statuses.items():
 65 | 		print 'State', state
 66 | 		print 'Status', k
 67 |                 vals = {'mage_order_state': state,
 68 | 		        'mage_order_status': k,
 69 | 			'mage_order_status_name': v,
 70 |                         'name': v
 71 |                 }
 72 |                 existing_ids = mage_order_state_obj.search(cr, uid,
 73 |                     [('mage_order_status', '=', k)])
 74 | 
 75 |                 if not existing_ids:
 76 |                     result = mage_order_state_obj.create(cr, uid, vals)
 77 |                     print (True, result)
 78 |                 else:
 79 | 		    mage_order_state_obj.write(cr, uid, existing_ids[0], vals)
 80 |                     print (False, existing_ids[0])
 81 | 
 82 |         return True
 83 | 
 84 | 
 85 |     def import_websites(self, cr, uid, job, context=None):
 86 | 	website_obj = self.pool.get('mage.website')
 87 |         records = self._get_job_data(cr, uid, job, 'oo_websites.list', [])
 88 |         for record in records:
 89 |             vals = website_obj.prepare_odoo_record_vals(cr, uid, job, record)
 90 |             result = website_obj.upsert_mage_record(cr, uid, vals)
 91 |             print result
 92 | 
 93 |         return True
 94 | 
 95 | 
 96 |     def import_store_groups(self, cr, uid, job, context=None):
 97 | 	group_obj = self.pool.get('mage.store.group')
 98 |         records = self._get_job_data(cr, uid, job, 'oo_groups.list', [])
 99 |         for record in records:
100 |             vals = group_obj.prepare_odoo_record_vals(cr, uid, job, record)
101 |             result = group_obj.upsert_mage_record(cr, uid, vals)
102 |             print result
103 | 
104 |         return True
105 | 
106 | 
107 |     def import_store_views(self, cr, uid, job, context=None):
108 | 	storeview_obj = self.pool.get('mage.store.view')
109 | 
110 |         records = self._get_job_data(cr, uid, job, 'oo_storeviews.list', [])
111 | 	for record in records:
112 | 	    vals = storeview_obj.prepare_odoo_record_vals(cr, uid, job, record)
113 | 	    result = storeview_obj.upsert_mage_record(cr, uid, vals)
114 | 	    print result
115 | 
116 | 	return True
117 | 
118 | 
119 | #    def process_mage_websites_response(self, cr, uid, job, mappinglines, records):
120 | #        target_obj = self.pool.get(job.mapping.model_id.model)
121 | 
122 | #        for record in records:
123 | #            vals = self._transform_record(cr, uid, job, record, 'from_mage_to_odoo', mappinglines)
124 | #            result = target_obj.upsert_mage_data(cr, uid, vals)
125 | #        return True
126 | 
127 | 
128 | 


--------------------------------------------------------------------------------
/jobs/attribute.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | 
  4 | 
  5 | class MageIntegrator(osv.osv_memory):
  6 | 
  7 |     _inherit = 'mage.integrator'
  8 | 
  9 | 
 10 |     def sync_mage_attribute_data(self, cr, uid, job, context=None):
 11 | 	self.import_attribute_sets(cr, uid, job)
 12 | 	self.import_attribute_groups(cr, uid, job)
 13 | 	self.import_attributes(cr, uid, job)
 14 | 	self.import_attribute_values(cr, uid, job)
 15 | 	self.import_attribute_groups_attribute_relation(cr, uid, job)
 16 | 	return True
 17 | 
 18 | 
 19 |     def import_attribute_sets(self, cr, uid, job, context=None):
 20 | 	set_obj = self.pool.get('product.attribute.set')
 21 | 	records = self._get_job_data(cr, uid, job, 'catalog_product_attribute_set.list', [])
 22 | 	for record in records:
 23 | 	    vals = set_obj.prepare_odoo_record_vals(cr, uid, job, record)
 24 | 	    result = set_obj.upsert_mage_record(cr, uid, vals)
 25 | 	    print result
 26 | 
 27 | 	return True
 28 | 
 29 | 
 30 |     def import_attribute_groups(self, cr, uid, job, context=None):
 31 | 	set_obj = self.pool.get('product.attribute.set')
 32 | 	group_obj = self.pool.get('product.attribute.group')
 33 | 	set_ids = set_obj.search(cr, uid, [])
 34 | 	set_data = set_obj.read(cr, uid, set_ids, fields=['external_id'])
 35 | 	sets = [x['external_id'] for x in set_data]
 36 | 	records = self._get_job_data(cr, uid, job, 'oo_catalog_product_attribute_group.list', \
 37 | 		[{'attribute_set_id': {'in': sets}}])
 38 | 
 39 | 	for record in records:
 40 | 	    vals = group_obj.prepare_odoo_record_vals(cr, uid, job, record)
 41 | 	    result = group_obj.upsert_mage_record(cr, uid, vals)
 42 | 	    print result
 43 | 
 44 | 	return True
 45 | 	    	    
 46 | 
 47 |     def import_attributes(self, cr, uid, job, context=None):
 48 | 	attribute_obj = self.pool.get('product.attribute')
 49 |         records = self._get_job_data(cr, uid, job, 'oo_catalog_product_attribute.list', [])
 50 | 	for record in records:
 51 |             if record.get('is_visible') == '0':
 52 |                 continue
 53 | 	    vals = attribute_obj.prepare_odoo_record_vals(cr, uid, job, record)
 54 | 	    result = attribute_obj.upsert_mage_record(cr, uid, vals)
 55 | 
 56 | 	return True
 57 | 	
 58 | 
 59 |     def import_attribute_values(self, cr, uid, job, context=None):
 60 |        attr_obj = self.pool.get('product.attribute')
 61 |        value_obj = self.pool.get('product.attribute.value')
 62 |        attr_ids = attr_obj.search(cr, uid, [('is_user_defined', '=', True)])
 63 |        attr_data = attr_obj.read(cr, uid, attr_ids, fields=['external_id'])
 64 |        attributes = [x['external_id'] for x in attr_data]
 65 |        for attribute in attributes:
 66 |             records = self._get_job_data(cr, uid, job, 'oo_catalog_product_attribute.options', [attribute])
 67 | 	    for record in records:
 68 | 		vals = value_obj.prepare_odoo_record_vals(cr, uid, job, record)
 69 | 		value_obj.upsert_mage_record(cr, uid, vals)
 70 | 
 71 |        return True
 72 | 
 73 | 
 74 |     def process_mage_attribute_response(self, cr, uid, job, mappinglines, records):
 75 | 	target_obj = self.pool.get(job.mapping.model_id.model)
 76 | 
 77 | 	for record in records:
 78 | 	    #This needs to be fixed on Magento
 79 | 	    if record.get('is_visible') == '0':
 80 | 		continue
 81 | 		
 82 |         return True
 83 | 
 84 | 
 85 |     def find_attribute_group_relationship(self, cr, uid, attr_data):
 86 | 	result = {}
 87 | 	attr_obj = self.pool.get('product.attribute')
 88 | 	group_obj = self.pool.get('product.attribute.group')
 89 | 	attr_ids = attr_obj.search(cr, uid, [('external_id', '=', attr_data['attribute_id'])])
 90 | 	#This needs to be fixed in Magento
 91 | 	if not attr_ids:
 92 | 	    return False
 93 | 	result['attribute'] = attr_ids[0]
 94 | 	group_ids = group_obj.search(cr, uid, [('external_id', '=', attr_data['group_id'])])
 95 | 	result['group'] = group_ids[0]
 96 | 	return result
 97 | 
 98 | 
 99 |     def import_attribute_groups_attribute_relation(self, cr, uid, job, context=None):
100 |         set_obj = self.pool.get('product.attribute.set')
101 |         set_ids = set_obj.search(cr, uid, [])
102 |         set_data = set_obj.read(cr, uid, set_ids, fields=['external_id'])
103 |         sets = [x['external_id'] for x in set_data]
104 | 	group_obj = self.pool.get('product.attribute.group')
105 | 	buffer = {}
106 | 	for set in sets:
107 |             records = self._get_job_data(cr, uid, job, 'oo_catalog_product_attribute.relations', [set])
108 | 	    count = 0
109 | 	    for record in records:
110 | 		if not record['attribute_id']:
111 | 		    count += 1
112 | 		    continue
113 | 		#This needs to be fixed in Magento
114 | 		dic = self.find_attribute_group_relationship(cr, uid, record)
115 | 		if not dic:
116 | 		    continue
117 | 		if dic['group'] not in buffer.keys():
118 | 		    buffer[dic['group']] = [dic['attribute']]
119 | 		else:
120 | 		    buffer[dic['group']].append(dic['attribute'])
121 | 
122 | 	    for k, v in buffer.items():
123 | 	        group_obj.write(cr, uid, k, 
124 | 	        {'attributes': [(6, 0, v)]})
125 | 
126 | 	return True
127 | 


--------------------------------------------------------------------------------
/models/country.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv
  2 | from openerp.tools.translate import _
  3 | import pycountry
  4 | 
  5 | 
  6 | class ResCountry(osv.osv):
  7 |     _inherit = 'res.country'
  8 | 
  9 |     def search_using_magento_code(self, cursor, user, code, context):
 10 |         """
 11 |         Searches for country with given magento code.
 12 | 
 13 |         :param cursor: Database cursor
 14 |         :param user: ID of current user
 15 |         :param code: ISO code of country
 16 |         :param context: Application context
 17 |         :return: Browse record of country if found else raises error
 18 |         """
 19 |         country_ids = self.search(
 20 |             cursor, user, [('code', '=', code.upper())], context=context
 21 |         )
 22 | 
 23 |         if not country_ids:
 24 |             raise osv.except_osv(
 25 |                 _('Not Found!'),
 26 |                 _('Country with ISO code %s does not exists.' % code)
 27 |             )
 28 | 
 29 |         country = self.browse(
 30 |             cursor, user, country_ids[0], context=context
 31 |         )
 32 | 
 33 |         return country
 34 | 
 35 | 
 36 | class ResCountryState(osv.Model):
 37 |     _inherit = 'res.country.state'
 38 | 
 39 |     def find_or_create_using_magento_region(
 40 |         self, cursor, user, country, region, context
 41 |     ):
 42 |         """
 43 |         Looks for the state whose `region` is sent by magento in `country`
 44 |         If state already exists, return that else create a new one and
 45 |         return
 46 | 
 47 |         :param cursor: Database cursor
 48 |         :param user: ID of current user
 49 |         :param country: Browse record of country
 50 |         :param region: Name of state from magento
 51 |         :param context: Application context
 52 |         :return: Browse record of record created/found
 53 |         """
 54 |         state = self.find_using_magento_region(
 55 |             cursor, user, country, region, context
 56 |         )
 57 |         if not state:
 58 |             state = self.create_using_magento_region(
 59 |                 cursor, user, country, region, context
 60 |             )
 61 | 
 62 |         return state
 63 | 
 64 | 
 65 |     def find_using_magento_region(
 66 |         self, cursor, user, country, region, context
 67 |     ):
 68 |         """
 69 |         Looks for the state whose `region` is sent by magento
 70 |         If state already exists, return that
 71 | 
 72 |         :param cursor: Database cursor
 73 |         :param user: ID of current user
 74 |         :param country: Browse record of country
 75 |         :param region: Name of state from magento
 76 |         :param context: Application context
 77 |         :return: Browse record of record found
 78 |         """
 79 |         state_ids = self.search(
 80 |             cursor, user, [
 81 |                 ('name', '=', region),
 82 |                 ('country_id', '=', country.id),
 83 |             ], context=context
 84 |         )
 85 | 
 86 |         return state_ids and self.browse(
 87 |             cursor, user, state_ids[0], context=context
 88 |         ) or None
 89 | 
 90 | 
 91 |     def create_using_magento_region(
 92 |         self, cursor, user, country, region, context
 93 |     ):
 94 |         """
 95 |         Creates state for the region sent by magento
 96 | 
 97 |         :param cursor: Database cursor
 98 |         :param user: ID of current user
 99 |         :param country: Browse record of country
100 |         :param region: Name of state from magento
101 |         :param context: Application context
102 |         :return: Browse record of record created
103 |         """
104 |         code = None
105 |         try:
106 |             for subdivision in pycountry.subdivisions.get(
107 |                     country_code=country.code):
108 |                 if subdivision.name.upper() == region.upper():
109 |                     code = ''.join(list(region)[:3]).upper()
110 |                     break
111 |             if not code:
112 |                 if country.code == 'US':
113 |                     code = 'APO'
114 |                 else:
115 |                     code = ''.join(list(region)[:3]).upper()
116 |         except KeyError:
117 |             raise osv.except_osv(
118 |                 _('Country Not Found!'),
119 |                 _('No country found with code %s' % country.code)
120 |             )
121 |         finally:
122 | 	    #TODO: are all 3 of these fields required?
123 | 	    #We must detect in advance if create() will fail
124 | 	    #Because Odoo cannot handle a try/catch around creation error
125 | 	    if region and country and code:
126 |                 state_id = self.create(
127 |                     cursor, user, {
128 |                         'name': region,
129 |                         'country_id': country.id,
130 |                         'code': code,
131 |                     }, context=context
132 |                 )
133 | 	    else:
134 | 		if not region:
135 | 			error = 'There is no State Mapping. This order cannot import'
136 | 		elif not country:
137 | 		    error = 'There is no Country. This order cannot import'
138 | 		else:
139 | 		    error = 'There is no State Code. This order cannot import'
140 | 
141 |                 raise osv.except_osv(
142 |                     _('Address Country/State Mapping Error'),
143 |                     _(error)
144 |                 )
145 |         return self.browse(cursor, user, state_id, context=context)
146 | 


--------------------------------------------------------------------------------
/jobs/product.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | from datetime import datetime
  4 | from tzlocal import get_localzone
  5 | 
  6 | class MageIntegrator(osv.osv_memory):
  7 | 
  8 |     _inherit = 'mage.integrator'
  9 | 
 10 |     def test_attribute_options(self, cr, uid, job, context=None):
 11 |         records = self._get_job_data(cr, uid, job, 'sales_order.shipping_methods', [])
 12 | 
 13 | 	return True
 14 | 
 15 | 
 16 |     def import_configurable_links(self, cr, uid, job, context=None):
 17 | 	product_obj = self.pool.get('product.product')
 18 | 
 19 | 	product_ids = product_obj.search(cr, uid, [('mage_type', '=', 'configurable')])
 20 | 	product_data = product_obj.read(cr, uid, product_ids, fields=['external_id'])
 21 | 	external_ids = [x['external_id'] for x in product_data]
 22 |         records = self._get_job_data(cr, uid, job, 'oo_catalog_product.associatedproducts', [external_ids])
 23 | 
 24 | 	#For each configurable, locate available child products
 25 | 	for record in records:
 26 | 	    vals = {'associated_products': [(5)]}
 27 | #	    product = get_or_create_product_
 28 | 	    product_ids = product_obj.search(cr, uid, [('external_id', 'in', record['associated_products'])])
 29 | 	    product_id = product_obj.get_or_create_odoo_record(cr, uid, job, record['entity_id']).id
 30 | 	    if product_ids:
 31 | 	        vals = {'associated_products': [(6, 0, product_ids)]}
 32 | 
 33 | 	    result = product_obj.upsert_mage_record(cr, uid, vals, product_id)
 34 | 
 35 | 	return True
 36 | 
 37 | 
 38 |     def get_product_job_call(self, cr, uid, job, context=None):
 39 | 	call = 'oo_catalog_product.allsqlsearch'
 40 | 
 41 | 	return call
 42 | 
 43 | 
 44 |     def get_update_filters(self, job):
 45 | 	status_filter = self.get_status_filter(job)
 46 | 	filters = status_filter
 47 | 	#YYYY-MM-DD
 48 | 	tz = get_localzone()
 49 | 	now = datetime.utcnow()
 50 | 	dt = tz.localize(now)
 51 | 	string = dt.strftime('%Y-%m-%d')
 52 | 	updated = {'updated_at': {'gteq': string}}
 53 | 	filters.update(updated)
 54 | 
 55 |         return [filters]
 56 | 
 57 | 
 58 |     def get_status_filter(self, job):
 59 |         statuses = ['1']
 60 |         if job.mage_instance.import_disabled_products:
 61 |             statuses.append('2')
 62 | 	return {'status': {'in': statuses}}
 63 | 
 64 | 
 65 |     def get_all_filters(self, job):
 66 | 	status_filter = self.get_status_filter(job)
 67 | 	filters = status_filter
 68 |         return [filters]
 69 | 
 70 | 
 71 |     def get_updated_api_call(self):
 72 | 	return 'oo_catalog_product.filtersearch'
 73 | 
 74 | 
 75 |     def get_all_api_call(self):
 76 | 	return 'oo_catalog_product.filtersearch'
 77 | 
 78 | 
 79 |     def import_updated_products(self, cr, uid, job, context=None):
 80 | 	try:
 81 |             if job.mage_instance.import_links_with_products:
 82 |                 link = True
 83 |             else:
 84 |                 link = False
 85 | 	#Module not installed
 86 | 	except Exception, e:
 87 | 	    link = False
 88 | 
 89 | 	call = self.get_updated_api_call()
 90 | 	filters = self.get_update_filters(job)
 91 | 	product_ids = self._get_job_data(cr, uid, job, call, filters)
 92 | 	return self.import_products(cr, uid, job, product_ids, link)
 93 | 
 94 | 
 95 |     def import_all_products(self, cr, uid, job, context=None):
 96 |         try:
 97 |             if job.mage_instance.import_links_with_products:
 98 |                 link = True
 99 |             else:
100 |                 link = False
101 |         #Module not installed
102 |         except Exception, e:
103 |             link = False
104 | 
105 | 	call = self.get_all_api_call()
106 | 	filters = self.get_all_filters(job)
107 | 	product_ids = self._get_job_data(cr, uid, job, call, filters)
108 | 	if not product_ids:
109 | 	    return True
110 | 
111 | 	return self.import_products(cr, uid, job, product_ids, link)
112 | 
113 | 
114 |     def import_products(self, cr, uid, job, product_ids, link, context=None):
115 | 	datas = [product_ids[i:i+500] for i in range(0, len(product_ids), 500)]
116 |         mappinglines = self._get_mappinglines(cr, uid, job.mapping.id)
117 | 
118 | 	for data in datas:
119 | 	    try:
120 |                 records = self._get_job_data(cr, uid, job, 'oo_catalog_product.multinfo', [data, link])
121 |                 self.process_mage_products_response(cr, uid, job, mappinglines, records)
122 | 	        cr.commit()
123 | 	    except Exception, e:
124 | 		print e
125 | 
126 | 	return True
127 | 
128 | 
129 |     def process_mage_products_response(self, cr, uid, job, mappinglines, records):
130 | #        target_obj = self.pool.get(job.mapping.model_id.model)
131 | 	product_obj = self.pool.get('product.product')
132 | 
133 | 	import_images = job.mage_instance.import_images
134 | 	if import_images:
135 | 	    base_url = job.mage_instance.url
136 | 	    if base_url[-1] != '/':
137 | 		base_url += '/'
138 | 
139 | 	    media_ext = 'media/catalog/product'
140 | 	    img_url = base_url + media_ext
141 | 
142 |         for record in records:
143 | 	    #JDM asked that configurable product not import
144 | 	    pp(record)
145 | 	    if record['type_id'] in ['configurable', 'bundle', 'grouped']:
146 | 		continue
147 | 	  #  pp(record)
148 | 	    #Solves bug with null sku
149 | 	    if not record['sku']:
150 | 		continue
151 | 
152 | 	    try:
153 | 	        vals = product_obj.prepare_odoo_record_vals(cr, uid, job, record)
154 | 		mapper_vals = self._transform_record(cr, uid, job, record, \
155 | 			'from_mage_to_odoo', mappinglines
156 | 		)
157 | 		vals.update(mapper_vals)
158 | 	#	pp(vals)
159 | #		pp(record)
160 |                 product_id = product_obj.upsert_mage_record(cr, uid, vals)
161 | 
162 | 	        if import_images:
163 | 		    try:
164 | 		        product_obj.sync_one_image(cr, uid, job, product_id, record, img_url)
165 | 		    except Exception, e:
166 | 			pass
167 | 
168 | 	        print 'Successfully synced product with SKU: %s' % record['sku']
169 | 	        cr.commit()
170 | 
171 | 	    except Exception, e:
172 | 		print 'Product Sync Exception', e
173 | 		continue
174 | 
175 |         return True
176 | 
177 | 
178 | 


--------------------------------------------------------------------------------
/jobs/package.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | 
  4 | class MageIntegrator(osv.osv_memory):
  5 | 
  6 |     _inherit = 'mage.integrator'
  7 | 
  8 | 
  9 |     def find_backorder_shipment_id(self, cr, uid, picking_id):
 10 | 	picking_obj = self.pool.get('stock.picking')
 11 | 	picking_ids = picking_obj.search(cr, uid, [('backorder_id', '=', picking_id),
 12 | 		('external_id', '!=', False),
 13 | 		('state', '=', 'done')
 14 | 	])
 15 | 
 16 | 	if picking_ids:
 17 | 	    picking = picking_obj.browse(cr, uid, picking_ids[0])
 18 | 	    return picking.external_id
 19 | 
 20 | 	return False
 21 | 
 22 | 
 23 |     def sync_packages(self, cr, uid, job, context=None):
 24 | 	#This implementation is not good nor adaptable. This will need a rework
 25 | 	package_obj = self.pool.get('stock.out.package')
 26 |         storeview_obj = self.pool.get('mage.store.view')
 27 |         store_ids = storeview_obj.search(cr, uid, [('do_not_import', '=', False)])
 28 |         for storeview in storeview_obj.browse(cr, uid, store_ids):
 29 | 	    package_ids = self.get_pending_packages(cr, uid, storeview.id)
 30 | 	    for package in package_obj.browse(cr, uid, package_ids):
 31 | #		if package.picking.sale.mage_shipment_complete:
 32 | #		    back_ship_id = self.find_backorder_shipment_id(cr, uid, package.picking.id)
 33 | #		    if back_ship_id:
 34 | #                        result = self.send_one_package(cr, uid, job, back_ship_id, package, True)
 35 | #                        package.mage_package_state = 'done'
 36 | #                        package.picking.sw_exp = False
 37 | #                        cr.commit()
 38 | #			continue
 39 | 
 40 | 		if package.picking.external_id:
 41 | 		    result = self.send_one_package(cr, uid, job, package.picking.external_id, package, True)
 42 | 		    package.mage_package_state = 'done'
 43 | 		    package.picking.sw_exp = False
 44 | 		    package.picking.sw_pre_exp = False
 45 | 		    cr.commit()
 46 | #		elif package.picking.backorder_id and package.picking.backorder_id.external_id:
 47 | #                    result = self.send_one_package(cr, uid, job, package.picking.backorder_id.external_id, package, True)
 48 | #                    package.mage_package_state = 'done'
 49 | #                    package.picking.sw_exp = False
 50 | #                    cr.commit()
 51 | 		else:
 52 | 		    shipping_id = self.send_one_package(cr, uid, job, package.picking.sale.mage_order_number, package, False)
 53 | 		    if shipping_id:
 54 | 			package.picking.external_id = shipping_id
 55 | 			package.picking.mage_export_error = False
 56 | 			package.mage_package_state = 'done'
 57 | 			if not package.picking.sale.mage_shipment_complete:
 58 | 			    sale = package.picking.sale
 59 | 			    sale.mage_shipment_complete = True
 60 | 			    #Ensure Sale is not needlessly updated and report to shipworks
 61 | 			    sale.mage_custom_status = 'complete'
 62 | 			    package.picking.sw_exp = False
 63 | 			    package.picking.sw_pre_exp = False
 64 | 
 65 | 		    else:
 66 | 			package.mage_package_state = 'exception'
 67 | 			package.picking.mage_export_error = True
 68 | 
 69 | 		    cr.commit()
 70 |         return True
 71 | 
 72 | 
 73 |     #This is a temoporary method. Ideal solution does not involve a direct sql query
 74 |     def get_pending_packages(self, cr, uid, storeview_id):
 75 | 	query = "SELECT package.id" \
 76 | 		" FROM stock_out_package package" \
 77 | 		" JOIN stock_picking picking ON (package.picking = picking.id)" \
 78 | 		" JOIN delivery_carrier carrier ON (picking.carrier_id = carrier.id)" \
 79 | 		" JOIN sale_order sale ON (sale.id = picking.sale)" \
 80 | 		" WHERE package.mage_package_state = 'pending'" \
 81 | 		" AND sale.mage_store = %s LIMIT 100" % storeview_id
 82 | 
 83 |         cr.execute(query)
 84 |         return [id[0] for id in cr.fetchall()]
 85 | 
 86 | 
 87 |     def send_one_package(self, cr, uid, job, incrementid, package, track_only):
 88 | 	#This is yucky business
 89 | #	base_carrier = package.picking.carrier_id.mage_carrier
 90 | 	print 'SEnd One PAckage'
 91 | 	if not package.tracking_number:
 92 | 	    return False
 93 | 	if package.tracking_number[0:2] == '1Z':
 94 | 	    base_carrier = 'ups'
 95 | 	else:
 96 | 	    base_carrier = 'usps'
 97 | 
 98 | 	if track_only:
 99 | 	    print 'Track Only'
100 | 	    try:
101 | 		response = self._get_job_data(cr, uid, job, \
102 | 			'sales_order_shipment.addTrack', [incrementid, base_carrier, \
103 | 			'Shipped', package.tracking_number])
104 | 	    except Exception, e:
105 | 		print 'Exception', e
106 | 		return False
107 | 	else:
108 | 	    print 'Shipment Then Track'
109 | 	    item_data = self.get_item_data_from_package(cr, uid, package)
110 | 	    pp(item_data)
111 |             try:
112 | 		response = self._get_job_data(cr, uid, job, \
113 |                 	'sales_order_shipment.create', [incrementid, item_data, 'Order Has Shipped', True, False])
114 |                 self._get_job_data(cr, uid, job, \
115 |                         'sales_order_shipment.addTrack', [response, base_carrier, \
116 |                         'Shipped', package.tracking_number])
117 |             except Exception, e:
118 | 		print 'Exception', e
119 | 		return False
120 | 
121 | 
122 |         return response
123 | 
124 | 
125 |     def get_item_data_from_package(self, cr, uid, package):
126 | 	picking = package.picking
127 |         picking_obj = self.pool.get('stock.picking')
128 |         picking_ids = picking_obj.search(cr, uid, [('backorder_id', '=', picking.id)])
129 | 	if not picking_ids:
130 | 	    print 'There are no backorders'
131 | 	    return {}
132 | 
133 | 	data = {}
134 | 	kits = []
135 | 	for move in picking.move_lines:
136 | 	    if move.kit_product and move.kit_product.id not in kits:
137 | 		kits.append(move.kit_product.id)
138 | 		if move.sale_line_id.mage_item_id and move.sale_line_id.mage_item_id != '0':
139 | 		    k = str(move.sale_line_id.mage_item_id)
140 | 		    data[k] = int(move.kit_qty)
141 | 	    if move.sale_line_id.mage_item_id and move.sale_line_id.mage_item_id != '0':
142 | 		k = str(move.sale_line_id.mage_item_id)
143 | 		data[k] = int(move.product_uom_qty)
144 | 
145 | 	print 'Item Package Data'
146 | 	pp(data)
147 | 	return data
148 | 


--------------------------------------------------------------------------------
/models/defaults.py:
--------------------------------------------------------------------------------
  1 | PRODUCT_DEFAULT_MAP = [
  2 | {'external_type': 'unicode',
  3 |  'field_model': 'product.template',
  4 |  'field_name': 'weight',
  5 |  'function_name': '',
  6 |  'mage_fieldname': 'weight',
  7 |  'mapping_type': 'direct',
  8 |  'name': 'Product',
  9 |  'type': 'in_out'},
 10 | {'external_type': 'unicode',
 11 |  'field_model': 'product.template',
 12 |  'field_name': 'standard_price',
 13 |  'function_name': '',
 14 |  'mage_fieldname': 'cost',
 15 |  'mapping_type': 'direct',
 16 |  'name': 'Product',
 17 |  'type': 'in_out'},
 18 | {'external_type': 'unicode',
 19 |  'field_model': 'product.template',
 20 |  'field_name': 'upc',
 21 |  'function_name': '',
 22 |  'mage_fieldname': 'upc',
 23 |  'mapping_type': 'direct',
 24 |  'name': 'Product',
 25 |  'type': 'in_out'},
 26 | {'external_type': 'unicode',
 27 |  'field_model': 'product.template',
 28 |  'field_name': 'list_price',
 29 |  'function_name': '',
 30 |  'mage_fieldname': 'price',
 31 |  'mapping_type': 'direct',
 32 |  'name': 'Product',
 33 |  'type': 'in_out'},
 34 | ]
 35 | 
 36 | 
 37 | DEFAULT_JOBS = [
 38 |                 {'name': 'Sync All Products',
 39 |                  'mapping_model_name': 'product.product',
 40 |                  'python_function_name': 'import_all_products',
 41 |                  'job_type': 'system',
 42 | 		 'scheduler': False,
 43 | 		 'mapping_name': 'Product',
 44 | 		 'mapping_lines': PRODUCT_DEFAULT_MAP},
 45 |                 {'name': 'Sync All Partners',
 46 |                  'mapping_model_name': '',
 47 |                  'python_function_name': 'import_all_partners',
 48 |                  'job_type': 'system',
 49 |                  'scheduler': False,
 50 |                  'mapping_name': '',
 51 |                  'mapping_lines': ''},
 52 |                 {'name': 'Sync Updated Partners',
 53 |                  'mapping_model_name': '',
 54 |                  'python_function_name': 'import_updated_partners',
 55 |                  'job_type': 'system',
 56 |                  'scheduler': True,
 57 |                  'mapping_name': '',
 58 |                  'mapping_lines': ''},
 59 |                 {'name': 'Sync Updated Products',
 60 |                  'mapping_model_name': 'product.product',
 61 |                  'python_function_name': 'import_updated_products',
 62 |                  'job_type': 'system',
 63 | 		 'scheduler': True,
 64 | 		 'mapping_name': 'Product',
 65 | 		 'mapping_lines': PRODUCT_DEFAULT_MAP},
 66 |                 {'name': 'Sync Admin Users',
 67 |                  'mapping_model_name': '',
 68 |                  'python_function_name': 'sync_admin_users',
 69 |                  'job_type': 'system',
 70 |                  'scheduler': False,
 71 |                  'mapping_name': '',
 72 |                  'mapping_lines': ''},
 73 |                 {'name': 'Sync Sales Orders',
 74 |                  'mapping_model_name': 'sale.order',
 75 |                  'python_function_name': 'import_sales_orders',
 76 |                  'job_type': 'system',
 77 | 		 'scheduler': True,
 78 |                  'mapping_name': 'Sale Order',
 79 |                  'mapping_lines': ''},
 80 |                 {'name': 'Sync Categories',
 81 |                  'mapping_model_name': 'product.category',
 82 |                  'python_function_name': 'import_categories',
 83 |                  'job_type': 'system',
 84 |                  'scheduler': False,
 85 |                  'mapping_name': 'Category',
 86 |                  'mapping_lines': ''},
 87 |                 {'name': 'Sync Packages',
 88 |                  'mapping_model_name': '',
 89 |                  'python_function_name': 'sync_packages',
 90 |                  'job_type': 'system',
 91 | 		 'scheduler': True,
 92 |                  'mapping_name': '',
 93 |                  'mapping_lines': ''},
 94 |                 {'name': 'Sync Payments',
 95 |                  'mapping_model_name': '',
 96 |                  'python_function_name': 'sync_invoices',
 97 |                  'job_type': 'system',
 98 | 		 'scheduler': True,
 99 |                  'mapping_name': '',
100 |                  'mapping_lines': ''},
101 |                 {'name': 'Sync Configurable Relationship',
102 |                  'mapping_model_name': 'product.template',
103 |                  'python_function_name': 'import_configurable_links',
104 |                  'job_type': 'system',
105 |                  'scheduler': False,
106 |                  'mapping_name': '',
107 |                  'mapping_lines': ''},
108 |                 {'name': 'Sync Metadata',
109 |                  'mapping_model_name': '',
110 |                  'python_function_name': 'sync_mage_metadata',
111 |                  'job_type': 'system',
112 |                  'scheduler': False,
113 |                  'mapping_name': '',
114 |                  'mapping_lines': ''},
115 |                 {'name': 'Sync Attribute Data',
116 | 		 'mapping_model_name': '',
117 |                  'python_function_name': 'sync_mage_attribute_data',
118 |                  'job_type': 'system',
119 |                  'scheduler': False,
120 |                  'mapping_name': '',
121 |                  'mapping_lines': ''},
122 |                 {'name': 'Auto Billing',
123 |                  'mapping_model_name': '',
124 |                  'python_function_name': 'autopay_sale_orders',
125 |                  'job_type': 'system',
126 |                  'scheduler': False,
127 |                  'mapping_name': '',
128 |                  'mapping_lines': ''},
129 |                 {'name': 'Auto Only Shipping',
130 |                  'mapping_model_name': '',
131 |                  'python_function_name': 'automate_only_pickings',
132 |                  'job_type': 'system',
133 |                  'scheduler': False,
134 |                  'mapping_name': '',
135 |                  'mapping_lines': ''},
136 |                 {'name': 'Auto Sale Shipping',
137 |                  'mapping_model_name': '',
138 |                  'python_function_name': 'autodeliver_sale_orders',
139 |                  'job_type': 'system',
140 |                  'scheduler': False,
141 |                  'mapping_name': '',
142 |                  'mapping_lines': ''},
143 |                 {'name': 'Sync Product Links',
144 |                  'mapping_model_name': '',
145 |                  'python_function_name': 'import_product_links',
146 |                  'job_type': 'system',
147 |                  'scheduler': False,
148 |                  'mapping_name': '',
149 |                  'mapping_lines': ''},
150 | 
151 | ]
152 | 


--------------------------------------------------------------------------------
/views/product.xml:
--------------------------------------------------------------------------------
  1 | <openerp>
  2 |     <data>
  3 |         <record id="mage_product_template_search_view" model="ir.ui.view">
  4 |             <field name="name">Mage Product Template Search</field>
  5 |             <field name="model">product.template</field>
  6 | 	    <field name="inherit_id" ref="product.product_template_search_view" />
  7 |             <field name="arch" type="xml">
  8 | 		<field name="name" position="replace">
  9 | 		    <field name="name" string="Product" filter_domain="['|','|',('default_code','ilike',self),('name','ilike',self),('upc', 'ilike', self)]"/>
 10 | 		</field>
 11 | 	    </field>
 12 | 	</record>
 13 | 
 14 | 	<record id="product_template_configurable_action" model="ir.actions.act_window">
 15 | 	    <field name="name">Configurable Products</field>
 16 | 	    <field name="type">ir.actions.act_window</field>
 17 | 	    <field name="res_model">product.template</field>
 18 | 	    <field name="view_mode">tree,form,kanban</field>
 19 | 	    <field name="view_type">form</field>
 20 | 	    <field name="view_id" ref="product.product_template_tree_view"/>
 21 | 	    <field name="domain">[('mage_type', '=', 'configurable')]</field>
 22 | 	    <field name="help" type="html">
 23 | 		<p class="oe_view_nocontent_create">
 24 | 		  No configurable products. Click to create.
 25 | 		</p>
 26 | 	    </field>
 27 | 	</record>
 28 | 
 29 | 	<menuitem action="product.product_template_action" id="stock.menu_stock_products_menu" parent="stock.menu_stock_product" sequence="2"/>
 30 | 
 31 | 	<menuitem action="product_template_configurable_action"
 32 | 		id="menu_product_template_configurable_action"
 33 | 		parent="stock.menu_stock_product" sequence="1" />
 34 | 
 35 |         <record id="view_mage_product_template_tree" model="ir.ui.view">
 36 |             <field name="name">Mage Product Template Tree</field>
 37 |             <field name="model">product.template</field>
 38 |             <field name="inherit_id" ref="product.product_template_tree_view" />
 39 |             <field name="arch" type="xml">
 40 |                 <field name="type" position="after">
 41 |                     <field name="mage_type" />
 42 |                     <field name="mage_status" />
 43 |                 </field>
 44 |             </field>
 45 |         </record>
 46 | 
 47 |         <record id="view_mage_product_template_form" model="ir.ui.view">
 48 |             <field name="name">Mage Product Template Form</field>
 49 |             <field name="model">product.template</field>
 50 |             <field name="inherit_id" ref="product.product_template_form_view"/>
 51 |             <field name="arch" type="xml">
 52 | 		<div name="options" position="inside" >
 53 | 		    <field name="sync_to_mage" />
 54 | 		    <label for="sync_to_mage"/>
 55 | 		</div>
 56 | 		<div name="options" position="after">
 57 | 		    <button name="%(asin_label.action_print_label_generator)d" type="action" string="Print Labels" />
 58 | 		</div>
 59 | 		<field name="description" position="replace" >
 60 | 		<separator string="Short/Detailed Description" colspan="4" />
 61 | 		<field name="short_description" nolabel="1" colspan="4"/>
 62 | 		<newline/>
 63 | 		<field name="description" colspan="4" nolabel="1" />
 64 | 		</field>
 65 |             </field>
 66 |         </record>
 67 | 
 68 | 	<record id="mage_core_configurable_menu" model="ir.ui.view">
 69 | 	    <field name="name">Mage Core Configurable Menu</field>
 70 | 	    <field name="model">product.template</field>
 71 | 	    <field name="inherit_id" ref="product.product_template_only_form_view"/>
 72 | 	    <field name="arch" type="xml">
 73 | 		<field name="default_code" position="replace" />
 74 | 		<field name="name" position="replace" />
 75 | 		<label string="Product Name" position="replace">
 76 | 		    <label class="oe_edit_only" for="name" string="Product Identification"/>
 77 | 		    <group>
 78 | 		    <field name="default_code" attrs="{'required': [('sync_to_mage', '=', True)]}"/>
 79 | 		    <field name="name" style="width: 230%;"/>
 80 | 		    </group>
 81 | 		</label>
 82 | 
 83 | 		<field name="list_price" position="after" >
 84 | 		    <field name="special_price" />
 85 | 		    <field name="msrp" />
 86 | 		</field>
 87 |                 <xpath expr="//page[@string='Variants']" position="replace">
 88 |                     <page string="Associated Products" attrs="{'invisible': 
 89 | 			['|', ('mage_type', '!=', 'configurable'), ('sync_to_mage', '!=', True)]}" >
 90 | 			<group colspan="4">
 91 | 			<field name="super_attributes" widget="many2many_tags" colspan="2" string="Configurable Attributes" />
 92 | 			<button name="update_variants" type="object" string="Update Variants" colspan="2"/>
 93 | 			</group>
 94 |                         <separator string="Variants" colspan="4"/>
 95 | 			<field name="associated_products" nolabel="1" colspan="4" widget="one2many_list" >
 96 | 			    <tree>
 97 | 				<field name="name" />
 98 | 				<field name="default_code" />
 99 | 				<field name="list_price" widget="symbol" />
100 | 			    </tree>
101 | 			</field>
102 |                     </page>
103 | 		    <page string="Magento" attrs="{'invisible': [('sync_to_mage', '!=', True)]}">
104 | 		        <group string="General">
105 | 			    <field name="set" attrs="{'required': [('sync_to_mage', '=', True)]}"/>
106 | 			    <field name="mage_type" attrs="{'required': [('sync_to_mage', '=', True)]}"/>
107 | 			    <field name="external_id" />
108 | 			    <field name="mage_tax_class" />
109 | 			    <field name="shipping_product" />
110 | 			    <field name="img_path" />
111 | 			    <field name="url_path" />
112 | 			    <field name="mage_last_sync_date" />
113 | 		        </group>
114 | 			<group string="Status">
115 | 			    <field name="visibility" />
116 | 			    <field name="mage_status" />
117 | 			    <field name="url_key" />
118 | 			</group>
119 | 			<newline/>
120 |                         <group string="Stock" >
121 |                             <field name="sync_stock" />
122 |                             <field name="always_in_stock" attrs="{'invisible': [('sync_stock', '!=', True)]}"/>
123 |                             <field name="manage_stock" attrs="{'invisible': [('sync_stock', '!=', True)]}"/>
124 |                             <field name="use_config_manage_stock" attrs="{'invisible': [('sync_stock', '!=', True)]}"/>
125 |                         </group>
126 |                         <newline/>
127 | 			<separator string="Categories" colspan="4" />
128 | 			<field name="categories" colspan="4" nolabel="1" />
129 |                         <newline/>
130 |                         <separator string="Websites" colspan="4" />
131 |                         <field name="websites" colspan="4" nolabel="1" />
132 | 		    </page>
133 |                 </xpath> 
134 | 	    </field>
135 | 	</record>
136 | 
137 |     </data>
138 | </openerp>
139 | 


--------------------------------------------------------------------------------
/views/partner.xml:
--------------------------------------------------------------------------------
  1 | <openerp>
  2 |     <data>
  3 | 
  4 |        <record id="view_res_partner_new_filter" model="ir.ui.view">
  5 |             <field name="name">res.partner.select.new.filter</field>
  6 |             <field name="model">res.partner</field>
  7 | 	    <field name="inherit_id" ref="base.view_res_partner_filter" />
  8 |             <field name="arch" type="xml">
  9 |                    <filter name="customer" position="after">
 10 |                        <filter string="Entity" name="entity_only" domain="[('parent_id','=',False)]" help="Only Parent Records"/>
 11 |                        <field string="Email" name="email" />
 12 |                        <field string="Phone" name="phone" />
 13 | 		   </filter>
 14 | 	    </field>
 15 | 	</record>
 16 | 
 17 |         <record id="base.action_partner_form" model="ir.actions.act_window">
 18 |             <field name="name">Customers</field>
 19 |             <field name="type">ir.actions.act_window</field>
 20 |             <field name="res_model">res.partner</field>
 21 |             <field name="view_type">form</field>
 22 |             <field name="view_mode">tree,form,kanban</field>
 23 |             <field name="context">{"search_default_entity_only": 1}</field>
 24 |             <field name="search_view_id" ref="view_res_partner_new_filter"/>
 25 |             <field name="help" type="html">
 26 |               <p class="oe_view_nocontent_create">
 27 |                 Test
 28 |               </p><p>
 29 |                 Odoo helps you easily track all activities related to
 30 |                 a customer; discussions, history of business opportunities,
 31 |                 documents, etc.
 32 |               </p>
 33 |             </field>
 34 |         </record>
 35 | 
 36 | 
 37 |         <record id="mage_partner_simple_form" model="ir.ui.view">
 38 |             <field name="name">Mage Partner Simple Form</field>
 39 |             <field name="model">res.partner</field>
 40 | 	    <field name="inherit_id" ref="base.view_partner_simple_form" />
 41 |             <field name="arch" type="xml">
 42 | 		<field name="function" position="before" >
 43 | 		    <field name="firstname" />
 44 | 		    <field name="lastname" />
 45 | 		    <field name="company" />
 46 | 		</field>
 47 | <!--		<field name="mobile" position="after">
 48 | 		</field> -->
 49 | 	    </field>
 50 | 	</record>
 51 | 
 52 | 
 53 |         <record id="view_mage_partner_form" model="ir.ui.view">
 54 |             <field name="name">Mage Partner Form</field>
 55 |             <field name="model">res.partner</field>
 56 | 	    <field name="inherit_id" ref="base.view_partner_form" />
 57 |             <field name="arch" type="xml">
 58 | 		<label string="Address" position="replace" />
 59 | 		<field name="website" position="replace" />
 60 | 		<field name="street" position="before">
 61 | 		    <group>
 62 | 		    <field name="is_default_shipping" />
 63 | 		    <field name="is_default_billing" />
 64 | 		    <field name="firstname" />
 65 | 		    <field name="lastname" />
 66 | 		    </group>
 67 | 		</field>
 68 | 		<field name="email" position="before">
 69 | 		    <field name="company" />
 70 | 		</field>
 71 | 		<page name="internal_notes" position="after" >
 72 | 		    <page string="Magento" >
 73 | 			<group string="Actions" attrs="{'invisible': [('parent_id', '!=', False)]}">
 74 | 			    <button string="Sync Customer" name="sync_one_mage_customer" type="object" />
 75 | 			</group>
 76 | 			<group string="References">
 77 | 			    <field name="external_id" />
 78 | 			</group>
 79 | 		    </page>
 80 | 		</page>
 81 | 		<!-- This entire form replaced because it is embedded inside another form -->
 82 | 		<form string="Contact" position="replace">
 83 |                     <form string="Contact">
 84 |                                     <sheet>
 85 |                                         <field name="image" widget='image' class="oe_avatar oe_left" options='{"preview_image": "image_medium"}'/>
 86 |                                         <div class="oe_title">
 87 |                                             <label for="name" class="oe_edit_only"/>
 88 |                                             <h1><field name="name" style="width: 70%%"/></h1>
 89 |                                             <field name="category_id" widget="many2many_tags" placeholder="Tags..." style="width: 70%%"/>
 90 |                                         </div>
 91 |                     			<group>
 92 |                     			    <field name="is_default_shipping" />
 93 |                     			    <field name="is_default_billing" />
 94 | 					</group>
 95 |                                         <group>
 96 |                                             <field name="firstname" />
 97 |                                             <field name="lastname" />
 98 |                                             <field name="function" placeholder="e.g. Sales Director"/>
 99 |                                             <field name="email"/>
100 |                                             <field name="phone"/>
101 |                                             <field name="mobile"/>
102 |                                         </group>
103 |                                         <div>
104 |                                             <field name="use_parent_address" invisible="1"/>
105 |                                         </div>
106 |                                         <group>
107 |                                             <label for="type"/>
108 |                                             <div name="div_type">
109 |                                                 <field class="oe_inline" name="type"/>
110 |                                             </div>
111 |                                             <label for="street" string="Address" attrs="{'invisible': [('use_parent_address','=', True)]}"/>
112 |                                             <div attrs="{'invisible': [('use_parent_address','=', True)]}" name="div_address">
113 |                                                 <field name="street" placeholder="Street..."/>
114 |                                                 <field name="street2"/>
115 |                                                 <div class="address_format">
116 |                                                     <field name="city" placeholder="City" style="width: 40%%"/>
117 |                                                     <field name="state_id" class="oe_no_button" placeholder="State" style="width: 37%%" options='{"no_open": True}' on_change="onchange_state(state_id)"/>
118 |                                                     <field name="zip" placeholder="ZIP" style="width: 20%%"/>
119 |                                                 </div>
120 |                                                 <field name="country_id" placeholder="Country" class="oe_no_button" options='{"no_open": True, "no_create": True}'/>
121 |                                             </div>
122 |                                         </group>
123 | 					<group>
124 | 					    <field name="external_id" readonly="1" />
125 | 					    <field name="external_address_id" readonly="1" />
126 | 					</group>
127 |                                         <field name="supplier" invisible="True"/>
128 |                                         <field name="customer" invisible="True"/>
129 |                                     </sheet>
130 |                                 </form>
131 | </form>
132 | 	    </field>
133 | 	</record>
134 | 
135 |     </data>
136 | </openerp>
137 | 


--------------------------------------------------------------------------------
/views/sites.xml:
--------------------------------------------------------------------------------
  1 | <openerp>
  2 |     <data>
  3 | 
  4 |         <menuitem name="Sites"
  5 |         id="menu_mage_site_management"
  6 |         parent="menu_mage_core"
  7 |         sequence="30"/>
  8 | 
  9 | 
 10 |         <record id="view_mage_website_tree" model="ir.ui.view">
 11 |             <field name="name">Mage Website Tree</field>
 12 |             <field name="model">mage.website</field>
 13 |             <field name="arch" type="xml">
 14 |                 <tree>
 15 |                     <field name="name" />
 16 | 		    <field name="code" />
 17 | 		    <field name="sort_order" />
 18 |                 </tree>
 19 |             </field>
 20 |         </record>
 21 | 
 22 |         <record id="view_mage_website_form" model="ir.ui.view">
 23 |             <field name="name">Mage Website Form</field>
 24 |             <field name="model">mage.website</field>
 25 |             <field name="arch" type="xml">
 26 |                 <form>
 27 |                     <sheet>
 28 |                         <h1>
 29 |                             <field name="name" class="oe_inline" readonly="1"/>
 30 |                         </h1>
 31 | 			<group string="Identity" readonly="1">
 32 | 			    <field name="code" readonly="1"/>
 33 | 			    <field name="is_default" readonly="1"/>
 34 | 			    <field name="default_store_group" readonly="1"/>
 35 | 			    <field name="sort_order" readonly="1"/>
 36 | 			    <field name="external_id" readonly="1"/>
 37 | 			</group>
 38 |                     </sheet>
 39 |                 </form>
 40 |             </field>
 41 |         </record>
 42 | 
 43 | 
 44 |         <record id="view_mage_store_group_tree" model="ir.ui.view">
 45 |             <field name="name">Mage Store Group Tree</field>
 46 |             <field name="model">mage.store.group</field>
 47 |             <field name="arch" type="xml">
 48 |                 <tree>
 49 |                     <field name="name" />
 50 | 		    <field name="website" />
 51 |                 </tree>
 52 |             </field>
 53 |         </record>
 54 | 
 55 |         <record id="view_mage_store_group_form" model="ir.ui.view">
 56 |             <field name="name">Mage Store Group Form</field>
 57 |             <field name="model">mage.store.group</field>
 58 |             <field name="arch" type="xml">
 59 |                 <form>
 60 |                     <sheet>
 61 |                         <h1>
 62 |                             <field name="name" class="oe_inline" readonly="1"/>
 63 |                         </h1>
 64 | 			<group string="Identity" readonly="1">
 65 | 			    <field name="website" readonly="1"/>
 66 | 			    <field name="external_id" readonly="1"/>
 67 | 			    <field name="default_store_view" readonly="1"/>
 68 | 			</group>
 69 |                         <separator string="Storeviews" colspan="4" />
 70 |                         <field name="store_views" widget="one2many_list" nolabel="1" readonly="1">
 71 |                             <tree>
 72 |                                 <field name="name" />
 73 | 				<field name="code" />
 74 |                             </tree>
 75 |                         </field>
 76 |                     </sheet>
 77 |                 </form>
 78 |             </field>
 79 |         </record>
 80 | 
 81 | 
 82 |         <record id="view_mage_store_view_tree" model="ir.ui.view">
 83 |             <field name="name">Mage Store View Tree</field>
 84 |             <field name="model">mage.store.view</field>
 85 |             <field name="arch" type="xml">
 86 |                 <tree>
 87 |                     <field name="name" />
 88 | 		    <field name="store" />
 89 | 		    <field name="code" />
 90 |                 </tree>
 91 |             </field>
 92 |         </record>
 93 | 
 94 | 
 95 |         <record id="view_mage_store_view_form" model="ir.ui.view">
 96 |             <field name="name">Mage Store View Form</field>
 97 |             <field name="model">mage.store.view</field>
 98 |             <field name="arch" type="xml">
 99 |                 <form>
100 |                     <sheet>
101 |                         <h1>
102 |                             <field name="name" class="oe_inline" readonly="1"/>
103 |                         </h1>
104 | 			<group string="Identity" readonly="1">
105 | 			    <field name="store" readonly="1"/>
106 | 			    <field name="code" readonly="1"/>
107 | 			    <field name="sort_order" readonly="1"/>
108 | 			    <field name="website" readonly="1"/>
109 | 			</group>
110 | 			<group string="Settings" colspan="4">
111 | 			    <field name="order_prefix" />
112 | 			    <field name="warehouse" required="1" />
113 | 			    <field name="fba_warehouse" required="1" />
114 | 			    <field name="picking_policy" />
115 | 			    <field name="invoice_policy" />
116 | 			    <field name="skip_order_status" />
117 | 			    <field name="odoo_guest_customer" />
118 | 			    <field name="do_not_import" />
119 | 			    <field name="allow_storeview_level_statuses" />
120 | 			    <group string="Statuses" colspan="4" attrs="{'invisible': [('allow_storeview_level_statuses', '!=', True)]}">
121 | 				<field name="order_statuses" colspan="4" nolabel="1" widget="many2many_tags">
122 | 				</field>
123 | 			    </group>
124 | 			</group>
125 | 			<group string="Schedule" >
126 | 			    <field name="import_orders_start_datetime" />
127 | 			    <field name="import_orders_end_datetime" />
128 | 			    <field name="last_import_datetime" />
129 | 			    <field name="last_export_datetime" />
130 | 			</group>
131 | 			<group string="Manual Order Import">
132 | 			    <field name="manual_order_number" />
133 | 			</group>
134 |                     </sheet>
135 |                 </form>
136 |             </field>
137 |         </record>
138 | 
139 | 
140 |         <record id="action_mage_website" model="ir.actions.act_window">
141 |             <field name="name">Website</field>
142 |             <field name="res_model">mage.website</field>
143 |             <field name="type">ir.actions.act_window</field>
144 |             <field name="view_type">form</field>
145 |             <field name="view_id" ref="view_mage_website_tree"/>
146 |             <field name="help" type="html">
147 |             <p class="oe_view_nocontent_create">
148 |             No Websites Synced.
149 |             </p>
150 |             </field>
151 |         </record>
152 | 
153 |         <record id="action_mage_store_group" model="ir.actions.act_window">
154 |             <field name="name">Stores</field>
155 |             <field name="res_model">mage.store.group</field>
156 |             <field name="type">ir.actions.act_window</field>
157 |             <field name="view_type">form</field>
158 |             <field name="view_id" ref="view_mage_store_group_tree"/>
159 |             <field name="help" type="html">
160 |             <p class="oe_view_nocontent_create">
161 |             No Stores Synced.
162 |             </p>
163 |             </field>
164 |         </record>
165 | 
166 |         <record id="action_mage_store_view" model="ir.actions.act_window">
167 |             <field name="name">Store Views</field>
168 |             <field name="res_model">mage.store.view</field>
169 |             <field name="type">ir.actions.act_window</field>
170 |             <field name="view_type">form</field>
171 |             <field name="view_id" ref="view_mage_store_view_tree"/>
172 |             <field name="help" type="html">
173 |             <p class="oe_view_nocontent_create">
174 |             No Storeviews Synced.
175 |             </p>
176 |             </field>
177 |         </record>
178 | 
179 | 
180 |         <menuitem action="action_mage_website"
181 |         id="menu_mage_website"
182 | 	parent="menu_mage_site_management"
183 |         sequence="10"/>
184 | 
185 |         <menuitem action="action_mage_store_group"
186 |         id="menu_mage_store_group"
187 |         parent="menu_mage_site_management"
188 |         sequence="20"/>
189 | 
190 |         <menuitem action="action_mage_store_view"
191 |         id="menu_mage_store_view"
192 | 	parent="menu_mage_site_management"
193 |         sequence="30"/>
194 | 
195 | 
196 |     </data>
197 | </openerp>
198 | 


--------------------------------------------------------------------------------
/models/create_mage_order.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from openerp.tools.translate import _
  3 | import xmlrpclib
  4 | from pprint import pprint as pp
  5 | from magento import Product, ProductImages, API, Order, Customer, Cart, CartCustomer, CartProduct, CartShipping, CartPayment
  6 | #TODO: Currently store id of 1 is hardcoded. What is the value of maintaining this, can it be null?
  7 | 
  8 | class SaleOrder(osv.osv):
  9 |     _inherit = 'sale.order'
 10 | 
 11 |     def get_name_field(self, cr, uid, address, context=None):
 12 |         if not address.firstname:
 13 |             name_data = address.name.split(' ')
 14 |             firstname = name_data[0]
 15 |             lastname = name_data[1] if len(name_data) > 1 else False
 16 |         else:
 17 |             firstname = address.firstname
 18 |             lastname = address.lastname
 19 | 
 20 |         return (firstname, lastname)
 21 | 
 22 |     def create_mage_sale_order(self, cr, uid, ids, context=None):
 23 | 	sale = self.browse(cr, uid, ids[0])
 24 | 
 25 | 	#Get Username/Pass
 26 | 	#TODO. Think about security here
 27 | 	integrator_obj = self.pool.get('mage.integrator')
 28 | 	credentials = integrator_obj.get_external_credentials(cr, uid)
 29 | 
 30 | 	customer_data = self.prepare_mage_cart_customer_data(cr, uid, credentials, sale)
 31 | 	billing_data = self.prepare_mage_cart_address_data(cr, uid, integrator_obj, credentials, sale.partner_shipping_id, 'billing')
 32 | 	shipping_data = self.prepare_mage_cart_address_data(cr, uid, integrator_obj, credentials, sale.partner_shipping_id, 'shipping')
 33 | 
 34 | 	items = self.prepare_mage_cart_items(cr, uid, sale.order_line)
 35 | 
 36 | 	cart_id = self.create_mage_cart(credentials)
 37 | 	self.add_mage_cart_customer_data(cr, uid, credentials, cart_id, customer_data, billing_data, shipping_data)
 38 | 	self.add_mage_cart_item_data(cr, uid, credentials, cart_id, items)
 39 | 	sale.mage_cart_id = cart_id
 40 | 	if sale.carrier_id and sale.carrier_id.mage_code:
 41 | 	    self.set_mage_cart_shipping_method(cr, uid, sale, credentials, cart_id)
 42 | 
 43 | 	else:
 44 | 	    print 'No Code'
 45 | 
 46 | 	self.set_mage_cart_payment_method(cr, uid, sale, credentials, cart_id)
 47 | 	result = self.mage_convert_cart_to_order(cr, uid, sale, credentials, cart_id)
 48 | 	sale.mage_order_number = result
 49 | 	sale.name = result
 50 | 	pp(result)
 51 | #	cart_info = self.get_mage_cart_info(cr, uid, credentials, cart_id)
 52 | #	pp(cart_info)
 53 | 
 54 | 
 55 |     def set_mage_cart_shipping_method(self, cr, uid, sale, credentials, cart_id):
 56 | 	try:
 57 | 	    print sale.carrier_id.mage_code
 58 |             with CartShipping(credentials['url'], credentials['username'], credentials['password']) as cart_api:
 59 | #		pp(cart_api.list(cart_id, 1))
 60 |                 return cart_api.method(cart_id, sale.carrier_id.mage_code, 1)
 61 | 	except Exception, e:
 62 | 	    raise osv.except_osv(_('Shipping Exception!'),_(str(e)))
 63 | 
 64 | 
 65 |     def set_mage_cart_payment_method(self, cr, uid, sale, credentials, cart_id):
 66 |         try:
 67 |             with CartPayment(credentials['url'], credentials['username'], credentials['password']) as cart_api:
 68 | 		payment_data = {'method': 'purchaseorder'}
 69 |                 return cart_api.method(cart_id, payment_data, 1)
 70 |         except Exception, e:
 71 |             raise osv.except_osv(_('Shipping Exception!'),_(str(e)))
 72 | 
 73 | 
 74 |     def mage_convert_cart_to_order(self, cr, uid, sale, credentials, cart_id):
 75 |         try:
 76 |             with Cart(credentials['url'], credentials['username'], credentials['password']) as cart_api:
 77 |                 return cart_api.order(cart_id, 1)
 78 |         except Exception, e:
 79 |             raise osv.except_osv(_('Shipping Exception!'),_(str(e)))
 80 | 
 81 | 
 82 |     def create_mage_order_customer(self, cr, uid, credentials, sale, partner, store_id, context=None):
 83 | 
 84 |         firstname, lastname = self.get_name_field(cr, uid, partner)
 85 |         email = sale.order_email or partner.email or sale.partner_shipping_id.email
 86 |         if not email:
 87 |             raise osv.except_osv(_('Data Error!'),_("You must specify an Email Address"))
 88 |         try:
 89 |             with Customer(credentials['url'], credentials['username'], credentials['password']) as customer_api:
 90 |                 customer = customer_api.create({'email': email,
 91 |                                         'firstname': firstname,
 92 |                                         'lastname': lastname,
 93 |                                         'website_id': store_id,
 94 |                 })
 95 |                 partner.external_id = customer
 96 |                 print 'Created Customer in Magento with ID: %s' % customer
 97 |                 #This must be committed beause the email has already been pushed to Magento
 98 |                 #If the process errors out at another step, the quote/customer will be stuck
 99 |                 #Because the email was pushed to Magento but the ID is not known by Odoo
100 | 
101 |                 #A quote must already be saved for this action to execute, so I see no harm here
102 |                 cr.commit()
103 |                 return partner
104 | 
105 |         except Exception, e:
106 |             raise osv.except_osv(_('Magento API Error.\nCould not create new customer with email %s.\nIf this is an existing customer, link their account.')%email,_(str(e)))
107 | 
108 | 
109 |     def prepare_mage_cart_items(self, cr, uid, order_lines, context=None):
110 | 	product_data = []
111 |         for sale_line in order_lines:
112 | 	    if not sale_line.product_id or sale_line.product_id.default_code == 'mage_shipping':
113 | 		continue
114 | 
115 | 	    product_data.append({
116 | 		'product_id': sale_line.product_id.external_id,
117 | 		'qty': int(sale_line.product_uom_qty),
118 | 		'price': sale_line.price_unit,
119 | 	    })
120 | 
121 |  	return product_data
122 | 
123 | 
124 |     def prepare_mage_cart_customer_data(self, cr, uid, credentials, sale, context=None):
125 | 	partner = sale.partner_id
126 | 	store_id = sale.mage_store.external_id
127 | 
128 |         firstname, lastname = self.get_name_field(cr, uid, partner)
129 | 	if not partner.external_id or partner.external_id == 0:
130 | 	    self.create_mage_order_customer(cr, uid, credentials, sale, partner, store_id)
131 | 
132 | 	customer_data = {
133 | 		'mode': 'customer',
134 | 		'firstname': firstname,
135 | 		'lastname': lastname,
136 | 		'customer_id': partner.external_id,
137 | 		'website_id': 1,
138 | 		'store_id': store_id,
139 | 		'group_id': 1,
140 | 		'email': sale.order_email or sale.partner_id.email or sale.partner_shipping_id.email,
141 | 	}
142 | 
143 | 	return customer_data
144 | 
145 | 
146 |     def prepare_mage_cart_address_data(self, cr, uid, integrator_obj, credentials, address, address_type, context=None):
147 |         firstname, lastname = self.get_name_field(cr, uid, address)
148 | 
149 | 	shipping_data = {
150 | 		'mode': address_type,
151 | 		'telephone': address.phone,
152 | 		'firstname': firstname,
153 | 		'lastname': lastname,
154 | 		'street': address.street,
155 | 		'city': address.city,
156 | 		'region': address.state_id.name,
157 | 		'region_id': integrator_obj.get_magento_region_id(cr, uid, credentials, address.country_id.code, address.state_id.name),
158 | 		'postcode': address.zip,
159 | 		'country_id': address.country_id.code,
160 | 	}
161 | 
162 | 	return [shipping_data]
163 | 
164 | 
165 |     def create_mage_cart(self, credentials):
166 |         with Cart(credentials['url'], credentials['username'], credentials['password']) as cart_api:
167 |             return cart_api.create(1)
168 | 
169 | 
170 |     def add_mage_cart_customer_data(self, cr, uid, credentials, cart_id, customer_data, billing_data, shipping_data):
171 |         with CartCustomer(credentials['url'], credentials['username'], credentials['password']) as cartcustomer_api:
172 |             cartcustomer_api.set(cart_id, customer_data, 1)
173 | 	    billing_data.extend(shipping_data)
174 |             cartcustomer_api.addresses(cart_id, billing_data, 1)
175 | 
176 | 	return True
177 | 
178 | 
179 |     def add_mage_cart_item_data(self, cr, uid, credentials, cart_id, items):
180 | 	try:
181 |             with CartProduct(credentials['url'], credentials['username'], credentials['password']) as cartproduct_api:
182 |                 res = cartproduct_api.add(cart_id, items, 1)
183 | 
184 | 	    return True
185 | 	except xmlrpclib.Fault, e:
186 | 	    raise osv.except_osv(_('Product Error'), _(str(e)))
187 | 
188 | 
189 |     def get_mage_cart_info(self, cr, uid, credentials, cart_id):
190 |         with Cart(credentials['url'], credentials['username'], credentials['password']) as cart_api:
191 |             return cart_api.info(cart_id)
192 | 
193 | 
194 | 


--------------------------------------------------------------------------------
/views/attribute.xml:
--------------------------------------------------------------------------------
  1 | <openerp>
  2 |     <data>
  3 | 
  4 |         <menuitem name="Attribute Management"
  5 | 	id="menu_mage_attribute_management"
  6 |         parent="menu_mage_core"
  7 |         sequence="10"/>
  8 | 
  9 | 
 10 | 	<record id="view_mage_attribute_set_tree" model="ir.ui.view">
 11 | 	    <field name="name">Mage Attribute Set Tree</field>
 12 | 	    <field name="model">product.attribute.set</field>
 13 | 	    <field name="arch" type="xml">
 14 | 	        <tree>
 15 |                     <field name="name" />
 16 | 	        </tree>
 17 | 	    </field>
 18 | 	</record>
 19 | 
 20 | 
 21 |         <record id="view_mage_attribute_set_form" model="ir.ui.view">
 22 |             <field name="name">Mage Attribute Set Form</field>
 23 |             <field name="model">product.attribute.set</field>
 24 |             <field name="arch" type="xml">
 25 |                 <form>
 26 |                     <sheet>
 27 |                         <h1>
 28 |                             <field name="name" class="oe_inline" />
 29 |                         </h1>
 30 | 			<separator string="Groups" colspan="4" />
 31 | 		        <field name="groups" widget="one2many_list" nolabel="1">
 32 | 			    <tree>
 33 | 				<field name="name" />
 34 | 			    </tree>
 35 | 			</field>
 36 | 		    </sheet>
 37 | 		</form>
 38 |             </field>
 39 |         </record>
 40 | 
 41 | 
 42 |         <record id="view_mage_attribute_group_tree" model="ir.ui.view">
 43 |             <field name="name">Mage Attribute Group Tree</field>
 44 |             <field name="model">product.attribute.group</field>
 45 |             <field name="arch" type="xml">
 46 |                 <tree>
 47 | 		    <field name="name" />
 48 | 		    <field name="set" />
 49 |                 </tree>
 50 |             </field>
 51 |         </record>
 52 | 
 53 | 
 54 |         <record id="view_mage_attribute_group_form" model="ir.ui.view">
 55 |             <field name="name">Mage Attribute Group Form</field>
 56 |             <field name="model">product.attribute.group</field>
 57 |             <field name="arch" type="xml">
 58 |                 <form>
 59 |                     <field name="name" />
 60 |                     <field name="set" />
 61 | 		    <separator string="Attributes" colspan="4" />
 62 | 		    <field name="attributes" widget="one2many_list" nolabel="1">
 63 | 			<tree>
 64 | 			    <field name="name" />
 65 | 			</tree>
 66 | 		    </field>
 67 |                 </form>
 68 | 	    </field>
 69 | 	</record>
 70 | 	
 71 | 
 72 | 
 73 |         <record id="view_mage_attribute_tree" model="ir.ui.view">
 74 |             <field name="name">Mage Attribute Tree</field>
 75 |             <field name="model">product.attribute</field>
 76 |             <field name="arch" type="xml">
 77 |                 <tree>
 78 |                     <field name="attribute_code" />
 79 |                     <field name="name" />
 80 |                     <field name="is_required" string="Required"/>
 81 |                     <field name="is_user_defined" string="System"/>
 82 | 		    <field name="scope" />
 83 | 		    <field name="is_filterable" />
 84 | 		    <field name="is_comparable" />
 85 |                 </tree>
 86 |             </field>
 87 |         </record>
 88 | 
 89 |         <record id="view_mage_attribute_form" model="ir.ui.view">
 90 |             <field name="name">Mage Attribute Form</field>
 91 |             <field name="model">product.attribute</field>
 92 |             <field name="arch" type="xml">
 93 |                 <form>
 94 | 		    <sheet>
 95 | 			<h1>
 96 | 			    <field name="name" class="oe_inline" />
 97 | 			</h1>
 98 | 			<notebook>
 99 | 			    <page string="Properties" >
100 | 		                <separator string="Attribute Properties" colspan="4"/>
101 | 				<group>
102 | 				    <field name="attribute_code" />
103 | 				    <field name="scope" />
104 | 				    <field name="frontend_input" />
105 | 				    <field name="is_unique" />
106 | 				    <field name="is_required" />
107 | 				    <field name="apply_to" />
108 | <!--				    <field name="apply_to_selections" attrs="{'invisible':
109 | 				    [('apply_to', '!=', 'select_types')]}"
110 | 				    widget="many2many_tags" /> -->
111 | 				</group>
112 | 		                <separator string="Frontend Properties" colspan="4"/>
113 | 				<group>
114 | 				    <field name="is_searchable" />
115 | 				    <field name="is_visible_in_advanced_search" />
116 | 				    <field name="is_comparable" />
117 | 				    <field name="is_filterable" />
118 | 				    <field name="is_filterable_in_search" />
119 | 				    <field name="is_used_for_promo_rules" />
120 | 				    <field name="position" />
121 | 				    <field name="is_html_allowed_on_front" />
122 | 				    <field name="is_visible_on_front" />
123 | 				    <field name="used_in_product_listing" />
124 | 				    <field name="used_for_sort_by" />
125 | 				</group>
126 | 			    </page>
127 | 			    <page string="Values" >
128 | 			        <separator string="Manage Options" colspan="4" />
129 | 				<field name="value_ids" widget="one2many_list" colspan="4" nolabel="1" />
130 | 			    </page>
131 | 			</notebook>
132 | 		    </sheet>
133 | 		</form>
134 | 	    </field>
135 | 	</record>
136 | <!--
137 | 
138 |         <record id="view_mage_attribute_value_tree" model="ir.ui.view">
139 |             <field name="name">Mage Attribute Value Tree</field>
140 |             <field name="model">product.attribute.value</field>
141 |             <field name="arch" type="xml">
142 |                 <tree>
143 | 		    <field name="label" />
144 |                     <field name="name" />
145 |                 </tree>
146 |             </field>
147 |         </record>
148 | -->
149 | 
150 | 
151 | 	<record id="action_mage_attribute_set" model="ir.actions.act_window">
152 | 	    <field name="name">Attribute Sets</field>
153 | 	    <field name="res_model">product.attribute.set</field>
154 | 	    <field name="type">ir.actions.act_window</field>
155 | 	    <field name="view_type">form</field>
156 | 	    <field name="view_id" ref="view_mage_attribute_set_tree"/>
157 | 	    <field name="help" type="html">
158 | 	    <p class="oe_view_nocontent_create">
159 | 	    Click to Create an Attribute Set.
160 | 	    </p>
161 | 	    </field>
162 | 	</record>
163 | 
164 |         <record id="action_mage_attribute_group" model="ir.actions.act_window">
165 |             <field name="name">Attribute Groups</field>
166 |             <field name="res_model">product.attribute.group</field>
167 |             <field name="type">ir.actions.act_window</field>
168 |             <field name="view_type">form</field>
169 |             <field name="view_id" ref="view_mage_attribute_group_tree"/>
170 |             <field name="help" type="html">
171 |             <p class="oe_view_nocontent_create">
172 |             Click to Create an Attribute Group.
173 |             </p>
174 |             </field>
175 |         </record>
176 | 
177 |         <record id="action_mage_attribute" model="ir.actions.act_window">
178 |             <field name="name">Attributes</field>
179 |             <field name="res_model">product.attribute</field>
180 |             <field name="type">ir.actions.act_window</field>
181 |             <field name="view_type">form</field>
182 |             <field name="view_id" ref="view_mage_attribute_tree"/>
183 |             <field name="help" type="html">
184 |             <p class="oe_view_nocontent_create">
185 |             Click to Create an Attribute.
186 |             </p>
187 |             </field>
188 |         </record>
189 | <!--
190 |         <record id="action_mage_attribute_value" model="ir.actions.act_window">
191 |             <field name="name">Attribute Values</field>
192 |             <field name="res_model">product.attribute.value</field>
193 |             <field name="type">ir.actions.act_window</field>
194 |             <field name="view_type">form</field>
195 |             <field name="view_id" ref="view_mage_attribute_value_tree"/>
196 |             <field name="help" type="html">
197 |             <p class="oe_view_nocontent_create">
198 |             Click to Create an Attribute Value.
199 |             </p>
200 |             </field>
201 |         </record>
202 | -->
203 |         <menuitem action="action_mage_attribute_set"
204 |         id="menu_mage_attribute_set"
205 |         parent="menu_mage_attribute_management"
206 |         sequence="10"/>
207 | 
208 |         <menuitem action="action_mage_attribute_group"
209 |         id="menu_mage_attribute_group"
210 |         parent="menu_mage_attribute_management"
211 |         sequence="20"/>
212 | 
213 |         <menuitem action="action_mage_attribute"
214 |         id="menu_mage_attribute"
215 |         parent="menu_mage_attribute_management"
216 |         sequence="30"/>
217 | <!--
218 |         <menuitem action="action_mage_attribute_value"
219 |         id="menu_mage_attribute_value"
220 |         parent="menu_mage_attribute_management"
221 |         sequence="40"/>
222 | -->
223 |     </data>
224 | </openerp>
225 | 


--------------------------------------------------------------------------------
/jobs/update_status.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | from openerp.tools.translate import _
  4 | from datetime import datetime, timedelta
  5 | 
  6 | HOLDED_STATUSES = ['new', 'pending', 'holded']
  7 | CANCELED_STATUSES = ['canceled', 'closed']
  8 | 
  9 | class SaleOrder(osv.osv):
 10 |     _inherit = 'sale.order'
 11 |     _columns = {
 12 |         'mage_shipment_code': fields.char('Magento Shipping Code'),
 13 |         'mage_custom_status': fields.char('Magento Custom Status'),
 14 |     }
 15 | 
 16 | 
 17 | class MageIntegrator(osv.osv_memory):
 18 | 
 19 |     _inherit = 'mage.integrator'
 20 | 
 21 |     def wrapper_update_odoo_orders(self, cr, uid, job, context=None):
 22 | 	try:
 23 | 	    self.update_odoo_orders(cr, uid, job, context=context)
 24 | 	except Exception, e:
 25 | 	    print e
 26 | 	    html = 'Alert! The Magento to Odoo Update job has failed.'
 27 |             recipients_data = [
 28 |                 {'name': 'Person Name', 'email': 'no_email@noemail.com'},
 29 |                 {'name': 'Peson Name', 'email': 'no_email@noemail.com'},
 30 |             ]
 31 | 
 32 |             sender = 'alerts@website.com'
 33 |             subject = 'Update Script Alert'
 34 |             from_mail = "Alerts <alerts@integration.com>"
 35 | 	    self.send_error_notification(html, recipients_data, sender, subject, from_mail)
 36 | 
 37 | 	return True
 38 | 
 39 | 
 40 |     def update_odoo_orders(self, cr, uid, job, context=None):
 41 |         """ See if order status is changed in Magento. If so then update it in Odoo
 42 |         """
 43 |         storeview_obj = self.pool.get('mage.store.view')
 44 |         sale_obj = self.pool.get('sale.order')
 45 |         picking_obj = self.pool.get('stock.picking')
 46 |         procurement_obj = self.pool.get('procurement.order')
 47 | 
 48 |         store_ids = storeview_obj.search(cr, uid, [('do_not_import', '=', False)])
 49 |         mappinglines = self._get_mappinglines(cr, uid, job.mapping.id)
 50 |         instance = job.mage_instance
 51 |         #Get a list of all orders updated in the last 24 hours
 52 |         from_date = (datetime.utcnow() - timedelta(days=2)).strftime('%Y-%m-%d')
 53 | 
 54 |         for storeview in storeview_obj.browse(cr, uid, store_ids):
 55 |             filters = {
 56 |                 'store_id': {'=': storeview.external_id},
 57 |                 'updated_at': {'gteq': {'from':from_date}},
 58 |                 'created_at': {'gteq': {'from': '2016-03-01'}}
 59 |             }
 60 | 
 61 |             #Get list of IDS
 62 |             order_data = self._get_job_data(cr, uid, job, 'sales_order.search', [filters])
 63 |             if not order_data:
 64 |                 continue
 65 | 
 66 |             #For each order in the response of orders updated
 67 |             for order in order_data:
 68 |                 increment_id = order['increment_id']
 69 | 
 70 |                 #Check Magento Status
 71 |                 mage_status = order.get('status')
 72 |                 if not mage_status:
 73 |                     continue
 74 | 
 75 |                 #Find sales in Odoo that match the given id
 76 |                 #an improvement would be to search with also mage_status to reduce loading records
 77 |                 sale_ids = sale_obj.search(cr, uid, [('mage_order_number', '=', increment_id)])
 78 |                 if not sale_ids:
 79 |                     continue
 80 | 
 81 |                 sale = sale_obj.browse(cr, uid, sale_ids[0])
 82 | 
 83 |                 #if the mage_status in Odoo matches the mage_status in Magento, then no action is needed
 84 |                 if sale.mage_custom_status == mage_status:
 85 |                     continue
 86 | 
 87 |                 #if the order is held in Odoo but has been released in Magento and not canceled
 88 |                 if sale.mage_custom_status in HOLDED_STATUSES and mage_status not in HOLDED_STATUSES and mage_status != 'canceled':
 89 |                     self.mage_unhold_order(cr, uid, sale, mage_status)
 90 | 
 91 |                 #No matter what happens to the order, if the status has changed ensure it updates in shipworks
 92 |                 self.mage_status_changed(cr, uid, sale, mage_status)
 93 | 
 94 |                 #RULE 2 - If the order is pending then unreserve any reserved inventory
 95 |                 if mage_status in HOLDED_STATUSES:
 96 |                     self.mage_status_pending(cr, uid, sale)
 97 | 
 98 | 
 99 |                 elif mage_status in CANCELED_STATUSES and sale.state != 'cancel':
100 |                     self.mage_status_canceled(cr, uid, job, sale)
101 | 
102 | 
103 |                 #RULE 4 - If the order is complete in Magento but is not detected as shipped in Odoo
104 |                 elif mage_status == 'complete' and not sale.shipped:
105 |                     self.mage_status_complete(cr, uid, sale)
106 | 
107 |         return True
108 | 
109 | 
110 |     def mage_status_canceled(self, cr, uid, job, sale, context=None):
111 | 	print 'Cancelling Order', sale.name
112 |         return self.cancel_one_order(cr, uid, job, sale, False)
113 | 
114 | 
115 |     def mage_status_complete(self, cr, uid, sale, context=None):
116 | 	sale_obj = self.pool.get('sale.order')
117 | 	picking_obj = self.pool.get('stock.picking')
118 | 
119 |         if sale.state == 'draft':
120 |             self.confirm_one_order(cr, uid, sale)
121 | 
122 |         if sale.state == 'cancel':
123 |             sale.state = 'draft'
124 |             self.confirm_one_order(cr, uid, sale)
125 | 
126 |         for picking in sale.picking_ids:
127 | 	    if picking.state != 'done' and picking.backorder_id:
128 | 		continue
129 | 
130 |             if picking.state == 'done':
131 |                 continue
132 | 
133 |             if picking.state == 'cancel':
134 | 		picking.action_back_to_draft()
135 | 
136 |             if picking.state == 'draft':
137 |                 picking_obj.action_confirm(cr, uid, [picking.id], context=context)
138 | 
139 |             if picking.state != 'assigned':
140 |                 picking_obj.force_assign(cr, uid, [picking.id])
141 | 
142 |             picking.do_transfer()
143 | 	    cr.commit()
144 |             picking_obj.write(cr, uid, [picking.id], {'sw_exp': False, 'sw_pre_exp': False})
145 | 
146 |         return True
147 | 
148 | 
149 |     def mage_status_pending(self, cr, uid, sale, context=None):
150 |         """
151 |         Put the order on hold
152 |         """
153 | 
154 |         picking_obj = self.pool.get('stock.picking')
155 | 
156 |         #if the order is already confirmed then cancel all of the pickings and reset them to draft
157 | 	print 'SALE NAME', sale.name
158 |         if sale.state == 'done':
159 |             #cannot hold a done order!
160 |             return True
161 | 
162 |         if sale.state == 'cancel':
163 |             #Reset te state to draft
164 |             sale.state = 'draft'
165 | 
166 |         if sale.picking_ids:
167 |             for picking in sale.picking_ids:
168 | 
169 |                 if picking.state in ['draft', 'done']:
170 |                     continue
171 | 
172 |                 if picking.state in ['partially_available', 'assigned']:
173 |                     picking_obj.do_unreserve(cr, uid, picking.id)
174 | 
175 |                 if picking.state != 'cancel':
176 |                     picking_obj.action_cancel(cr, uid, picking.id)
177 | 
178 |                 if picking.state == 'cancel':
179 |                     picking.action_back_to_draft()
180 | 
181 |                 picking.sw_exp = False
182 | 		picking.sw_pre_exp = False
183 | 
184 |         return True
185 | 
186 | 
187 |     def mage_status_changed(self, cr, uid, sale, mage_status, context=None):
188 | 	picking_obj = self.pool.get('stock.picking')
189 |         sale.mage_custom_status = mage_status
190 |         picking_ids = picking_obj.search(cr, uid, [('sale', '=', sale.id)])
191 |         if picking_ids:
192 |             picking_obj.write(cr, uid, picking_ids, {'sw_exp': False, 'sw_pre_exp': False})
193 | 
194 | 
195 |     def mage_unhold_order(self, cr, uid, sale, mage_status, context=None):
196 | 	if not context:
197 | 	    context = None
198 | 	picking_obj = self.pool.get('stock.picking')
199 |         if sale.state == 'draft':
200 |             self.confirm_one_order(cr, uid, sale)
201 | 
202 |         for picking in sale.picking_ids:
203 |             if picking.state == 'draft':
204 | 		picking_obj.action_confirm(cr, uid, [picking.id], context=context)
205 |                 #picking.action_confirm()
206 |                 picking.sw_exp = False
207 | 		picking.sw_pre_exp = False
208 | 
209 |         return;
210 | 
211 | 
212 |     def send_error_notification(self, html, recipients_data, sender, subject, from_mail, context=None):
213 |         from email.MIMEMultipart import MIMEMultipart
214 |         from email.MIMEText import MIMEText
215 |         from email.MIMEImage import MIMEImage
216 |         import smtplib
217 |         receivers = []
218 |         to_list = []
219 |         msg = MIMEMultipart()
220 |         msg['Subject'] = subject
221 |         msg['From'] = from_mail
222 | 
223 |         for person in recipients_data:
224 |             to_list.append("<%s>" % (person['email']))
225 |             receivers.append(person['email'])
226 | 
227 |         msg['To'] = ', '.join(to_list)
228 |         body = html
229 |         content = MIMEText(body, 'html')
230 |         msg.attach(content)
231 |         try:
232 |             smtpObj = smtplib.SMTP('localhost')
233 |             smtpObj.sendmail(sender, receivers, msg.as_string())
234 |         except Exception, e:
235 |             print 'THERE WAS EXCEPTION', e
236 | 
237 |         return True
238 | 


--------------------------------------------------------------------------------
/models/attribute.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | from lxml import etree
  4 | from openerp.tools.translate import _
  5 | 
  6 | 
  7 | 
  8 | class ProductAttributeSet(osv.osv):
  9 |     _name = 'product.attribute.set'
 10 |     _description = "Product Attribute Set"
 11 | 
 12 |     def _attribute_ids(self, cr, uid, ids, fieldname, arg, context=None):
 13 | 	id = ids[0]
 14 | 	query = "SELECT attribute.attribute_id\n" \
 15 | 	"FROM product_attribute_group gr\n" \
 16 | 	"JOIN product_attribute_set set ON (gr.set = set.id)\n" \
 17 | 	"JOIN product_group_attribute_rel attribute ON (gr.id = attribute.group_id)\n" \
 18 | 	"WHERE set.id = %s" % id
 19 | 	cr.execute(query)
 20 | 	results = cr.fetchall()
 21 | 	print results
 22 | 	return True
 23 | 
 24 |     _columns = {
 25 | 	'external_id': fields.integer('External Id', select=True, copy=False),
 26 | 	'name': fields.char('Name'),
 27 | 	'groups': fields.one2many('product.attribute.group', 'set', 'Attribute Groups'),
 28 | 	'attributes': fields.function(_attribute_ids, method=True, type="boolean", store=False, string="Attributes"),
 29 |     }
 30 | 
 31 | 
 32 |     def prepare_odoo_record_vals(self, cr, uid, job, record):
 33 |         return {
 34 |                 'name': record['name'],
 35 |                 'external_id': record['set_id'],
 36 |         }
 37 | 
 38 | 
 39 | class ProductAttributeGroup(osv.osv):
 40 |     _name = 'product.attribute.group'
 41 |     _description = "Product Attribute Group"
 42 |     _order = 'sort_order'
 43 |     _columns = {
 44 | 	'external_id': fields.integer('External Id', select=True, copy=False),
 45 | 	'name': fields.char('name'),
 46 | 	'set': fields.many2one('product.attribute.set', 'Attribute Set'),
 47 | 	'default': fields.integer('Default'),
 48 | 	'sort_order': fields.integer('Sort Order'),
 49 | 	'attributes': fields.many2many('product.attribute',
 50 | 		'product_group_attribute_rel', 'group_id', 'attribute_id', 'Attributes'),
 51 |     }
 52 | 
 53 | 
 54 |     def prepare_odoo_record_vals(self, cr, uid, job, record):
 55 | 	set_obj = self.pool.get('product.attribute.set')
 56 |         return {
 57 |                 'default': record['default_id'],
 58 |                 'set': set_obj.get_mage_record(cr, uid, record['attribute_set_id']),
 59 |                 'sort_order': record['sort_order'],
 60 |                 'external_id': record['attribute_group_id'],
 61 |                 'name': record['attribute_group_name'],
 62 |         }
 63 | 
 64 | 
 65 | class ProductAttribute(osv.osv):
 66 |     _inherit = 'product.attribute'
 67 | 
 68 | 
 69 |     def _frontend_options(self):
 70 |         return {
 71 |                 'select': 'many2one',
 72 |                 'text': 'char',
 73 |                 'date': 'date',
 74 | 		'hidden': 'boolean',
 75 | 		'datetime': 'datetime',
 76 | 		'multiline': 'char',
 77 |                 'boolean': 'boolean',
 78 |                 'textarea': 'text',
 79 | 		'image': 'binary',
 80 |                 'multiselect': 'many2many',
 81 |                 'price': 'float',
 82 | 		'weight': 'float',
 83 |                 'media_image': 'binary',
 84 |                 'gallery': 'binary',
 85 |         }
 86 | 
 87 |     def _get_boolean(self, field):
 88 |         return True if field == '1' else False
 89 | 
 90 | 
 91 |     _columns = {
 92 | 	'id': fields.integer('ID'),
 93 | 	'apply_to': fields.selection([('all_types', 'All Product Types'),
 94 | 				      ('select_types', 'Selected Product Types')
 95 | 	],'Apply To'),
 96 | #	'apply_to_selections': fields.many2many('mage.product.type', 'mage_attribute_prod_type_rel', 
 97 | #		'attribute', 'type', 'Selections'),
 98 | 	'external_id': fields.char('External Id', select=True, copy=False),
 99 | 	'attribute_code': fields.char('Attribute Code', select=True),
100 | 	'default_value': fields.char('Default Value'),
101 | 	'ttype': fields.char('Odoo Model Field Type'),
102 |         'frontend_input': fields.selection([
103 | 		('select', 'Dropdown'),
104 |                 ('text', 'Text Field'),
105 |                 ('date', 'date'),
106 |                 ('hidden', 'Hidden'),
107 |                 ('datetime', 'Date'),
108 |                 ('multiline', 'Multi Line'),
109 |                 ('boolean', 'Yes/No'),
110 |                 ('textarea', 'Text Area'),
111 |                 ('image', 'Image'),
112 |                 ('multiselect', 'Multiple Select'),
113 |                 ('price', 'Price'),
114 |                 ('weight', 'Weight'),
115 |                 ('media_image', 'Media Image'),
116 |                 ('gallery', 'Gallery')
117 | 	], 'Catalog Input Type'),
118 | 	'name': fields.char('Frontend Label'),
119 | 	'is_comparable': fields.boolean('Comparable on Front-end'),
120 | 	'is_configurable': fields.boolean('Use to Create Configurable Product'),
121 | 	'is_filterable': fields.selection([
122 | 					   ('0', 'No'),
123 | 					   ('1', 'Filterable (with results)'),
124 | 					   ('2', 'Filterable (no results)')
125 | 	], 'Use in Layered Navigation'),
126 | 	'scope': fields.selection([('0', 'Store View'),
127 | 				   ('1', 'Global'),
128 | 				   ('2', 'Website')
129 | 	], 'Scope', help="Declare attribute value saving scope"),
130 | 	'is_filterable_in_search': fields.boolean('Use In Search Results Layered Navigation',
131 | 		help="Can be used only with catalog input type Dropdown, Multiple Select and Price"),
132 | 	'is_html_allowed_on_front': fields.boolean('Allow HTML Tags on Frontend'),
133 | 	'is_required': fields.boolean('Values Required'),
134 | 	'is_searchable': fields.boolean('Use in Quick Search'),
135 | 	'is_unique': fields.boolean('Unique Value'),
136 | 	'is_used_for_price_rules': fields.boolean('is_used_for_price_rules'),
137 | 	'is_used_for_promo_rules': fields.boolean('Use for Promo Rules Conditions'),
138 | 	'is_user_defined': fields.boolean('User Attribute'),
139 | 	'is_visible': fields.boolean('System Hidden Attribute'),
140 | 	'is_visible_in_advanced_search': fields.boolean('Use in Advanced Search'),
141 | 	'is_visible_on_front': fields.boolean('Visible on Catalog Pages on Front-end'),
142 | 	'is_wysiwyg_enabled': fields.boolean('Enable WYSIWYG'),
143 | 	'note': fields.char('Note'),
144 | 	'position': fields.integer('Position'),
145 | 	'used_for_sort_by': fields.boolean('Used for Sorting in Product Listing'),
146 | 	'used_in_product_listing': fields.boolean('Used in Product Listing'),
147 |     }
148 | 
149 |     def prepare_odoo_record_vals(self, cr, uid, job, record):
150 | 	dict = self._frontend_options()
151 |         return {
152 |                 'is_visible': self._get_boolean(record['is_visible']),
153 |                 'ttype': dict[record['frontend_input']],
154 |                 'is_wysiwyg_enabled': self._get_boolean(record['is_wysiwyg_enabled']),
155 |                 'is_used_for_promo_rules': self._get_boolean(record['is_used_for_promo_rules']),
156 |                 'is_configurable': self._get_boolean(record['is_configurable']),
157 |                 'is_searchable': self._get_boolean(record['is_searchable']),
158 |                 'scope': record['is_global'],
159 |                 'is_visible_in_advanced_search': self._get_boolean(record['is_visible_in_advanced_search']),
160 |                 'is_user_defined': self._get_boolean(record['is_user_defined']),
161 |                 'default_value': record['default_value'],
162 |                 'frontend_input': record['frontend_input'],
163 |                 'name': record['frontend_label'],
164 |                 'is_filterable_in_search': self._get_boolean(record['is_filterable_in_search']),
165 |                 'is_required': self._get_boolean(record['is_required']),
166 |                 'is_filterable': record['is_filterable'],
167 |                 'used_in_product_listing': self._get_boolean(record['used_in_product_listing']),
168 |                 'is_used_for_price_rules': self._get_boolean(record['is_used_for_price_rules']),
169 |                 'position': record['position'],
170 |                 'attribute_code': record['attribute_code'],
171 |                 'is_unique': self._get_boolean(record['is_unique']),
172 |                 'external_id': record['attribute_id'],
173 |                 'is_comparable': self._get_boolean(record['is_comparable']),
174 |         }
175 | 
176 | 
177 | class ProductAttributeValue(osv.osv):
178 |     _inherit = 'product.attribute.value'
179 | 
180 |     _columns = {
181 |         'external_id': fields.char('External Id', select=True, help="The Option id from Magento"),
182 |         'name': fields.char('Admin', translate=True, required=True),
183 |         'attribute_code': fields.related('attribute_id', 'attribute_code',
184 |                 type="char", relation="product.attribute", store=True, string="Attribute Code"
185 |         ),
186 |     }
187 | 
188 |     def prepare_odoo_record_vals(self, cr, uid, job, record):
189 | 	attribute_obj = self.pool.get('product.attribute')
190 | 
191 |         return {
192 |                 'attribute_id': attribute_obj.get_mage_record(cr, uid, record['attribute_id']),
193 |                 'external_id': record['value'],
194 |                 'name': record['label'],
195 |         }
196 | 
197 | 
198 |     #Needed for temp hack
199 |     def upsert_mage_record(self, cr, uid, vals):
200 |         existing_sets = self.search(cr, uid, [('external_id', '=', vals['external_id'])])
201 |         if not existing_sets:
202 |                 existing_sets = self.search(cr, uid, [('attribute_id', '=', vals['attribute_id']), ('name', '=', vals['name'])])
203 | 
204 |         if existing_sets:
205 |             self.write(cr, uid, existing_sets[0], vals)
206 |             return(False, existing_sets[0])
207 |         else:
208 |             self.create(cr, uid, vals)
209 |             return True
210 | 


--------------------------------------------------------------------------------
/models/partner.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from pprint import pprint as pp
  3 | 
  4 | class ResPartner(osv.osv):
  5 |     _inherit = 'res.partner'
  6 |     _columns = {
  7 | 		'firstname': fields.char('Firstname'),
  8 | 		'company': fields.char('Company'),
  9 | 		'is_default_billing': fields.boolean('Is Default Billing'),
 10 | 		'is_default_shipping': fields.boolean('Is Default Shipping'),
 11 | 		'lastname': fields.char('Lastname'),
 12 | 		'external_address_id': fields.integer('Magento Address Id', readonly=True),
 13 | 		#'address_type': fields.selection([('billing', 'Billing'), ('shipping', 'Shipping')], 'Magento Address Type'),
 14 | 		'external_id': fields.integer('Magento ID', copy=False, select=True, readonly=True),
 15 |     }
 16 | 
 17 | 
 18 |     def get_sale_address(self, cr, uid, partner_id, type, context=None):
 19 | 	base_search = ('parent_id', '=', partner_id)
 20 | 	if type == 'invoice':
 21 | 	    preferred = 'is_default_billing'
 22 | 	elif type == 'delivery':
 23 | 	    preferred = 'is_default_shipping'
 24 | 	else:
 25 | 	    preferred = False
 26 | 
 27 | 	if preferred:
 28 | 	    preferred_ids = self.search(cr, uid, [(preferred, '=', True), ('type', '=', type), base_search])
 29 | 	    if preferred_ids:
 30 | 		return preferred_ids[0]
 31 | 
 32 |         address_ids = self.search(cr, uid, [('type', '=', type), base_search])
 33 | 	if address_ids:
 34 | 	    return address_ids[0]
 35 | 
 36 | 	contact_ids = self.search(cr, uid, [('type', '=', 'contact'), base_search])
 37 | 	if not contact_ids:
 38 | 	    return partner_id
 39 | 
 40 | 	return contact_ids[0]
 41 | 
 42 | 
 43 |     def sync_one_mage_customer(self, cr, uid, ids, context=None):
 44 | 	integrator_obj = self.pool.get('mage.integrator')
 45 | 	job_obj = self.pool.get('mage.job')
 46 | 	job_ids = job_obj.search(cr, uid, [('python_function_name', '=', 'import_all_partners')])
 47 | 	job = job_obj.browse(cr, uid, job_ids[0])
 48 | 
 49 | 	partner = self.browse(cr, uid, ids[0])
 50 | 	if not partner.external_id:
 51 | 	    return True
 52 | 
 53 | 	integrator_obj.import_partners(cr, uid, job, [partner.external_id])
 54 | 	return True
 55 | 
 56 | 
 57 |     def get_or_create_customer(self, cr, uid, record, context=None):
 58 | 
 59 |         partner_ids = self.search(cr, uid, [('external_id', '=', \
 60 |             record['entity_id'])], limit=1)
 61 | 
 62 |         vals = {
 63 |                     'firstname': firstname,
 64 |                     'lastname': lastname,
 65 |                     'is_company': False,
 66 |                     'name': firstname + ' ' + lastname,
 67 |                     'email': record['email'],
 68 |                     'external_id': record['entity_id'],
 69 | 
 70 |         }
 71 | 
 72 | 	if partner_ids:
 73 | 	    self.write(cr, uid, partner_ids[0], vals)
 74 | 	    return self.browse(cr, uid, partner_ids[0])
 75 | 
 76 | 	else:
 77 | 	    firstname = record['firstname']
 78 | 	    lastname = record['lastname'] or 'no lastname'
 79 | 	    vals = {
 80 | 		    'firstname': firstname,
 81 | 		    'lastname': lastname,
 82 | 		    'is_company': False,
 83 | 		    'name': firstname + ' ' + lastname,
 84 | 		    'email': record['email'],
 85 | 		    'external_id': record['entity_id'],
 86 | 
 87 | 	    }
 88 | 
 89 | 
 90 | 	    partner = self.create(cr, uid, vals)
 91 | 
 92 | 	    return self.browse(cr, uid, partner)
 93 | 
 94 | 
 95 |     def get_or_create_order_customer(self, cr, uid, record, context=None):
 96 | 
 97 | 
 98 | 	if record.get('odoo_customer_id'):
 99 | 	    return self.browse(cr, uid, record['odoo_customer_id'])
100 | 
101 | 	elif record['customer_id'] == '0' or record.get('customer_is_guest') \
102 | 		and record.get('customer_is_guest') == '1':
103 | 	    partner_ids = []
104 | 
105 | 	else:
106 | 	    partner_ids = self.search(cr, uid, [('external_id', '=', \
107 | 		record['customer_id'])], limit=1)
108 | 
109 | 	if partner_ids:
110 | 	    return self.browse(cr, uid, partner_ids[0])
111 | 
112 | 	else:
113 | 	    firstname = record['customer_firstname']
114 | 	    lastname = record['customer_lastname'] or 'no lastname'
115 | 	    if not firstname:
116 | 		firstname = 'No Firstname'
117 | 	    if not lastname:
118 | 		lastname = 'No Lastname'
119 | 	    vals = {
120 | 		    'firstname': firstname,
121 | 		    'lastname': lastname,
122 | 		    'is_company': False,
123 | 		    'name': firstname + ' ' + lastname,
124 | 		    'email': record['customer_email'],
125 | 		    'external_id': record['customer_id'],
126 | 
127 | 	    }
128 | 
129 | 
130 | 	    partner = self.create(cr, uid, vals)
131 | 
132 | 	    return self.browse(cr, uid, partner)
133 | 
134 | 
135 |     def get_or_create_partner_address(self, cr, uid, address_data, \
136 | 		partner, address_type, context=None):
137 | 
138 | 	if not partner.child_ids:
139 | 	    return self.create_mage_partner_address(cr, uid, address_data, partner, context)
140 | 	
141 | 	for address in partner.child_ids:
142 | 	    if self.match_mage_address(
143 | 		cr, uid, address, address_data
144 | 	    ):
145 | 		address.company = address_data.get('company')
146 | 		if address_type:
147 | 		    address.type = address_type
148 | 		address.external_address_id = address_data.get('entity_id')
149 | 	        return address
150 | 
151 |         else:
152 |             return self.create_mage_partner_address(
153 |                 cr, uid, address_data, partner, address_type, context
154 |             )
155 | 
156 | 
157 |     def parse_customer_address(self, cr, uid, address_data):
158 | 	#Build a dictionary of prepared address values
159 | 	#Also include an address object with no spaces for matching
160 | 	#an existing record
161 | 	vals = {}
162 |         if address_data.get('street'):
163 |             address_data['street'] = address_data['street'].replace('\r', '\n')
164 |             addr_lines = address_data['street'].split('\n')
165 |             addr_line1 = addr_lines[0]
166 |             if len(addr_lines) > 1:
167 |                 addr_line2 = addr_lines[1].replace(' ', '') if addr_lines[1] else None
168 |             else:
169 |                 addr_line2 = None
170 |         else:
171 |             addr_line1 = None
172 |             addr_line2 = None
173 | 
174 | 	vals = {
175 | 		'addr_1': addr_line1,
176 | 		'addr_1_match':addr_line1.replace(' ', '').lower() if addr_line1 else addr_line1,
177 |                 'addr_2': addr_line2,
178 |                 'addr_2_match': addr_line2.replace(' ', '').lower() if addr_line2 else addr_line2,
179 | 		'zip': address_data['postcode'],
180 | 		'zip_match': address_data['postcode'].replace(' ', '').lower() if address_data['postcode'] else address_data['postcode'],
181 | 		'city': address_data['city'],
182 | 		'city_match': address_data['city'].replace(' ', '').lower() if address_data['city'] else address_data['city'],
183 | 	}
184 | 
185 | 	return vals
186 | 
187 | 
188 |     def parse_odoo_address(self, cr, uid, address):
189 | 	street = address.street or None
190 | 	street2 = address.street2 or None
191 | 	zip = address.zip or None
192 | 	city = address.city or None
193 | 
194 | 	vals = {
195 | 		'address': street.replace(' ', '').lower() if street else street,
196 | 		'address2': street2.replace(' ', '').lower() if street2 else street2,
197 | 		'zip': zip.replace(' ', '').lower() if zip else zip,
198 | 		'city': city.replace(' ', '').lower() if city else city,
199 | 	}
200 | 
201 | 	return vals
202 | 
203 | 
204 |     def match_mage_address(self, cr, uid, address, address_data):
205 |         # Check if the name matches
206 | 	firstname = address_data['firstname']
207 | 	lastname = address_data['lastname'] or ''
208 | 	data_name = firstname + lastname
209 | 	final_data_name = data_name.replace(' ', '').lower()
210 | 
211 | 	addr_name = address.name
212 | 	match_name = addr_name.replace(' ', '').lower()
213 | 
214 | 	if match_name != final_data_name:
215 | 	    return False
216 | 
217 | 	vals = self.parse_customer_address(cr, uid, address_data)
218 | 	match = self.parse_odoo_address(cr, uid, address)
219 | 
220 |         if not all([
221 |             (match['address'] or None) == (vals['addr_1_match'] or None),
222 | 	    (match['address2'] or None) == (vals['addr_2_match'] or None),
223 |             (match['zip'] or None) == (vals['zip_match'] or None),
224 |             (match['city'] or None) == (vals['city_match'] or None),
225 |         ]):
226 | 
227 |             return False
228 | 
229 |         return True
230 | 
231 | 
232 |     def create_mage_partner_address(self, cr, uid, address_data, partner, address_type, context=None):
233 |         country_obj = self.pool.get('res.country')
234 |         state_obj = self.pool.get('res.country.state')
235 | 
236 |         country = country_obj.search_using_magento_code(
237 |             cr, uid, address_data['country_id'], context
238 |         )
239 |         if address_data['region']:
240 |             state_id = state_obj.find_or_create_using_magento_region(
241 |                 cr, uid, country, address_data['region'], context
242 |             ).id
243 |         else:
244 |             state_id = None
245 | 
246 | 	vals = self.parse_customer_address(cr, uid, address_data)
247 | 
248 | 	firstname = address_data['firstname']
249 | 	lastname = address_data['lastname'] or 'no lastname'
250 |         address_id = self.create(cr, uid, {
251 |             'name': u' '.join(
252 |                 [firstname, lastname]
253 |             ),
254 | 	    'firstname': firstname,
255 | 	    'lastname': lastname,
256 | 	    'type': address_type,
257 | 	    'company': address_data.get('company'),
258 | 	    'external_address_id': address_data.get('entity_id'),
259 |             'street': vals['addr_1'],
260 |             'street2': vals['addr_2'],
261 |             'state_id': state_id,
262 |             'country_id': country.id,
263 |             'city': vals['city'],
264 |             'zip': vals['zip'],
265 | 	    'email': address_data.get('email'),
266 |             'phone': address_data['telephone'],
267 | 	    'email': address_data.get('email'),
268 |             'fax': address_data.get('fax'),
269 |             'parent_id': partner.id,
270 |         }, context=context)
271 | 
272 |         return self.browse(cr, uid, address_id, context=context)
273 | 


--------------------------------------------------------------------------------
/views/sale.xml:
--------------------------------------------------------------------------------
  1 | <openerp>
  2 |     <data>
  3 | 
  4 | 	<record id="view_mage_sale_order_search" model="ir.ui.view">
  5 | 	    <field name="name">Mage Sale Order Search</field>
  6 | 	    <field name="model">sale.order</field>
  7 | 	    <field name="inherit_id" ref="sale.view_sales_order_filter" />
  8 | 	    <field name="arch" type="xml">
  9 | 		<field name="name" position="after">
 10 |                     <field name="order_email" />
 11 |                     <field name="mage_store" />
 12 | 		</field>
 13 | 	    </field>
 14 | 	</record>
 15 | 
 16 | 	<record id="view_mage_sale_order_tree" model="ir.ui.view">
 17 | 	    <field name="name">Mage Sale Order Tree</field>
 18 | 	    <field name="model">sale.order</field>
 19 | 	    <field name="inherit_id" ref="sale.view_order_tree" />
 20 | 	    <field name="arch" type="xml">
 21 | 		<field name="partner_id" position="after" >
 22 | 		    <field name="order_email" />
 23 | 		    <field name="mage_store" />
 24 | 		    <field name="mage_custom_status" />
 25 | 		</field>
 26 | 	    </field>
 27 | 	</record>
 28 | 
 29 | 	<record id="view_mage_quote_tree" model="ir.ui.view">
 30 | 	    <field name="name">Mage Sale Quote Tree</field>
 31 | 	    <field name="model">sale.order</field>
 32 | 	    <field name="inherit_id" ref="sale.view_quotation_tree" />
 33 |             <field name="arch" type="xml">
 34 |                 <field name="partner_id" position="after" >
 35 |                     <field name="order_email" />
 36 |                     <field name="mage_store" />
 37 |                     <field name="mage_custom_status" />
 38 |                 </field>
 39 |             </field>
 40 |         </record>
 41 | 
 42 |         <record id="view_mage_order_form" model="ir.ui.view">
 43 |             <field name="name">Mage Sale Order Form</field>
 44 |             <field name="model">sale.order</field>
 45 |             <field name="inherit_id" ref="payment_method.view_sale_billing_form" />
 46 |             <field name="arch" type="xml">
 47 | <!--                <button name="invoice_recreate" position="before" >
 48 |                     <button name="create_mage_sale_order" type="object" string="Create Magento Order" />
 49 |                </button> -->
 50 | 		<field name="partner_invoice_id" position="replace" />
 51 | 		<field name="partner_shipping_id" position="replace" />
 52 | 		<field name="partner_id" position="replace">
 53 | 		    <field name="partner_id" on_change="onchange_sale_partner_id(partner_id, context)" domain="[('parent_id', '=', False)]" context="{'search_default_customer':1}" options='{"always_reload": True}'/>
 54 | 		    <field name="order_email" />
 55 |                     <field name="mage_custom_status" />
 56 | 		</field>
 57 | 		<group name="payment" position="inside" >
 58 | 		    <field name="mage_invoice_complete" attrs="{'invisible': [('mage_store', '=', False)]}"/>
 59 | 		    <field name="mage_order_prepaid" attrs="{'invisible': [('mage_store', '=', False)]}"/>
 60 | 		    <field name="mage_order_total" attrs="{'invisible': [('mage_store', '=', False)]}"/>
 61 | 		    <field name="mage_paid_total" attrs="{'invisible': [('mage_store', '=', False)]}"/>
 62 | 		    <field name="mage_paid_date" attrs="{'invisible': [('mage_store', '=', False)]}"/>
 63 | 		</group>
 64 | 		<group name="payment" position="before" >
 65 | 		    <group>
 66 | 			 <field name="partner_invoice_id" groups="sale.group_delivery_invoice_address" context="{'default_type':'invoice', 'show_address': 1}" options='{"always_reload": True}'/>
 67 | 		    </group>
 68 | 		    <group name="paypal" string="PayPal">
 69 | 			<field name="paypal_transaction_id" />
 70 | 			<field name="paypal_buyer_email" />
 71 | 			<field name="paypal_address_status" />
 72 | 			<field name="paypal_payer_id" />
 73 | 			<field name="paypal_payer_status" />
 74 | 		 	<field name="paypal_token" />
 75 | 		    </group>
 76 | 		</group>
 77 |                 <page string="Billing" position="after" >
 78 |                     <page string="Shipping" >
 79 | 			<group>
 80 | 			    <field name="partner_shipping_id" on_change="onchange_delivery_id(company_id, partner_id, partner_shipping_id, fiscal_position)" groups="sale.group_delivery_invoice_address" context="{'default_type':'delivery', 'show_address': 1}" options='{"always_reload": True}'/>
 81 | 			</group>
 82 | 			<group name="carrier">
 83 | 			    <group name="mage_shipment" string="Delivery">
 84 | 			        <field name="mage_shipment_complete" />
 85 | 			    </group>
 86 | 			</group>
 87 |                         <group string="Delivery Orders" name="pickings">
 88 |                             <field name="picking_ids" nolabel="1" widget="one2many_list">
 89 | 				<tree>
 90 | 				    <field name="name" />
 91 | 				    <field name="carrier_id" string="Ship Via" />
 92 | 				    <field name="state" />
 93 | 				</tree>
 94 |                             </field>
 95 |                         </group>
 96 |                     </page>
 97 | 		    <page string="Tracking" >
 98 | 			<group string="Packages">
 99 | 			    <field name="packages" widget="one2many_list" nolabel="1"/>
100 | 			</group>
101 | 		    </page>
102 |                 </page>
103 | 	    </field>
104 | 	</record>
105 | 
106 | 	<record id="view_mage_sale_stock_form" model="ir.ui.view">
107 | 	    <field name="name">Mage Sale Stock Order Form</field>
108 | 	    <field name="model">sale.order</field>
109 | 	    <field name="inherit_id" ref="sale_stock.view_order_form_inherit"/>
110 | 	    <field name="arch" type="xml">
111 |                 <field name="warehouse_id" position="after">
112 |                     <field name="mage_store" />
113 | 		    <field name="department" />
114 |                 </field>
115 |                 <field name="order_policy" position="after">
116 |                     <field name="mage_order_status" />
117 |                     <field name="mage_order_number" />
118 |                     <field name="ip_address" />
119 | 		    <field name="external_id" readonly="1" />
120 |                 </field>
121 | 	    </field>
122 | 	</record>
123 | 
124 |         <record id="mage_carrier_service_search_view" model="ir.ui.view">
125 |             <field name="name">Carrier Many2one Tree View</field>
126 |             <field name="model">delivery.carrier</field>
127 |             <field name="arch" type="xml">
128 | 		<search>
129 | 		    <field name="name" />
130 | 		</search>
131 | 	    </field>
132 | 	</record>
133 | 
134 | 
135 |         <record id="delivery.view_order_withcarrier_form" model="ir.ui.view">
136 |             <field name="name">delivery.sale.order_withcarrier.form.view</field>
137 |             <field name="model">sale.order</field>
138 |             <field name="inherit_id" ref="view_mage_order_form"/>
139 |             <field name="arch" type="xml">
140 | 		<group name="mage_shipment" position="inside">
141 |                         <label for="carrier_id"/>
142 |                         <div>
143 |                             <field name="carrier_id" context="{'order_id':active_id or False, 'tree_view_ref': 'mage_carrier_service_search_view'}" class="oe_inline" colspan="3"/>
144 |                             <button name="delivery_set" string="Add in Quote" type="object"
145 |                                 class="oe_edit_only"
146 |                                 attrs="{'invisible':['|',('carrier_id','=',False),('state','not in',('draft','sent'))]}"/>
147 |                             <br/>
148 |                             <label string="If you don't 'Add in Quote', the exact price will be computed when invoicing based on delivery order(s)."
149 |                                 class="oe_edit_only"
150 |                                 attrs="{'invisible':['|',('carrier_id','=',False),('state','not in',('draft','sent'))]}"/>
151 |                         </div>
152 |                 </group>
153 |             </field>
154 |         </record>
155 | 
156 | 	<record id="sale.action_quotations" model="ir.actions.act_window">
157 | 	    <field name="name">Quotations</field>
158 | 	    <field name="type">ir.actions.act_window</field>
159 | 	    <field name="res_model">sale.order</field>
160 | 	    <field name="view_type">form</field>
161 | 	    <field name="context">{}</field>
162 | 	    <field name="view_id" ref="sale.view_quotation_tree"/>
163 | 	    <field name="view_mode">tree,form,calendar,graph</field>
164 | 	    <field name="domain">[('state','in',('draft','sent'))]</field>
165 | 	    <field name="search_view_id" ref="sale.view_sales_order_filter"/>
166 | 	    <field name="help" type="html">
167 | 	      <p class="oe_view_nocontent_create">
168 | 	      Click to create a quotation, the first step of a new sale.
169 | 	      </p><p>
170 | 	      Odoo will help you handle efficiently the complete sale flow:
171 | 	      from the quotation to the sales order, the
172 | 	      delivery, the invoicing and the payment collection.
173 | 	      </p><p>
174 | 	      The social feature helps you organize discussions on each sales
175 | 	      order, and allow your customers to keep track of the evolution
176 | 	      of the sales order.
177 | 	      </p>
178 | 	    </field>
179 | 	</record>
180 | 
181 | 	<record id="action_canceled_orders" model="ir.actions.act_window">
182 | 	    <field name="name">Canceled Orders</field>
183 | 	    <field name="type">ir.actions.act_window</field>
184 | 	    <field name="res_model">sale.order</field>
185 | 	    <field name="view_type">form</field>
186 | 	    <field name="context">{}</field>
187 | 	    <field name="view_id" ref="sale.view_quotation_tree"/>
188 | 	    <field name="view_mode">tree,form,calendar,graph</field>
189 | 	    <field name="domain">[('state', '=', 'cancel')]</field>
190 | 	    <field name="search_view_id" ref="sale.view_sales_order_filter"/>
191 | 	</record>
192 | 
193 | 
194 | 	<record id="sale.action_orders" model="ir.actions.act_window">
195 | 	    <field name="name">Sales Orders</field>
196 | 	    <field name="type">ir.actions.act_window</field>
197 | 	    <field name="res_model">sale.order</field>
198 | 	    <field name="view_type">form</field>
199 | 	    <field name="view_mode">tree,form,calendar,graph</field>
200 | 	    <field name="search_view_id" ref="sale.view_sales_order_filter"/>
201 | 	    <field name="context">{}</field>
202 | 	    <field name="domain">[('state', 'not in', ('draft', 'sent', 'cancel')),('amazon_process', '=', False)]</field>
203 | 	    <field name="help" type="html">
204 | 	      <p class="oe_view_nocontent_create">
205 | 	      Click to create a quotation that can be converted into a sales
206 | 	      order.
207 | 	      </p><p>
208 | 	      Odoo will help you efficiently handle the complete sales flow:
209 | 	      quotation, sales order, delivery, invoicing and payment.
210 | 	      </p>
211 | 	    </field>
212 | 	</record>
213 | 
214 |         <menuitem id="menu_action_canceled_orders"
215 |                 action="action_canceled_orders" parent="base.menu_sales"
216 | 	sequence="6"/>
217 | 
218 |     </data>
219 | </openerp>
220 | 
221 | 


--------------------------------------------------------------------------------
/models/mage.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from openerp.tools.translate import _
  3 | from pprint import pprint as pp
  4 | 
  5 | 
  6 | class MageSetup(osv.osv):
  7 |     _name = 'mage.setup'
  8 |     _columns = {
  9 | 	'last_inventory_sync_date': fields.datetime('Last Inventory Sync Time'),
 10 | 	'sync_policy': fields.selection([('all', 'Sync All'), ('changed', 'Sync What Changed')], 'Sync Policy'),
 11 | 	'include_boms': fields.boolean('Include BOM in inventory sync', help="This will calculate build quantity"),
 12 | 	'name': fields.char('Name', required=True),
 13 | 	'debug_mode': fields.selection([('none', 'None'), ('error', 'Error'), ('debug', 'All')],
 14 | 	string='Debug Mode', help="None: This will not log any messages to Sentry.\n" \
 15 | 		"Error: This will send only error events to Sentry\n" \
 16 | 		"All: This will send every event, success and failure to Sentry"),
 17 | 	'sentry_dsn': fields.char('Sentry DSN', help="Exception Messages wil be sent to the logging server"),
 18 | 	'url': fields.char('URL', required=True),
 19 | 	'integrity_product': fields.many2one('product.product', 'Product Deleted Replacement', help="Select a product to use in the case a product returned on an order has been deleted from Magento"),
 20 | 	'import_images': fields.boolean('Import Images'),
 21 | 	'import_images_method': fields.selection([
 22 | 		('standalone', 'Separately'),
 23 | 		('withproduct', 'With Products')], 'Images Import Method'),
 24 | 	'images_storage': fields.selection([
 25 | 		('database', 'Database'),
 26 | 		('filesystem', 'Filesystem (Not yet supported)')], 'Image Storage Method'),
 27 | 	'username': fields.char('Username', required=True),
 28 | 	'default_fiscal_position': fields.many2one('account.fiscal.position', 'Default Fiscal Position', help="This will assign a fiscal position to all orders"),
 29 | 	'import_disabled_products': fields.boolean('Import Disabled Products'),
 30 | 	'password': fields.char('Password', required=True, help="This is the API Key for Magento"),
 31 | 	'default_shipping_partner': fields.many2one('res.partner', 'Default Shipping Partner', help="This will assign a required partner to any shipping method that is created"),
 32 | 	'shipping_product': fields.many2one('product.product', \
 33 | 		'Shipping Product', domain="[('type', '=', 'service')]", help="Only service products can be used here"),
 34 | 	'picking_policy': fields.selection([
 35 | 		('direct', 'Deliver each product when available'),
 36 | 		('one', 'Deliver all products at once')], 'Shipping Policy'
 37 | 	),
 38 | 	'last_imported_customer': fields.integer('Last Imported Customer', help="When syncing customers, start at a given id"),
 39 | 	'pay_sale_if_paid': fields.boolean('Pay Sale in Odoo if Paid in Magento', help="This wil pay the sale order on a deferred scheduled basis if the order status is paid in Magento.\nThis feature requires the module mage2odoo_sale_automation"),
 40 | 	'use_invoice_date': fields.boolean('Use Invoice Date from Magento'),
 41 | 	'deliver_if_delivered': fields.boolean('Delivery automatic if Delivered in Magento', help="Create and fulfill the sales order automatically if it is fulfilled in Magento.\nThis feature requires the module mage2odoo_sale_automation"),
 42 | 	'use_order_date_as_delivery_date': fields.boolean('Use Order Date as Delivery Date'),
 43 | 	'use_order_date': fields.boolean('Use Order Date from Magento'),
 44 | 	'default_product_tax': fields.many2one('account.tax', 'Default Tax', help="If this box is checked, tax will be applied to all products"),
 45 | 	'nontaxable_tax_class_id': fields.char('Nontaxable Class Id', help="This field can be used to not apply tax even with default tax applied"),
 46 |         'invoice_policy': fields.selection([
 47 |                 ('manual', 'On Demand'),
 48 |                 ('picking', 'On Delivery Order'),
 49 |                 ('prepaid', 'Before Delivery')], 'Invoice Policy'
 50 | 	),
 51 | 	'states_or_statuses': fields.selection([('status', 'Import by Status'), ('state', 'Import by State')],
 52 | 	string='Import by Status or State', required=True),
 53 |         'order_statuses': fields.many2many('mage.mapping.order.state', 'mage_setup_import_status_rel', 'status_id', \
 54 |                 'storeview_id', 'Import Order Statuses'
 55 |         ),
 56 | 
 57 |     }
 58 | 
 59 |     def create(self, cr, uid, vals, context=None):
 60 |         new_id = super(MageSetup, self).create(cr, uid, vals, context)
 61 | 	self.create_mage_jobs(cr, uid, new_id)
 62 | 
 63 |         return new_id
 64 | 
 65 | 
 66 | #    def write(self, cr, uid, ids, vals, context=None):
 67 | #	if isinstance(ids, (int, long)):
 68 | #	    ids = [ids]
 69 | #	res = super(MageSetup, self).write(cr, uid, ids, vals, context=context)
 70 | 
 71 | 
 72 |     def create_mage_jobs(self, cr, uid, mage_id, context=None):
 73 | 	model_obj = self.pool.get('ir.model')
 74 | 	job_obj = self.pool.get('mage.job')
 75 | 	mapping_obj = self.pool.get('mage.mapping')
 76 | 	setup = self.browse(cr, uid, mage_id)
 77 | 	from defaults import *
 78 | 	#This will always be present if the module is installed
 79 | 	integrator_id = model_obj.search(cr, uid, [('model', '=', 'mage.integrator')])[0]
 80 | 
 81 | 	for job_vals in DEFAULT_JOBS:
 82 | 	    job_name = setup.name + ' : ' + job_vals['name']
 83 | 	    job = {'name': job_name,
 84 | 		   'python_model': integrator_id,
 85 | 		   'python_function_name': job_vals['python_function_name'],
 86 | 		   'mage_instance': mage_id,
 87 | 		   'job_type': job_vals['job_type'],
 88 | 	    }
 89 | 
 90 | 	    if job_vals['mapping_name']:
 91 | 		model_ids = model_obj.search(cr, uid, [('model', '=', job_vals['mapping_model_name'])])
 92 | 		if model_ids:
 93 | 	            mapping_vals = {
 94 | 				'name': job_vals['mapping_name'],
 95 | 				'model_id': model_ids[0],
 96 | 		    }
 97 | 		    mapping_id = mapping_obj.create(cr, uid, mapping_vals)
 98 | 		    mapping_lines = self.create_default_mappinglines(cr, uid, job_vals, mapping_id)
 99 | 		    job['mapping'] = mapping_id
100 | 
101 | 	    job_id = job_obj.create(cr, uid, job)
102 | 
103 | 	    if job_vals['scheduler']:
104 | 		job_obj.button_schedule_mage_job(cr, uid, [job_id])
105 | 
106 | 	return True
107 | 
108 | 
109 |     def create_default_mappinglines(self, cr, uid, job_vals, mapping_id):
110 | 	field_obj = self.pool.get('ir.model.fields')
111 | 	line_obj = self.pool.get('mage.mapping.line')
112 | 	for f in job_vals['mapping_lines']:
113 | 		field_ids = field_obj.search(cr, uid, \
114 | 			[('name', '=', f['field_name']), ('model', '=', f['field_model'])])
115 | 		if field_ids:
116 | 		    vals = {
117 | 			'external_type': f['external_type'],
118 | 			'function_name': f['function_name'],
119 | 			'mage_fieldname': f['mage_fieldname'],
120 | 			'mapping_type': f['mapping_type'],
121 | 			'type': f['type'],
122 | 			'field': field_ids[0],
123 | 			'mapping': mapping_id,
124 | 		    }
125 | 		    line = line_obj.create(cr, uid, vals)
126 | 	return True
127 | 
128 | 
129 | class MageWebsite(osv.osv):
130 |     _name = 'mage.website'
131 |     _columns = {
132 | 	'name': fields.char('Name'),
133 | 	'code': fields.char('Code'),
134 | 	'is_default': fields.boolean('Default Website'),
135 | 	'default_store_group': fields.many2one('mage.store.group', 'Default Store Group'),
136 | 	'sort_order': fields.integer('Sort Order'),
137 | 	'external_id': fields.integer('External Id'),
138 | #	'store_groups': fields.one2many('mage.store.group', 'website', 'Stores'),
139 |     }
140 | 
141 | 
142 |     def prepare_odoo_record_vals(self, cr, uid, job, record, context=None):
143 |         return {
144 |             'is_default': record['is_default'],
145 |             'external_id': record['website_id'],
146 |             'code': record['code'],
147 |             'sort_order': record['sort_order'],
148 |             'name': record['name'],
149 |         }
150 | 
151 | 
152 | class MageStoreGroup(osv.osv):
153 |     _name = 'mage.store.group'
154 |     _columns = {
155 |         'name': fields.char('Name'),
156 |         'website': fields.many2one('mage.website', 'Website'),
157 |         'external_id': fields.integer('External Id'),
158 | 	'default_store_view': fields.many2one('mage.store.view', 'Default Store View'),
159 | 	'store_views': fields.one2many('mage.store.view', 'store', 'Store Views'),
160 |     }
161 | 
162 | 
163 |     def prepare_odoo_record_vals(self, cr, uid, job, record, context=None):
164 | 	website_obj = self.pool.get('mage.website')
165 |         return {
166 |                 'website': website_obj.get_mage_record(cr, uid, record['website_id']),
167 |                 'external_id': record['group_id'],
168 |                 'name': record['name'],
169 |         }
170 | 
171 | 
172 | class MageStoreView(osv.osv):
173 |     _name = 'mage.store.view'
174 |     _columns = {
175 |         'name': fields.char('Name'),
176 | 	'manual_order_number': fields.char('Manual Order Number'),
177 | 	'store': fields.many2one('mage.store.group', 'Store Group'),
178 | 	'code': fields.char('Code'),
179 | 	'website': fields.many2one('mage.website', 'Website'),
180 |         'picking_policy': fields.selection([
181 |                 ('direct', 'Deliver each product when available'),
182 |                 ('one', 'Deliver all products at once')], 'Shipping Policy'
183 |         ),
184 |         'invoice_policy': fields.selection([
185 |                 ('manual', 'On Demand'),
186 |                 ('picking', 'On Delivery Order'),
187 |                 ('prepaid', 'Before Delivery')], 'Invoice Policy'
188 |         ),
189 | 	'skip_order_status': fields.boolean('Do not change status on Magento'),
190 | 	'do_not_import': fields.boolean('Do Not Import'),
191 | 	'external_id': fields.integer('External Id'),
192 | 	'sort_order': fields.integer('Sort Order'),
193 | 	'odoo_guest_customer': fields.many2one('res.partner', 'Stealth Checkout Customer'),
194 | 	'import_orders_start_datetime': fields.datetime('Import Orders from This Time'),
195 | 	'import_orders_end_datetime': fields.datetime('Import Orders To This Time'),
196 | 	'warehouse': fields.many2one('stock.warehouse', 'Warehouse'),
197 | 	'fba_warehouse': fields.many2one('stock.warehouse', 'FBA Warehouse'),
198 | 	'last_import_datetime': fields.datetime('Last Imported At'),
199 | 	'last_export_datetime': fields.datetime('Last Exported At'),
200 | 	'order_prefix': fields.char('Order Prefix'),
201 | 	'allow_storeview_level_statuses': fields.boolean('Allow storeview level status configuration'),
202 | 	'order_statuses': fields.many2many('mage.mapping.order.state', 'mage_store_view_import_status_rel', 'status_id', \
203 |                 'storeview_id', 'Import Order Statuses'
204 | 	),
205 |     }
206 | 
207 |     _defaults = {
208 | 	'do_not_export': False,
209 |     }
210 | 
211 | 
212 |     def prepare_odoo_record_vals(self, cr, uid, job, record, context=None):
213 | 	website_obj = self.pool.get('mage.website')
214 | 	group_obj = self.pool.get('mage.store.group')
215 |         return {
216 | 		'website': website_obj.get_mage_record(cr, uid, record['website_id']),
217 |                 'code': record['code'],
218 |                 'name': record['name'],
219 |                 'sort_order': record['sort_order'],
220 |                 'external_id': record['store_id'],
221 |                 'store': group_obj.get_mage_record(cr, uid, record['group_id']),
222 | 
223 |         }
224 | 
225 | 
226 | class MageMappingOrderState(osv.osv):
227 |     _name = 'mage.mapping.order.state'
228 |     _name_get = 'mage_order_status_name'
229 |     _columns = {
230 | 	'name': fields.char('Name'),
231 | 	'mage_order_state': fields.char('Magento Order State'),
232 | 	'mage_order_status': fields.char('Magento Order Status'),
233 | 	'mage_order_status_name': fields.char('Magento Order Status Name'),
234 | 	'odoo_order_state': fields.selection([
235 | 		('draft', 'Draft Quotation'),
236 | 		('sent', 'Quotation Sent'),
237 | 		('cancel', 'Cancelled'),
238 | 		('waiting_date', 'Waiting Schedule'),
239 | 		('progress', 'Sales Order'),
240 | 		('manual', 'Sale to Invoice'),
241 | 		('shipping_except', 'Shipping Exception'),
242 | 		('invoice_except', 'Invoice Exception'),
243 | 		('done', 'Done')], 'Odoo Order Status'
244 | 	),
245 |     }
246 | 


--------------------------------------------------------------------------------
/models/product.py:
--------------------------------------------------------------------------------
  1 | from openerp.osv import osv, fields
  2 | from magento import Product
  3 | from pprint import pprint as pp
  4 | from openerp.tools.translate import _
  5 | import urllib
  6 | import base64
  7 | 
  8 | PRODUCT_TYPES = {
  9 |                 'simple': 'product',
 10 |                 'configurable': 'service',
 11 |                 'bundle': 'service',
 12 |                 'grouped': 'product',
 13 |                 'virtual': 'service',
 14 | }
 15 | 
 16 | 
 17 | class ProductTemplate(osv.osv):
 18 |     _inherit = 'product.template'
 19 |     _columns = {
 20 | 	'msrp': fields.float('MSRP'),
 21 | 	'special_price': fields.float('Special Price'),
 22 | 	'mage_last_sync_date': fields.datetime('Last Mage Sync Date', copy=False),
 23 | 	'sync_stock': fields.boolean('Sync Stock'),
 24 |         'always_in_stock': fields.boolean('Always in Stock'),
 25 |         'manage_stock': fields.boolean('Manage Stock'),
 26 |         'use_config_manage_stock': fields.boolean('Use Config Manage Stock'),
 27 | 	'shipping_product': fields.boolean('Shipping Product', help="Used to create totals like Magento"),
 28 | 	'set': fields.many2one('product.attribute.set', 'Attribute Set'),
 29 | 	'short_description': fields.text('Short Descripton'),
 30 | 	'msrp': fields.float('MSRP'),
 31 | 	'img_path': fields.char('Image Path'),
 32 | 	'url_path': fields.char('URL Path'),
 33 | 	'categories': fields.many2many('product.category', 'mage_product_categories_rel', \
 34 | 		'product_id', 'category_id', 'Categories'
 35 | 	),
 36 | 	'websites': fields.many2many('mage.website', 'mage_product_website_rel', 'product_tmpl_id', \
 37 | 		'website_id', 'Websites'
 38 | 	),
 39 | 	'associated_products': fields.many2many('product.template', 'associated_products_rel', \
 40 | 		'parent_id', 'product_tmpl_id', 'Associated Products', domain="[('mage_type', '!=', 'configurable')]"
 41 | 	),
 42 |         'mage_tax_class': fields.many2one('product.attribute.value', 'Mage Tax Class',
 43 |                 domain="[('attribute_code', '=', 'tax_class_id')]"),
 44 | 	'special_price': fields.float('Special Price'),
 45 | 	'visibility': fields.selection([
 46 | 					('1', 'Not Visible Individually'),
 47 | 					('2', 'Catalog'),
 48 | 					('3', 'Search'),
 49 | 					('4', 'Catalog, Search'),
 50 | 	], 'Visibility'),
 51 |         'mage_status': fields.selection([
 52 |                                        ('1', 'Enabled'),
 53 |                                        ('2', 'Disabled'),
 54 |         ], 'Magento Status'),
 55 |         'mage_type': fields.selection([
 56 |                                        ('simple', 'Simple Product'),
 57 |                                        ('grouped', 'Grouped Product'),
 58 |                                        ('configurable', 'Configurable Product'),
 59 |                                        ('bundle', 'Bundle Product'),
 60 | 				       ('ugiftcert', 'Gift Certificate'),
 61 | 				       ('virtual', 'Virtual'),
 62 |         ], 'Mage Product Type'),
 63 | 	'url_key': fields.char('URL Key'),
 64 | 	'external_id': fields.integer('External Id', select=True, copy=False),
 65 | 	'sync_to_mage': fields.boolean('Magento Sync', copy=False),
 66 |         'super_attributes': fields.many2many('product.attribute',
 67 |                 'product_super_attribute_rel', 'product_tmpl_id', 'attribute_id', 'Super Attributes',
 68 | 		domain="[('scope', '=', '1'), ('is_configurable', '=', True), ('is_user_defined', '=', True), ('frontend_input', '=', 'select')]"),
 69 |     }
 70 | 
 71 |     def get_or_create_odoo_record(self, cr, uid, job, external_id):
 72 | 	#This is not allowed
 73 | 	raise
 74 | 
 75 | 
 76 | class ProductProduct(osv.osv):
 77 |     _inherit = 'product.product'
 78 | 
 79 | 
 80 |     _sql_constraints = [('default_code_uniq', 'unique (default_code)', 'The SKU must be unique!')]
 81 | 
 82 | <<<<<<< HEAD
 83 |     def button_create_product_in_magento(self, cr, uid, ids, context=None):
 84 | 	for product_id in ids:
 85 | 	    self.push_shell_product_to_mage(cr, uid, product_id)
 86 | 
 87 | 	return True
 88 | 
 89 | 
 90 |     def push_shell_product_to_mage(self, cr, uid, product_id, context=None):
 91 | 	job_obj = self.pool.get('mage.job')
 92 | 	product = self.browse(cr, uid, product_id)
 93 | 	vals = {
 94 | 	    'name': product.name,
 95 | 	    'set': product.set.external_id,
 96 | 	    'type': product.mage_type,
 97 | 	}
 98 | 
 99 | 	job_obj.create_one_mage_product(cr, uid, product, vals)
100 | 
101 | 
102 |     def sql_product_search(self, cr, uid, default_code):
103 | 	query = "SELECT id FROM product_product WHERE default_code = '%s'" % default_code
104 | 	cr.execute(query)
105 | 	results = cr.fetchall()
106 | 	product_ids = [res[0] for res in results]
107 | 	return product_ids
108 | 
109 | 
110 |     def get_or_create_special_product_vals(self, cr, uid, item, context=None):
111 | 
112 | #	product_ids = self.search(cr, uid, [('default_code', '=', item['sku'])])
113 | 	product_ids = self.sql_product_search(cr, uid, item['sku'])
114 | 	if product_ids:
115 | 	    return self.browse(cr, uid, product_ids[0])
116 | 
117 | 	else:
118 | 	    vals = {
119 | 		'name': item.get('description') or item['sku'],
120 | 		'default_code': item['sku'],
121 | 		'active': True,
122 | 		'categories': [(5)],
123 | 		'type': 'service',
124 | 	    }
125 | 
126 | 	    product = self.create(cr, uid, vals)
127 | 	    return self.browse(cr, uid, product)
128 | 
129 | 
130 |     def get_or_create_odoo_record(self, cr, uid, job, external_id, item=False, context=None):
131 | 	if external_id and int(external_id) == 0 and item:
132 | 	    return self.get_or_create_special_product_vals(cr, uid, item)
133 | 
134 |         product_id = self.get_mage_record(cr, uid, external_id)
135 | 	if not product_id and item:
136 | 	    product_ids = self.sql_product_search(cr, uid, item['sku'])
137 | 	   # product_ids = self.search(cr, uid, [('default_code', '=', item['sku'])])
138 | 	    if product_ids:
139 | 		product_id = product_ids[0]
140 | 
141 | 	if not product_id:
142 | 	    product_id = self.get_and_create_mage_record(cr, uid, job, 'oo_catalog_product.info', external_id)
143 | 
144 | 	return self.browse(cr, uid, product_id)
145 | 
146 | 
147 |     def apply_taxes(self, cr, uid, job, record, context=None):
148 | 	instance = job.mage_instance
149 | 	if instance.default_product_tax:
150 | 	    product_tax_class = record.get('tax_class_id')
151 | 	    if not product_tax_class:
152 | 		return [(6, 0, [])]
153 | 
154 | 	    if instance.nontaxable_tax_class_id and instance.nontaxable_tax_class_id == str(product_tax_class):
155 | 		return [(6, 0, [])]
156 | 
157 | 	    return [(6, 0, [instance.default_product_tax.id])]
158 | 	else:
159 | 	    return [(6, 0, [])]
160 | 
161 | 
162 |     def prepare_odoo_record_vals(self, cr, uid, job, record, context=None):
163 | 	set_obj = self.pool.get('product.attribute.set')
164 | 	base_url = job.mage_instance.url
165 | 	media_ext = 'media/catalog/product'
166 | 	img_url = base_url + media_ext
167 | 
168 |         image_path = record.get('thumbnail')
169 |         if not image_path:
170 |             image_path = record.get('small_image')
171 | 
172 | 	if image_path:
173 | 	    get_url = img_url + image_path
174 | 	else:
175 | 	    get_url = False
176 | 
177 |         vals = {
178 | 		'active': True,
179 | 		'weight': record.get('weight'),
180 | 		'standard_price': record.get('cost'),
181 | 		'upc': record.get('upc'),
182 | 		'special_price': record.get('special_price'),
183 | 		'msrp': record.get('msrp'),
184 | 		'manufacturer': record.get('manufacturer'),
185 | 		'list_price': record.get('price'),
186 |                 'description': record.get('description', ' '),
187 |                 'mage_status': record['status'],
188 | #                'name': record['name'],
189 |                 'default_code': record['sku'],
190 |                 'mage_type': record['type_id'],
191 |                 'set': set_obj.get_mage_record(cr, uid, record['attribute_set_id']),
192 |                 'super_attributes': [(5)],
193 |                 'websites': [(5)],
194 |                 'external_id': record['entity_id'],
195 |                 'url_key': record.get('url_key', ''),
196 |                 'short_description': record.get('short_description', ''),
197 |                 'categories': [(5)],
198 |                 'type': PRODUCT_TYPES.get(record['type_id']) or 'product',
199 |                 'sync_to_mage': True,
200 |         }
201 | 
202 | 	if record.get('weight') and float(record.get('weight')) > 0:
203 | 	    vals['weight'] = record.get('weight')
204 | 
205 | 	vals['taxes_id'] = self.apply_taxes(cr, uid, job, record)
206 | 
207 |         if record.get('categories'):
208 |            categ_ids = self._find_categories(cr, uid, record['categories'])
209 | 	   #Copy what someone else did, just apply the first category as primary randomly
210 | 	   #To satisfy unpredictable reporting requirement ;)
211 |            if categ_ids:
212 |                vals['categ_id'] = categ_ids[0]
213 | 
214 |            vals['categories'] = [(6, 0, categ_ids)]
215 | 
216 | 
217 |         if record.get('websites'):
218 |             vals['websites'] = self._find_websites(cr, uid, record['websites'])
219 | 
220 |         if record.get('super_attributes'):
221 |             vals['super_attributes'] = self._find_super_attributes(cr, uid, record['super_attributes'])
222 | 
223 |         return vals
224 | 
225 | 
226 |     def _find_categories(self, cr, uid, categories):
227 |         cat_obj = self.pool.get('product.category')
228 |         category_ids = cat_obj.search(cr, uid, [('external_id', 'in', categories)])
229 |         return category_ids
230 | 
231 | 
232 |     def _find_super_attributes(self, cr, uid, super_attributes):
233 |         attribute_obj = self.pool.get('product.attribute')
234 |         attribute_ids = attribute_obj.search(cr, uid, [('external_id', 'in', super_attributes)])
235 |         return [(6, 0, attribute_ids)]
236 | 
237 | 
238 |     def _find_websites(self, cr, uid, websites):
239 |         website_obj = self.pool.get('mage.website')
240 |         website_ids = website_obj.search(cr, uid, [('external_id', 'in', websites)])
241 |         return [(6, 0, website_ids)]
242 | 
243 | 
244 |     def _find_attribute_values(self, cr, uid, external_attribute_ids):
245 |         attribute_obj = self.pool.get('product.attribute.value')
246 | 	external_ids = external_attribute_ids.split(',')
247 |         attribute_ids = attribute_obj.search(cr, uid, [
248 |                 ('external_id', 'in', external_ids)
249 |         ])
250 | 
251 |         return [(6, 0, attribute_ids)]
252 | 
253 | 
254 |     def _find_attribute_value(self, cr, uid, external_attribute_id):
255 |         attribute_obj = self.pool.get('product.attribute.value')
256 | 
257 |         attribute_ids = attribute_obj.search(cr, uid, [
258 |                 ('external_id', '=', external_attribute_id)
259 |         ])
260 | 
261 |         if attribute_ids:
262 |             return attribute_ids[0]
263 | 
264 |         return False
265 | 
266 | 
267 |     def upsert_mage_record(self, cr, uid, vals, record_id=False):
268 |         if record_id:
269 |             self.write(cr, uid, record_id, vals)
270 |             return record_id
271 | 
272 |         existing_id = self.get_mage_record(cr, uid, vals['external_id'])
273 |         if not existing_id and vals.get('default_code'):
274 | 	    existing_id = self.sql_product_search(cr, uid, vals['default_code'])
275 | #	    existing_id = self.search(cr, uid, [('default_code', '=', vals['default_code'])])
276 |         if existing_id:
277 |             self.write(cr, uid, existing_id, vals)
278 |             return existing_id
279 | 
280 |         else:
281 |             return self.create(cr, uid, vals)
282 | 
283 | 
284 |     def sync_one_image(self, cr, uid, job, product_id, record, img_url):
285 | 	image_path = record.get('thumbnail')
286 | 	if not image_path:
287 | 	    image_path = record.get('small_image')
288 | 
289 | 	if not image_path or image_path == 'no_selection':
290 | 	    return True
291 | 
292 | 	get_url = img_url + image_path
293 | 	(filename, header) = urllib.urlretrieve(get_url)
294 | 	with open(filename, 'rb') as f:
295 | 	    img = base64.b64encode(f.read())
296 | 	    self.write(cr, uid, product_id, {'image': img, 'img_path': get_url})
297 | 
298 | 	return True	
299 | 


--------------------------------------------------------------------------------