From 97fcb936623d0c6a7a538e8868d32f818236428d Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Wed, 9 May 2018 09:27:45 -0700
Subject: [PATCH 01/21] Initial commit of `sale_planner` for 11.0

---
 sale_planner/__init__.py                    |   2 +
 sale_planner/__manifest__.py                |  40 ++
 sale_planner/models/__init__.py             |   3 +
 sale_planner/models/delivery.py             |  69 +++
 sale_planner/models/sale.py                 |  16 +
 sale_planner/models/stock.py                |   9 +
 sale_planner/tests/__init__.py              |   1 +
 sale_planner/tests/test_planner.py          | 204 +++++++
 sale_planner/views/delivery.xml             |  13 +
 sale_planner/views/sale.xml                 |  17 +
 sale_planner/views/stock.xml                |  13 +
 sale_planner/wizard/__init__.py             |   1 +
 sale_planner/wizard/order_planner.py        | 590 ++++++++++++++++++++
 sale_planner/wizard/order_planner_views.xml |  40 ++
 14 files changed, 1018 insertions(+)
 create mode 100644 sale_planner/__init__.py
 create mode 100644 sale_planner/__manifest__.py
 create mode 100644 sale_planner/models/__init__.py
 create mode 100644 sale_planner/models/delivery.py
 create mode 100644 sale_planner/models/sale.py
 create mode 100644 sale_planner/models/stock.py
 create mode 100644 sale_planner/tests/__init__.py
 create mode 100644 sale_planner/tests/test_planner.py
 create mode 100644 sale_planner/views/delivery.xml
 create mode 100644 sale_planner/views/sale.xml
 create mode 100644 sale_planner/views/stock.xml
 create mode 100644 sale_planner/wizard/__init__.py
 create mode 100644 sale_planner/wizard/order_planner.py
 create mode 100644 sale_planner/wizard/order_planner_views.xml

diff --git a/sale_planner/__init__.py b/sale_planner/__init__.py
new file mode 100644
index 00000000..134df274
--- /dev/null
+++ b/sale_planner/__init__.py
@@ -0,0 +1,2 @@
+from . import wizard
+from . import models
diff --git a/sale_planner/__manifest__.py b/sale_planner/__manifest__.py
new file mode 100644
index 00000000..a6bddc5c
--- /dev/null
+++ b/sale_planner/__manifest__.py
@@ -0,0 +1,40 @@
+{
+    'name': 'Sale Order Planner',
+    'summary': 'Plans order dates and warehouses.',
+    'version': '11.0.1.0.0',
+    'author': "Hibou Corp.",
+    'category': 'Sale',
+    'license': 'AGPL-3',
+    'complexity': 'expert',
+    'images': [],
+    'website': "https://hibou.io",
+    'description': """
+Sale Order Planner
+==================
+
+Plans sales order dates based on available warehouses and shipping methods.
+
+Adds shipping calendar to warehouse to plan delivery orders based on availability 
+of the warehouse or warehouse staff.
+
+Adds shipping calendar to individual shipping methods to estimate delivery based 
+on the specific method's characteristics. (e.g. Do they deliver on Saturday?)
+
+
+""",
+    'depends': [
+        'sale_order_dates',
+        'sale_sourced_by_line',
+        'base_geolocalize',
+        'delivery',
+    ],
+    'demo': [],
+    'data': [
+        'wizard/order_planner_views.xml',
+        'views/sale.xml',
+        'views/stock.xml',
+        'views/delivery.xml',
+    ],
+    'auto_install': False,
+    'installable': True,
+}
diff --git a/sale_planner/models/__init__.py b/sale_planner/models/__init__.py
new file mode 100644
index 00000000..35dedabf
--- /dev/null
+++ b/sale_planner/models/__init__.py
@@ -0,0 +1,3 @@
+from . import sale
+from . import stock
+from . import delivery
diff --git a/sale_planner/models/delivery.py b/sale_planner/models/delivery.py
new file mode 100644
index 00000000..b46cebcb
--- /dev/null
+++ b/sale_planner/models/delivery.py
@@ -0,0 +1,69 @@
+from datetime import timedelta
+
+from odoo import api, fields, models
+
+
+class DeliveryCarrier(models.Model):
+    _inherit = 'delivery.carrier'
+
+    delivery_calendar_id = fields.Many2one(
+        'resource.calendar', 'Delivery Calendar',
+        help="This calendar represents days that the carrier will deliver the package.")
+
+    # -------------------------- #
+    # API for external providers #
+    # -------------------------- #
+
+    def get_shipping_price_for_plan(self, orders, date_planned):
+        ''' For every sale order, compute the price of the shipment
+
+        :param orders: A recordset of sale orders
+        :param date_planned: Date to say that the shipment is leaving.
+        :return list: A list of floats, containing the estimated price for the shipping of the sale order
+        '''
+        self.ensure_one()
+        if hasattr(self, '%s_get_shipping_price_for_plan' % self.delivery_type):
+            return getattr(self, '%s_get_shipping_price_for_plan' % self.delivery_type)(orders, date_planned)
+
+    def calculate_transit_days(self, date_planned, date_delivered):
+        self.ensure_one()
+        if isinstance(date_planned, str):
+            date_planned = fields.Datetime.from_string(date_planned)
+        if isinstance(date_delivered, str):
+            date_delivered = fields.Datetime.from_string(date_delivered)
+
+        transit_days = 0
+        while date_planned < date_delivered:
+            if transit_days > 10:
+                break
+            interval = self.delivery_calendar_id.schedule_days(1, date_planned, compute_leaves=True)
+
+            if not interval:
+                return self._calculate_transit_days_naive(date_planned, date_delivered)
+            date_planned = interval[0][1]
+            transit_days += 1
+
+        if transit_days > 1:
+            transit_days -= 1
+
+        return transit_days
+
+    def _calculate_transit_days_naive(self, date_planned, date_delivered):
+        return abs((date_delivered - date_planned).days)
+
+    def calculate_date_delivered(self, date_planned, transit_days):
+        self.ensure_one()
+        if isinstance(date_planned, str):
+            date_planned = fields.Datetime.from_string(date_planned)
+
+        # date calculations needs an extra day
+        effective_transit_days = transit_days + 1
+
+        interval = self.delivery_calendar_id.schedule_days(effective_transit_days, date_planned, compute_leaves=True)
+        if not interval:
+            return self._calculate_date_delivered_naive(date_planned, transit_days)
+
+        return fields.Datetime.to_string(interval[-1][1])
+
+    def _calculate_date_delivered_naive(self, date_planned, transit_days):
+        return fields.Datetime.to_string(date_planned + timedelta(days=transit_days))
diff --git a/sale_planner/models/sale.py b/sale_planner/models/sale.py
new file mode 100644
index 00000000..6d5e46b0
--- /dev/null
+++ b/sale_planner/models/sale.py
@@ -0,0 +1,16 @@
+from odoo import api, fields, models
+
+
+class SaleOrder(models.Model):
+    _inherit = 'sale.order'
+
+    @api.multi
+    def action_planorder(self):
+        plan_obj = self.env['sale.order.make.plan']
+        for order in self:
+            plan = plan_obj.create({
+                'order_id': order.id,
+            })
+            action = self.env.ref('sale_planner.action_plan_sale_order').read()[0]
+            action['res_id'] = plan.id
+            return action
diff --git a/sale_planner/models/stock.py b/sale_planner/models/stock.py
new file mode 100644
index 00000000..4d72f4f4
--- /dev/null
+++ b/sale_planner/models/stock.py
@@ -0,0 +1,9 @@
+from odoo import api, fields, models
+
+
+class Warehouse(models.Model):
+    _inherit = 'stock.warehouse'
+
+    shipping_calendar_id = fields.Many2one(
+        'resource.calendar', 'Shipping Calendar',
+        help="This calendar represents shipping availability from the warehouse.")
diff --git a/sale_planner/tests/__init__.py b/sale_planner/tests/__init__.py
new file mode 100644
index 00000000..25366b57
--- /dev/null
+++ b/sale_planner/tests/__init__.py
@@ -0,0 +1 @@
+from . import test_planner
diff --git a/sale_planner/tests/test_planner.py b/sale_planner/tests/test_planner.py
new file mode 100644
index 00000000..b2d3bd61
--- /dev/null
+++ b/sale_planner/tests/test_planner.py
@@ -0,0 +1,204 @@
+from odoo.tests import common
+from datetime import datetime, timedelta
+
+
+class TestPlanner(common.TransactionCase):
+    # @todo Test date planning!
+
+    def setUp(self):
+        super(TestPlanner, self).setUp()
+        self.today = datetime.today()
+        self.tomorrow = datetime.today() + timedelta(days=1)
+        # This partner has a parent
+        self.country_usa = self.env['res.country'].search([('name', '=', 'United States')], limit=1)
+        self.state_wa = self.env['res.country.state'].search([('name', '=', 'Washington')], limit=1)
+        self.state_co = self.env['res.country.state'].search([('name', '=', 'Colorado')], limit=1)
+        self.partner_wa = self.env['res.partner'].create({
+            'name': 'Jared',
+            'street': '1234 Test Street',
+            'city': 'Marysville',
+            'state_id': self.state_wa.id,
+            'zip': '98270',
+            'country_id': self.country_usa.id,
+            'partner_latitude': 48.05636,
+            'partner_longitude': -122.14922,
+        })
+        self.warehouse_partner_1 = self.env['res.partner'].create({
+            'name': 'WH1',
+            'street': '1234 Test Street',
+            'city': 'Lynnwood',
+            'state_id': self.state_wa.id,
+            'zip': '98036',
+            'country_id': self.country_usa.id,
+            'partner_latitude': 47.82093,
+            'partner_longitude': -122.31513,
+        })
+
+        self.warehouse_partner_2 = self.env['res.partner'].create({
+            'name': 'WH2',
+            'street': '1234 Test Street',
+            'city': 'Craig',
+            'state_id': self.state_co.id,
+            'zip': '81625',
+            'country_id': self.country_usa.id,
+            'partner_latitude': 40.51525,
+            'partner_longitude': -107.54645,
+        })
+        self.warehouse_calendar_1 = self.env['resource.calendar'].create({
+            'name': 'Washington Warehouse Hours',
+            'attendance_ids': [
+                (0, 0, {'name': 'today',
+                        'dayofweek': str(self.today.weekday()),
+                        'hour_from': (self.today.hour - 1) % 24,
+                        'hour_to': (self.today.hour + 1) % 24}),
+                (0, 0, {'name': 'tomorrow',
+                        'dayofweek': str(self.tomorrow.weekday()),
+                        'hour_from': (self.tomorrow.hour - 1) % 24,
+                        'hour_to': (self.tomorrow.hour + 1) % 24}),
+            ]
+        })
+        self.warehouse_calendar_2 = self.env['resource.calendar'].create({
+            'name': 'Colorado Warehouse Hours',
+            'attendance_ids': [
+                (0, 0, {'name': 'tomorrow',
+                        'dayofweek': str(self.tomorrow.weekday()),
+                        'hour_from': (self.tomorrow.hour - 1) % 24,
+                        'hour_to': (self.tomorrow.hour + 1) % 24}),
+            ]
+        })
+        self.warehouse_1 = self.env['stock.warehouse'].create({
+            'name': 'Washington Warehouse',
+            'partner_id': self.warehouse_partner_1.id,
+            'code': 'WH1',
+            'shipping_calendar_id': self.warehouse_calendar_1.id,
+        })
+        self.warehouse_2 = self.env['stock.warehouse'].create({
+            'name': 'Colorado Warehouse',
+            'partner_id': self.warehouse_partner_2.id,
+            'code': 'WH2',
+            'shipping_calendar_id': self.warehouse_calendar_2.id,
+        })
+        self.so = self.env['sale.order'].create({
+            'partner_id': self.partner_wa.id,
+            'warehouse_id': self.warehouse_1.id,
+        })
+        self.product_1 = self.env['product.template'].create({
+            'name': 'Product for WH1',
+            'type': 'product',
+            'standard_price': 1.0,
+        })
+        self.product_1 = self.product_1.product_variant_id
+        self.product_2 = self.env['product.template'].create({
+            'name': 'Product for WH2',
+            'type': 'product',
+            'standard_price': 1.0,
+        })
+        self.product_2 = self.product_2.product_variant_id
+        self.product_both = self.env['product.template'].create({
+            'name': 'Product for Both',
+            'type': 'product',
+            'standard_price': 1.0,
+        })
+        self.product_both = self.product_both.product_variant_id
+        self.env['stock.change.product.qty'].create({
+            'location_id': self.warehouse_1.lot_stock_id.id,
+            'product_id': self.product_1.id,
+            'new_quantity': 100,
+        }).change_product_qty()
+        self.env['stock.change.product.qty'].create({
+            'location_id': self.warehouse_1.lot_stock_id.id,
+            'product_id': self.product_both.id,
+            'new_quantity': 100,
+        }).change_product_qty()
+        self.env['stock.change.product.qty'].create({
+            'location_id': self.warehouse_2.lot_stock_id.id,
+            'product_id': self.product_2.id,
+            'new_quantity': 100,
+        }).change_product_qty()
+        self.env['stock.change.product.qty'].create({
+            'location_id': self.warehouse_2.lot_stock_id.id,
+            'product_id': self.product_both.id,
+            'new_quantity': 100,
+        }).change_product_qty()
+
+    def both_wh_ids(self):
+        return [self.warehouse_1.id, self.warehouse_2.id]
+
+    def test_planner_creation_internals(self):
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_1.id,
+            'name': 'demo',
+        })
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)], skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertEqual(set(both_wh_ids), set(planner.get_warehouses().ids))
+        fake_order = planner._fake_order(self.so)
+        base_option = planner.generate_base_option(fake_order)
+        self.assertTrue(base_option, 'Must have base option.')
+        self.assertEqual(self.warehouse_1.id, base_option['warehouse_id'])
+
+    def test_planner_creation(self):
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_1.id,
+            'name': 'demo',
+        })
+        self.assertEqual(self.product_1.with_context(warehouse=self.warehouse_1.id).qty_available, 100)
+        self.assertEqual(self.product_1.with_context(warehouse=self.warehouse_2.id).qty_available, 0)
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)], skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_1)
+        self.assertFalse(planner.planning_option_ids[0].sub_options)
+
+    def test_planner_creation_2(self):
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_2.id,
+            'name': 'demo',
+        })
+        self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_1.id).qty_available, 0)
+        self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_2.id).qty_available, 100)
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)], skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
+        self.assertFalse(planner.planning_option_ids[0].sub_options)
+
+    def test_planner_creation_split(self):
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_1.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_2.id,
+            'name': 'demo',
+        })
+        self.assertEqual(self.product_1.with_context(warehouse=self.warehouse_1.id).qty_available, 100)
+        self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_2.id).qty_available, 100)
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)], skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertTrue(planner.planning_option_ids[0].sub_options)
+
+    def test_planner_creation_no_split(self):
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_both.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_2.id,
+            'name': 'demo',
+        })
+        self.assertEqual(self.product_both.with_context(warehouse=self.warehouse_2.id).qty_available, 100)
+        self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_2.id).qty_available, 100)
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)], skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
+        self.assertFalse(planner.planning_option_ids[0].sub_options)
diff --git a/sale_planner/views/delivery.xml b/sale_planner/views/delivery.xml
new file mode 100644
index 00000000..16e36513
--- /dev/null
+++ b/sale_planner/views/delivery.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+    <record id="view_delivery_carrier_form_calendar" model="ir.ui.view">
+        <field name="name">delivery.carrier.form.calendar</field>
+        <field name="model">delivery.carrier</field>
+        <field name="inherit_id" ref="delivery.view_delivery_carrier_form" />
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='integration_level']" position="after">
+                <field name="delivery_calendar_id" />
+            </xpath>
+        </field>
+    </record>
+</odoo>
\ No newline at end of file
diff --git a/sale_planner/views/sale.xml b/sale_planner/views/sale.xml
new file mode 100644
index 00000000..aec860a2
--- /dev/null
+++ b/sale_planner/views/sale.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+    <record id="view_order_form_planner" model="ir.ui.view">
+        <field name="name">sale.order.form.planner</field>
+        <field name="model">sale.order</field>
+        <field name="inherit_id" ref="sale.view_order_form" />
+        <field name="arch" type="xml">
+            <xpath expr="//header/button[@name='action_confirm']" position="before">
+                <button name="action_planorder"
+                        type="object"
+                        attrs="{'invisible': [('state', 'not in', ('draft'))]}"
+                        string="Plan"
+                        class="oe_highlight"/>
+            </xpath>
+        </field>
+    </record>
+</odoo>
\ No newline at end of file
diff --git a/sale_planner/views/stock.xml b/sale_planner/views/stock.xml
new file mode 100644
index 00000000..d0195d86
--- /dev/null
+++ b/sale_planner/views/stock.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+    <record id="view_warehouse_shipping_calendar" model="ir.ui.view">
+        <field name="name">stock.warehouse.shipping.calendar</field>
+        <field name="model">stock.warehouse</field>
+        <field name="inherit_id" ref="stock.view_warehouse" />
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='partner_id']" position="after">
+                <field name="shipping_calendar_id" />
+            </xpath>
+        </field>
+    </record>
+</odoo>
\ No newline at end of file
diff --git a/sale_planner/wizard/__init__.py b/sale_planner/wizard/__init__.py
new file mode 100644
index 00000000..235b12a8
--- /dev/null
+++ b/sale_planner/wizard/__init__.py
@@ -0,0 +1 @@
+from . import order_planner
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
new file mode 100644
index 00000000..dd48dd78
--- /dev/null
+++ b/sale_planner/wizard/order_planner.py
@@ -0,0 +1,590 @@
+from math import sin, cos, sqrt, atan2, radians
+from json import dumps, loads
+from copy import deepcopy
+from datetime import datetime
+from logging import getLogger
+
+_logger = getLogger(__name__)
+
+try:
+    from uszipcode import ZipcodeSearchEngine
+except ImportError:
+    _logger.warn('module "uszipcode" cannot be loaded, falling back to Google API')
+    ZipcodeSearchEngine = None
+
+from odoo import api, fields, models, tools
+from odoo.addons.base_geolocalize.models.res_partner import geo_find, geo_query_address
+
+
+class FakeCollection():
+    def __init__(self, vals):
+        self.vals = vals
+
+    def __iter__(self):
+        for v in self.vals:
+            yield v
+
+    def filtered(self, f):
+        return filter(f, self.vals)
+
+
+class FakePartner():
+    def __init__(self, **kwargs):
+        """
+        'delivery.carrier'.verify_carrier(contact) ->
+            country_id,
+            state_id,
+            zip
+            company
+
+        city,
+
+        `distance calculations` ->
+            date_localization,
+            partner_latitude,
+            partner_longitude
+
+            computes them when accessed
+        """
+        self.partner_latitude = 0.0
+        self.partner_longitude = 0.0
+        self.is_company = False
+        for attr, value in kwargs.items():
+            _logger.warn('  ' + str(attr) + ': ' + str(value))
+            setattr(self, attr, value)
+
+    @property
+    def date_localization(self):
+        if not hasattr(self, 'date_localization'):
+            self.date_localization = 'TODAY!'
+            # The fast way.
+            if ZipcodeSearchEngine and self.zip:
+                with ZipcodeSearchEngine() as search:
+                    zipcode = search.by_zipcode(self.zip)
+                    if zipcode:
+                        self.partner_latitude = zipcode['Latitude']
+                        self.partner_longitude = zipcode['Longitude']
+                        return self.date_localization
+
+            # The slow way.
+            result = geo_find(geo_query_address(
+                city=self.city,
+                state=self.state_id.name,
+                country=self.country_id.name,
+            ))
+            if result:
+                self.partner_latitude = result[0]
+                self.partner_longitude = result[1]
+
+        return self.date_localization
+
+
+class FakeOrderLine():
+    def __init__(self, **kwargs):
+        """
+        'delivery.carrier'.get_price_available(order) ->
+            state,
+            is_delivery,
+            product_uom._compute_quantity,
+            product_uom_qty,
+            product_id
+            price_total
+
+
+        """
+        self.state = 'draft'
+        self.is_delivery = False
+        self.product_uom = self
+
+        for attr, value in kwargs.items():
+            setattr(self, attr, value)
+
+    def _compute_quantity(self, qty=1, uom=None):
+        """
+        This is a non-implementation for when someone wants to call product_uom._compute_quantity
+        :param qty:
+        :param uom:
+        :return:
+        """
+        return qty
+
+
+class FakeSaleOrder():
+    """
+    partner_id :: used in shipping
+    partner_shipping_id :: is used in several places
+    order_line :: can be a FakeCollection of FakeOrderLine's or Odoo 'sale.order.line'
+    carrier_id :: can be empty, will be overwritten when walking through carriers
+
+    'delivery.carrier'.get_shipping_price_from_so(orders) ->
+        id, (int)
+        name, (String)
+        currency_id, (Odoo 'res.currency')
+        company_id,  (Odoo 'res.company')
+        warehouse_id, (Odoo 'stock.warehouse')
+        carrier_id, (Odoo 'delivery.carrier')
+
+    SaleOrderMakePlan.generate_shipping_options() ->
+        pricelist_id, (Odoo 'product.pricelist')
+    """
+    def __init__(self, **kwargs):
+        self.carrier_id = None
+        self.id = 0
+        self.name = 'Quote'
+        self.team_id = None
+        self.project_id = None
+        self.amount_total = 0.0
+        for attr, value in kwargs.items():
+            setattr(self, attr, value)
+
+    def __iter__(self):
+        """
+        Emulate a recordset of a single order.
+        """
+        yield self
+
+
+def distance(lat_1, lon_1, lat_2, lon_2):
+    R = 6373.0
+
+    lat1 = radians(lat_1)
+    lon1 = radians(lon_1)
+    lat2 = radians(lat_2)
+    lon2 = radians(lon_2)
+
+    dlon = lon2 - lon1
+    dlat = lat2 - lat1
+
+    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
+    c = 2 * atan2(sqrt(a), sqrt(1 - a))
+
+    return R * c
+
+
+class SaleOrderMakePlan(models.TransientModel):
+    _name = 'sale.order.make.plan'
+    _description = 'Plan Order'
+
+    order_id = fields.Many2one(
+        'sale.order', 'Sale Order',
+    )
+    planning_option_ids = fields.One2many('sale.order.planning.option', 'plan_id', 'Options')
+
+    @api.model
+    def plan_order(self, vals):
+        pass
+
+    @api.multi
+    def select_option(self, option):
+        for plan in self:
+            self.plan_order_option(plan.order_id, option)
+
+    def _order_fields_for_option(self, option):
+        return {
+            'warehouse_id': option.warehouse_id.id,
+            'requested_date': option.requested_date,
+            'date_planned': option.date_planned,
+            'carrier_id': option.carrier_id.id,
+        }
+
+    @api.model
+    def plan_order_option(self, order, option):
+        if option.sub_options:
+            sub_options = option.sub_options
+            if isinstance(sub_options, str):
+                sub_options = loads(sub_options)
+            if not isinstance(sub_options, dict):
+                _logger.warn('Cannot apply option with corrupt sub_options')
+                return False
+            order_lines = order.order_line
+            for wh_id, wh_vals in sub_options.items():
+                wh_id = int(wh_id)
+                if wh_id == option.warehouse_id.id:
+                    continue
+                order_lines.filtered(lambda line: line.product_id.id in wh_vals['product_ids']).write({
+                    'warehouse_id': wh_id,
+                    'date_planned': wh_vals.get('date_planned'),
+                })
+
+        order_fields = self._order_fields_for_option(option)
+
+        order.write(order_fields)
+
+        if option.carrier_id:
+            order._create_delivery_line(option.carrier_id, option.shipping_price)
+
+
+    @api.model
+    def create(self, values):
+        planner = super(SaleOrderMakePlan, self).create(values)
+
+        for option_vals in self.generate_order_options(planner.order_id):
+            option_vals['plan_id'] = planner.id
+            planner.planning_option_ids |= self.env['sale.order.planning.option'].create(option_vals)
+
+        return planner
+
+    def _fake_order(self, order):
+        return FakeSaleOrder(**{
+            'id': order.id,
+            'name': order.name,
+            'partner_id': order.partner_id,
+            'partner_shipping_id': order.partner_shipping_id,
+            'order_line': order.order_line,
+            'currency_id': order.currency_id,
+            'company_id': order.company_id,
+            'warehouse_id': order.warehouse_id,
+            'amount_total': order.amount_total,
+            'pricelist_id': order.pricelist_id,
+            'env': self.env,
+        })
+
+    @api.model
+    def generate_order_options(self, order, plan_shipping=True):
+        fake_order = self._fake_order(order)
+        base_option = self.generate_base_option(fake_order)
+        # do we need shipping?
+        # we need to collect it because we want multi-warehouse shipping amounts.
+        if order.carrier_id:
+            base_option['carrier_id'] = order.carrier_id.id
+
+        if plan_shipping and not self.env.context.get('skip_plan_shipping'):
+            options = self.generate_shipping_options(base_option, fake_order)
+        else:
+            options = [base_option]
+
+        return options
+
+    def get_warehouses(self, warehouse_id=None):
+        warehouse = self.env['stock.warehouse'].sudo()
+        if warehouse_id:
+            return warehouse.search([('id', '=', warehouse_id)])
+
+        if self.env.context.get('warehouse_domain'):
+            #potential bug here if this is textual
+            return warehouse.search(self.env.context.get('warehouse_domain'))
+
+        irconfig_parameter = self.env['ir.config_parameter'].sudo()
+        if irconfig_parameter.get_param('sale.order.planner.warehouse_domain'):
+            domain = tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.warehouse_domain'))
+            return warehouse.search(domain)
+
+        return warehouse.search([])
+
+    def get_shipping_carriers(self, carrier_id=None):
+        Carrier = self.env['delivery.carrier'].sudo()
+        if carrier_id:
+            return Carrier.search([('id', '=', carrier_id)])
+
+        if self.env.context.get('carrier_domain'):
+            # potential bug here if this is textual
+            return Carrier.search(self.env.context.get('carrier_domain'))
+
+        irconfig_parameter = self.env['ir.config_parameter'].sudo()
+        if irconfig_parameter.get_param('sale.order.planner.carrier_domain'):
+            domain = tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.carrier_domain'))
+            return Carrier.search(domain)
+
+        return Carrier.search([])
+
+    def generate_base_option(self, order_fake):
+        product_lines = list(filter(lambda line: line.product_id.type == 'product', order_fake.order_line))
+        if not product_lines:
+            return {}
+
+        buy_qty = {line.product_id.id: line.product_uom_qty for line in product_lines}
+
+        products = self.env['product.product']
+        for line in product_lines:
+            products |= line.product_id
+
+        warehouses = self.get_warehouses()
+        product_stock = self._fetch_product_stock(warehouses, products)
+        sub_options = {}
+        wh_date_planning = {}
+
+        p_len = len(products)
+        full_candidates = set()
+        partial_candidates = set()
+        for wh_id, stock in product_stock.items():
+            available = sum(1 for p_id, p_vals in stock.items() if self._is_in_stock(p_vals, buy_qty[p_id]))
+            if available == p_len:
+                full_candidates.add(wh_id)
+            elif available > 0:
+                partial_candidates.add(wh_id)
+
+        if full_candidates:
+            if len(full_candidates) == 1:
+                warehouse = warehouses.filtered(lambda wh: wh.id in full_candidates)
+                date_planned = self._next_warehouse_shipping_date(warehouse)
+                order_fake.warehouse_id = warehouse
+                return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
+
+            warehouse = self._find_closest_warehouse_by_partner(
+                warehouses.filtered(lambda wh: wh.id in full_candidates), order_fake.partner_shipping_id)
+            date_planned = self._next_warehouse_shipping_date(warehouse)
+            order_fake.warehouse_id = warehouse
+            return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
+
+        if partial_candidates:
+            if len(partial_candidates) == 1:
+                warehouse = warehouses.filtered(lambda wh: wh.id in partial_candidates)
+                order_fake.warehouse_id = warehouse
+                return {'warehouse_id': warehouse.id}
+
+            sorted_warehouses = self._sort_warehouses_by_partner(warehouses.filtered(lambda wh: wh.id in partial_candidates), order_fake.partner_shipping_id)
+            primary_wh = sorted_warehouses[0] #partial_candidates means there is at least one warehouse
+            primary_wh_date_planned = self._next_warehouse_shipping_date(primary_wh)
+            wh_date_planning[primary_wh.id] = primary_wh_date_planned
+            for wh in sorted_warehouses:
+                if not buy_qty:
+                    continue
+                stock = product_stock[wh.id]
+                for p_id, p_vals in stock.items():
+                    if p_id in buy_qty and self._is_in_stock(p_vals, buy_qty[p_id]):
+                        if wh.id not in sub_options:
+                            sub_options[wh.id] = {
+                                'date_planned': self._next_warehouse_shipping_date(wh),
+                                'product_ids': [],
+                                'product_skus': [],
+                            }
+                        sub_options[wh.id]['product_ids'].append(p_id)
+                        sub_options[wh.id]['product_skus'].append(p_vals['sku'])
+                        del buy_qty[p_id]
+
+            if not buy_qty:
+                # item_details can fulfil all items.
+                # this is good!!
+                order_fake.warehouse_id = primary_wh
+                return {'warehouse_id': primary_wh.id, 'date_planned': primary_wh_date_planned, 'sub_options': sub_options}
+
+            # warehouses cannot fulfil all requested items!!
+            order_fake.warehouse_id = primary_wh
+            return {'warehouse_id': primary_wh.id}
+
+        # nobody has stock!
+        primary_wh = self._find_closest_warehouse_by_partner(warehouses, order_fake.partner_shipping_id)
+        order_fake.warehouse_id = primary_wh
+        return {'warehouse_id': primary_wh.id}
+
+    def _is_in_stock(self, p_stock, buy_qty):
+        return p_stock['real_qty_available'] >= buy_qty
+
+    def _find_closest_warehouse_by_partner(self, warehouses, partner):
+        if not partner.date_localization:
+            partner.geo_localize()
+        return self._find_closest_warehouse(warehouses, partner.partner_latitude, partner.partner_longitude)
+
+    def _find_closest_warehouse(self, warehouses, latitude, longitude):
+        distances = {distance(latitude, longitude, wh.partner_id.partner_latitude, wh.partner_id.partner_longitude): wh.id for wh in warehouses}
+        wh_id = distances[min(distances)]
+        return warehouses.filtered(lambda wh: wh.id == wh_id)
+
+    def _sort_warehouses_by_partner(self, warehouses, partner):
+        if not partner.date_localization:
+            partner.geo_localize()
+        return self._sort_warehouses(warehouses, partner.partner_latitude, partner.partner_longitude)
+
+    def _sort_warehouses(self, warehouses, latitude, longitude):
+        distances = {distance(latitude, longitude, wh.partner_id.partner_latitude, wh.partner_id.partner_longitude): wh.id for wh in warehouses}
+        wh_distances = sorted(distances)
+        return [warehouses.filtered(lambda wh: wh.id == distances[d]) for d in wh_distances]
+
+    def _next_warehouse_shipping_date(self, warehouse):
+        return fields.Datetime.to_string(warehouse.shipping_calendar_id.plan_days(0.01,
+                                                                                  fields.Datetime.from_string(fields.Datetime.now()),
+                                                                                  compute_leaves=True))
+
+    @api.model
+    def _fetch_product_stock(self, warehouses, products):
+        output = {}
+        for wh in warehouses:
+            products = products.with_context({'location': wh.lot_stock_id.id})
+            output[wh.id] = {
+                p.id: {
+                    'qty_available': p.qty_available,
+                    'virtual_available': p.virtual_available,
+                    'incoming_qty': p.incoming_qty,
+                    'outgoing_qty': p.outgoing_qty,
+                    'real_qty_available': p.qty_available - p.outgoing_qty,
+                    'sku': p.default_code
+                } for p in products}
+        return output
+
+    def generate_shipping_options(self, base_option, order_fake):
+        # generate a carrier_id, amount, requested_date (promise date)
+        # if base_option['carrier_id'] then that is the only carrier we want to collect rates for.
+        carriers = self.get_shipping_carriers(base_option.get('carrier_id'))
+
+        if not base_option.get('sub_options'):
+            options = []
+            # this locic comes from "delivery.models.sale_order.SaleOrder"
+            for carrier in carriers:
+                option = self._generate_shipping_carrier_option(base_option, order_fake, carrier)
+                if option:
+                    options.append(option)
+
+            return options
+        else:
+            warehouses = self.get_warehouses()
+            original_order_fake_warehouse_id = order_fake.warehouse_id
+            original_order_fake_order_line = order_fake.order_line
+            options = []
+            for carrier in carriers:
+                new_base_option = deepcopy(base_option)
+                has_error = False
+                for wh_id, wh_vals in base_option['sub_options'].items():
+                    if has_error:
+                        continue
+                    order_fake.warehouse_id = warehouses.filtered(lambda wh: wh.id == wh_id)
+                    order_fake.order_line = FakeCollection(filter(lambda line: line.product_id.id in wh_vals['product_ids'], original_order_fake_order_line))
+                    wh_option = self._generate_shipping_carrier_option(wh_vals, order_fake, carrier)
+                    if not wh_option:
+                        has_error = True
+                    else:
+                        new_base_option['sub_options'][wh_id] = wh_option
+
+                if has_error:
+                    continue
+                # now that we've collected, we can roll up some details.
+
+                new_base_option['carrier_id'] = carrier.id
+                new_base_option['shipping_price'] = self._get_shipping_price_for_options(new_base_option['sub_options'])
+                new_base_option['requested_date'] = self._get_max_requested_date(new_base_option['sub_options'])
+                new_base_option['transit_days'] = self._get_max_transit_days(new_base_option['sub_options'])
+                options.append(new_base_option)
+
+            #restore values in case more processing occurs
+            order_fake.warehouse_id = original_order_fake_warehouse_id
+            order_fake.order_line = original_order_fake_order_line
+            if not options:
+                options.append(base_option)
+            return options
+
+    def _get_shipping_price_for_options(self, sub_options):
+        return sum(wh_option.get('shipping_price', 0.0) for wh_option in sub_options.values())
+
+    def _get_max_requested_date(self, sub_options):
+        max_requested_date = None
+        for option in sub_options.values():
+            requested_date = option.get('requested_date')
+            if requested_date and isinstance(requested_date, str):
+                requested_date = fields.Datetime.from_string(requested_date)
+            if requested_date and not max_requested_date:
+                max_requested_date = requested_date
+            elif requested_date:
+                if requested_date > max_requested_date:
+                    max_requested_date = requested_date
+        if max_requested_date:
+            return fields.Datetime.to_string(max_requested_date)
+        return max_requested_date
+
+    def _get_max_transit_days(self, sub_options):
+        return max(wh_option.get('transit_days', 0) for wh_option in sub_options.values())
+
+    def _generate_shipping_carrier_option(self, base_option, order_fake, carrier):
+        # some carriers look at the order carrier_id
+        order_fake.carrier_id = carrier
+
+        # this logic comes from "delivery.models.sale_order.SaleOrder"
+        try:
+            date_delivered = None
+            transit_days = 0
+            if carrier.delivery_type not in ['fixed', 'base_on_rule']:
+                result = carrier.get_shipping_price_for_plan(order_fake, base_option.get('date_planned'))
+                if result:
+                    price_unit, transit_days, date_delivered = result[0]
+                else:
+                    price_unit = carrier.get_shipping_price_from_so(order_fake)[0]
+            else:
+                carrier = carrier.verify_carrier(order_fake.partner_shipping_id)
+                if not carrier:
+                    return None
+                #price_unit = carrier.get_price_available(order)
+                # ^^ ends up calling carrier.get_price_from_picking(order_total, weight, volume, quantity)
+                order_total = order_fake.amount_total
+                weight = sum((line.product_id.weight or 0.0) * line.product_uom_qty for line in order_fake.order_line if line.product_id.type == 'product')
+                volume = sum((line.product_id.volume or 0.0) * line.product_uom_qty for line in order_fake.order_line if line.product_id.type == 'product')
+                quantity = sum((line.product_uom_qty or 0.0) for line in order_fake.order_line if line.product_id.type == 'product')
+                price_unit = carrier.get_price_from_picking(order_total, weight, volume, quantity)
+                if order_fake.company_id.currency_id.id != order_fake.pricelist_id.currency_id.id:
+                    price_unit = order_fake.company_id.currency_id.with_context(date=order_fake.date_order).compute(price_unit, order_fake.pricelist_id.currency_id)
+
+            final_price = float(price_unit) * (1.0 + (float(carrier.margin) / 100.0))
+            option = deepcopy(base_option)
+            option['carrier_id'] = carrier.id
+            option['shipping_price'] = final_price
+            option['requested_date'] = fields.Datetime.to_string(date_delivered) if date_delivered and isinstance(date_delivered, datetime) else date_delivered
+            option['transit_days'] = transit_days
+            return option
+        except Exception as e:
+            # _logger.warn("Exception collecting carrier rates: " + str(e))
+            # _logger.exception(e)
+            pass
+
+        return None
+
+
+
+class SaleOrderPlanningOption(models.TransientModel):
+    _name = 'sale.order.planning.option'
+    _description = 'Order Planning Option'
+
+    def create(self, values):
+        if 'sub_options' in values and not isinstance(values['sub_options'], str):
+            values['sub_options'] = dumps(values['sub_options'])
+        return super(SaleOrderPlanningOption, self).create(values)
+
+    @api.multi
+    def _compute_sub_options_text(self):
+        for option in self:
+            sub_options = option.sub_options
+            if sub_options and not isinstance(sub_options, dict):
+                sub_options = loads(sub_options)
+            if not isinstance(sub_options, dict):
+                option.sub_options_text = ''
+                continue
+
+            line = ''
+            for wh_id, wh_option in sub_options.items():
+                product_skus = wh_option.get('product_skus', [])
+                product_skus = ', '.join(product_skus)
+                requested_date = wh_option.get('requested_date', '')
+                if requested_date:
+                    requested_date = self._context_datetime(requested_date)
+                date_planned = wh_option.get('date_planned', '')
+                if date_planned:
+                    date_planned = self._context_datetime(date_planned)
+                shipping_price = float(wh_option.get('shipping_price', 0.0))
+                transit_days = int(wh_option.get('transit_days', 0))
+
+                line += """WH %d :: %s
+  Date Planned:   %s
+  Requested Date: %s
+  Transit Days:   %d
+  Shipping Price: %.2f
+
+""" % (int(wh_id), product_skus, date_planned, requested_date, transit_days, shipping_price)
+
+            option.sub_options_text = line
+
+    plan_id = fields.Many2one('sale.order.make.plan', 'Plan', ondelete='cascade')
+    warehouse_id = fields.Many2one('stock.warehouse', string='Warehouse')
+    date_planned = fields.Datetime('Planned Date')
+    requested_date = fields.Datetime('Requested Date')
+    carrier_id = fields.Many2one('delivery.carrier', string='Carrier')
+    transit_days = fields.Integer('Transit Days')
+    shipping_price = fields.Float('Shipping Price')
+    sub_options = fields.Text('Sub Options JSON')
+    sub_options_text = fields.Text('Sub Options', compute=_compute_sub_options_text)
+
+    @api.multi
+    def select_plan(self):
+        for option in self:
+            option.plan_id.select_option(option)
+            return
+
+    def _context_datetime(self, date):
+        date = fields.Datetime.from_string(date)
+        date = fields.Datetime.context_timestamp(self, date)
+        return fields.Datetime.to_string(date)
diff --git a/sale_planner/wizard/order_planner_views.xml b/sale_planner/wizard/order_planner_views.xml
new file mode 100644
index 00000000..bf30f96d
--- /dev/null
+++ b/sale_planner/wizard/order_planner_views.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+    <record id="view_plan_sale_order" model="ir.ui.view">
+        <field name="name">view.plan.sale.order</field>
+        <field name="model">sale.order.make.plan</field>
+        <field name="type">form</field>
+        <field name="arch" type="xml">
+            <form>
+                <field name="planning_option_ids">
+                    <tree>
+                        <field name="warehouse_id" />
+                        <field name="date_planned" />
+                        <field name="requested_date" />
+                        <field name="transit_days" />
+                        <field name="carrier_id" />
+                        <field name="shipping_price" />
+                        <field name="sub_options_text" />
+                        <button class="eo_highlight"
+                                name="select_plan"
+                                string="Select"
+                                type="object" />
+                    </tree>
+                </field>
+                <footer>
+                    <button class="oe_link"
+                            special="cancel"
+                            string="Cancel" />
+                </footer>
+            </form>
+        </field>
+    </record>
+     <record id="action_plan_sale_order" model="ir.actions.act_window">
+        <field name="name">Plan Sale Order</field>
+        <field name="res_model">sale.order.make.plan</field>
+        <field name="view_type">form</field>
+        <field name="view_mode">form</field>
+        <field name="view_id" ref="view_plan_sale_order" />
+        <field name="target">new</field>
+    </record>
+</odoo>
\ No newline at end of file

From dee8f875fed43cfc29e977d5cd64a9741a0083bd Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Sun, 10 Jun 2018 11:04:30 -0700
Subject: [PATCH 02/21] Add missing requirement for `sale_planner`.

---
 sale_planner/__manifest__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sale_planner/__manifest__.py b/sale_planner/__manifest__.py
index a6bddc5c..75bc2f24 100644
--- a/sale_planner/__manifest__.py
+++ b/sale_planner/__manifest__.py
@@ -27,6 +27,7 @@ on the specific method's characteristics. (e.g. Do they deliver on Saturday?)
         'sale_sourced_by_line',
         'base_geolocalize',
         'delivery',
+        'resource',
     ],
     'demo': [],
     'data': [

From 8bb965c669d5ab662811273a4c8b71edbd995228 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Sat, 7 Jul 2018 12:48:54 -0700
Subject: [PATCH 03/21] Initial ideas of having product level 'Planning Policy'
 for grouping and limiting where items can be planned from and how.

---
 sale_planner/__manifest__.py         |   2 +
 sale_planner/models/__init__.py      |   3 +
 sale_planner/models/delivery.py      |   4 +-
 sale_planner/models/partner.py       |  29 ++
 sale_planner/models/planning.py      |  16 ++
 sale_planner/models/product.py       |  22 ++
 sale_planner/tests/test_planner.py   | 274 ++++++++++++++++++-
 sale_planner/views/product.xml       |  23 ++
 sale_planner/wizard/order_planner.py | 386 +++++++++++++++++++++++----
 9 files changed, 700 insertions(+), 59 deletions(-)
 create mode 100644 sale_planner/models/partner.py
 create mode 100644 sale_planner/models/planning.py
 create mode 100644 sale_planner/models/product.py
 create mode 100644 sale_planner/views/product.xml

diff --git a/sale_planner/__manifest__.py b/sale_planner/__manifest__.py
index 75bc2f24..bdb3d28c 100644
--- a/sale_planner/__manifest__.py
+++ b/sale_planner/__manifest__.py
@@ -28,6 +28,7 @@ on the specific method's characteristics. (e.g. Do they deliver on Saturday?)
         'base_geolocalize',
         'delivery',
         'resource',
+        'stock',
     ],
     'demo': [],
     'data': [
@@ -35,6 +36,7 @@ on the specific method's characteristics. (e.g. Do they deliver on Saturday?)
         'views/sale.xml',
         'views/stock.xml',
         'views/delivery.xml',
+        'views/product.xml',
     ],
     'auto_install': False,
     'installable': True,
diff --git a/sale_planner/models/__init__.py b/sale_planner/models/__init__.py
index 35dedabf..4257587e 100644
--- a/sale_planner/models/__init__.py
+++ b/sale_planner/models/__init__.py
@@ -1,3 +1,6 @@
 from . import sale
 from . import stock
 from . import delivery
+from . import product
+from . import planning
+from . import partner
diff --git a/sale_planner/models/delivery.py b/sale_planner/models/delivery.py
index b46cebcb..47219b76 100644
--- a/sale_planner/models/delivery.py
+++ b/sale_planner/models/delivery.py
@@ -36,7 +36,7 @@ class DeliveryCarrier(models.Model):
         while date_planned < date_delivered:
             if transit_days > 10:
                 break
-            interval = self.delivery_calendar_id.schedule_days(1, date_planned, compute_leaves=True)
+            interval = self.delivery_calendar_id.plan_days(1, date_planned, compute_leaves=True)
 
             if not interval:
                 return self._calculate_transit_days_naive(date_planned, date_delivered)
@@ -59,7 +59,7 @@ class DeliveryCarrier(models.Model):
         # date calculations needs an extra day
         effective_transit_days = transit_days + 1
 
-        interval = self.delivery_calendar_id.schedule_days(effective_transit_days, date_planned, compute_leaves=True)
+        interval = self.delivery_calendar_id.plan_days(effective_transit_days, date_planned, compute_leaves=True)
         if not interval:
             return self._calculate_date_delivered_naive(date_planned, transit_days)
 
diff --git a/sale_planner/models/partner.py b/sale_planner/models/partner.py
new file mode 100644
index 00000000..a0790ce7
--- /dev/null
+++ b/sale_planner/models/partner.py
@@ -0,0 +1,29 @@
+from odoo import api, fields, models
+
+try:
+    from uszipcode import ZipcodeSearchEngine
+except ImportError:
+    ZipcodeSearchEngine = None
+
+
+class Partner(models.Model):
+    _inherit = 'res.partner'
+
+    @api.multi
+    def geo_localize(self):
+        # We need country names in English below
+        for partner in self.with_context(lang='en_US'):
+            if ZipcodeSearchEngine and partner.zip:
+                with ZipcodeSearchEngine() as search:
+                    zipcode = search.by_zipcode(partner.zip)
+                    if zipcode:
+                        partner.write({
+                            'partner_latitude': zipcode['Latitude'],
+                            'partner_longitude': zipcode['Longitude'],
+                            'date_localization': fields.Date.context_today(partner),
+                        })
+                    else:
+                        super(Partner, partner).geo_localize()
+            else:
+                super(Partner, partner).geo_localize()
+        return True
diff --git a/sale_planner/models/planning.py b/sale_planner/models/planning.py
new file mode 100644
index 00000000..47d645af
--- /dev/null
+++ b/sale_planner/models/planning.py
@@ -0,0 +1,16 @@
+from odoo import api, fields, models
+
+
+class PlanningPolicy(models.Model):
+    _name = 'sale.order.planning.policy'
+
+    name = fields.Char(string='Name')
+    carrier_filter_id = fields.Many2one(
+        'ir.filters',
+        string='Delivery Carrier Filter',
+    )
+    warehouse_filter_id = fields.Many2one(
+        'ir.filters',
+        string='Warehouse Filter',
+    )
+    always_closest_warehouse = fields.Boolean(string='Always Plan Closest Warehouse')
diff --git a/sale_planner/models/product.py b/sale_planner/models/product.py
new file mode 100644
index 00000000..8c666a60
--- /dev/null
+++ b/sale_planner/models/product.py
@@ -0,0 +1,22 @@
+from odoo import api, fields, models
+
+
+class ProductTemplate(models.Model):
+    _inherit = 'product.template'
+
+    property_planning_policy_id = fields.Many2one('sale.order.planning.policy', company_dependent=True,
+        string="Order Planner Policy",
+        help="The Order Planner Policy to use when making a sale order planner.")
+
+    @api.multi
+    def get_planning_policy(self):
+        self.ensure_one()
+        return self.property_planning_policy_id or self.categ_id.property_planning_policy_categ_id
+
+
+class ProductCategory(models.Model):
+    _inherit = 'product.category'
+
+    property_planning_policy_categ_id = fields.Many2one('sale.order.planning.policy', company_dependent=True,
+        string="Order Planner Policy",
+        help="The Order Planner Policy to use when making a sale order planner.")
diff --git a/sale_planner/tests/test_planner.py b/sale_planner/tests/test_planner.py
index b2d3bd61..49696bc0 100644
--- a/sale_planner/tests/test_planner.py
+++ b/sale_planner/tests/test_planner.py
@@ -1,5 +1,9 @@
 from odoo.tests import common
 from datetime import datetime, timedelta
+from json import loads as json_decode
+from logging import getLogger
+
+_logger = getLogger(__name__)
 
 
 class TestPlanner(common.TransactionCase):
@@ -69,13 +73,13 @@ class TestPlanner(common.TransactionCase):
         self.warehouse_1 = self.env['stock.warehouse'].create({
             'name': 'Washington Warehouse',
             'partner_id': self.warehouse_partner_1.id,
-            'code': 'WH1',
+            'code': 'TWH1',
             'shipping_calendar_id': self.warehouse_calendar_1.id,
         })
         self.warehouse_2 = self.env['stock.warehouse'].create({
             'name': 'Colorado Warehouse',
             'partner_id': self.warehouse_partner_2.id,
-            'code': 'WH2',
+            'code': 'TWH2',
             'shipping_calendar_id': self.warehouse_calendar_2.id,
         })
         self.so = self.env['sale.order'].create({
@@ -87,13 +91,25 @@ class TestPlanner(common.TransactionCase):
             'type': 'product',
             'standard_price': 1.0,
         })
+        self.product_12 = self.env['product.template'].create({
+            'name': 'Product for WH1 Second',
+            'type': 'product',
+            'standard_price': 1.0,
+        })
         self.product_1 = self.product_1.product_variant_id
+        self.product_12 = self.product_12.product_variant_id
         self.product_2 = self.env['product.template'].create({
             'name': 'Product for WH2',
             'type': 'product',
             'standard_price': 1.0,
         })
+        self.product_22 = self.env['product.template'].create({
+            'name': 'Product for WH2 Second',
+            'type': 'product',
+            'standard_price': 1.0,
+        })
         self.product_2 = self.product_2.product_variant_id
+        self.product_22 = self.product_22.product_variant_id
         self.product_both = self.env['product.template'].create({
             'name': 'Product for Both',
             'type': 'product',
@@ -105,6 +121,11 @@ class TestPlanner(common.TransactionCase):
             'product_id': self.product_1.id,
             'new_quantity': 100,
         }).change_product_qty()
+        self.env['stock.change.product.qty'].create({
+            'location_id': self.warehouse_1.lot_stock_id.id,
+            'product_id': self.product_12.id,
+            'new_quantity': 100,
+        }).change_product_qty()
         self.env['stock.change.product.qty'].create({
             'location_id': self.warehouse_1.lot_stock_id.id,
             'product_id': self.product_both.id,
@@ -115,16 +136,45 @@ class TestPlanner(common.TransactionCase):
             'product_id': self.product_2.id,
             'new_quantity': 100,
         }).change_product_qty()
+        self.env['stock.change.product.qty'].create({
+            'location_id': self.warehouse_2.lot_stock_id.id,
+            'product_id': self.product_22.id,
+            'new_quantity': 100,
+        }).change_product_qty()
         self.env['stock.change.product.qty'].create({
             'location_id': self.warehouse_2.lot_stock_id.id,
             'product_id': self.product_both.id,
             'new_quantity': 100,
         }).change_product_qty()
 
+        self.policy_closest = self.env['sale.order.planning.policy'].create({
+            'always_closest_warehouse': True,
+        })
+        self.policy_other = self.env['sale.order.planning.policy'].create({})
+        self.wh_filter_1 = self.env['ir.filters'].create({
+            'name': 'TWH1 Only',
+            'domain': "[('id', '=', %d)]" % (self.warehouse_1.id, ),
+            'model_id': 'stock.warehouse',
+        })
+        self.wh_filter_2 = self.env['ir.filters'].create({
+            'name': 'TWH2 Only',
+            'domain': "[('id', '=', %d)]" % (self.warehouse_2.id,),
+            'model_id': 'stock.warehouse',
+        })
+        self.policy_wh_1 = self.env['sale.order.planning.policy'].create({
+            'warehouse_filter_id': self.wh_filter_1.id,
+        })
+        self.policy_wh_2 = self.env['sale.order.planning.policy'].create({
+            'warehouse_filter_id': self.wh_filter_2.id,
+        })
+
     def both_wh_ids(self):
         return [self.warehouse_1.id, self.warehouse_2.id]
 
-    def test_planner_creation_internals(self):
+    def test_10_planner_creation_internals(self):
+        """
+        Tests certain internal representations and that we can create a basic plan.
+        """
         self.env['sale.order.line'].create({
             'order_id': self.so.id,
             'product_id': self.product_1.id,
@@ -138,7 +188,11 @@ class TestPlanner(common.TransactionCase):
         self.assertTrue(base_option, 'Must have base option.')
         self.assertEqual(self.warehouse_1.id, base_option['warehouse_id'])
 
-    def test_planner_creation(self):
+    def test_21_planner_creation(self):
+        """
+        Scenario where only one warehouse has inventory on the order line.
+        This is "the closest" warehouse.
+        """
         self.env['sale.order.line'].create({
             'order_id': self.so.id,
             'product_id': self.product_1.id,
@@ -152,7 +206,11 @@ class TestPlanner(common.TransactionCase):
         self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_1)
         self.assertFalse(planner.planning_option_ids[0].sub_options)
 
-    def test_planner_creation_2(self):
+    def test_22_planner_creation(self):
+        """
+        Scenario where only one warehouse has inventory on the order line.
+        This is "the further" warehouse.
+        """
         self.env['sale.order.line'].create({
             'order_id': self.so.id,
             'product_id': self.product_2.id,
@@ -166,7 +224,11 @@ class TestPlanner(common.TransactionCase):
         self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
         self.assertFalse(planner.planning_option_ids[0].sub_options)
 
-    def test_planner_creation_split(self):
+    def test_31_planner_creation_split(self):
+        """
+        Scenario where only one warehouse has inventory on each of the order line.
+        This will cause two pickings to be created, one for each warehouse.
+        """
         self.env['sale.order.line'].create({
             'order_id': self.so.id,
             'product_id': self.product_1.id,
@@ -175,7 +237,7 @@ class TestPlanner(common.TransactionCase):
         self.env['sale.order.line'].create({
             'order_id': self.so.id,
             'product_id': self.product_2.id,
-            'name': 'demo',
+            'name': 'demo2',
         })
         self.assertEqual(self.product_1.with_context(warehouse=self.warehouse_1.id).qty_available, 100)
         self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_2.id).qty_available, 100)
@@ -184,7 +246,12 @@ class TestPlanner(common.TransactionCase):
         self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
         self.assertTrue(planner.planning_option_ids[0].sub_options)
 
-    def test_planner_creation_no_split(self):
+    def test_32_planner_creation_no_split(self):
+        """
+        Scenario where only "the further" warehouse has inventory on whole order, but
+        the "closest" warehouse only has inventory on one item.
+        This will simply plan out of the "the further" warehouse.
+        """
         self.env['sale.order.line'].create({
             'order_id': self.so.id,
             'product_id': self.product_both.id,
@@ -202,3 +269,194 @@ class TestPlanner(common.TransactionCase):
         self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
         self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
         self.assertFalse(planner.planning_option_ids[0].sub_options)
+
+    def test_42_policy_force_closest(self):
+        """
+        Scenario where an item may not be in stock at "the closest" warehouse, but an item is only allowed
+        to come from "the closest" warehouse.
+        """
+        self.product_2.property_planning_policy_id = self.policy_closest
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_both.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_2.id,
+            'name': 'demo',
+        })
+        self.assertEqual(self.product_both.with_context(warehouse=self.warehouse_1.id).qty_available, 100)
+        # Close warehouse doesn't have product.
+        self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_1.id).qty_available, 0)
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)],
+                                                                skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_1)
+        self.assertFalse(planner.planning_option_ids[0].sub_options)
+
+    def test_43_policy_merge(self):
+        """
+        Scenario that will make a complicated scenario specifically:
+        - 3 policy groups
+        - 2 base options with sub_options (all base options with same warehouse)
+        """
+        self.product_both.property_planning_policy_id = self.policy_closest
+        self.product_12.property_planning_policy_id = self.policy_other
+        self.product_22.property_planning_policy_id = self.policy_other
+
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_both.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_1.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_2.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_12.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_22.id,
+            'name': 'demo',
+        })
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)],
+                                                                skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_1)
+        self.assertTrue(planner.planning_option_ids.sub_options)
+
+        sub_options = json_decode(planner.planning_option_ids.sub_options)
+        _logger.error(sub_options)
+        wh_1_ids = sorted([self.product_both.id, self.product_1.id, self.product_12.id])
+        wh_2_ids = sorted([self.product_2.id, self.product_22.id])
+        self.assertEqual(sorted(sub_options[str(self.warehouse_1.id)]['product_ids']), wh_1_ids)
+        self.assertEqual(sorted(sub_options[str(self.warehouse_2.id)]['product_ids']), wh_2_ids)
+
+    def test_44_policy_merge_2(self):
+        """
+        Scenario that will make a complicated scenario specifically:
+        - 3 policy groups
+        - 2 base options from different warehouses
+        """
+        self.product_both.property_planning_policy_id = self.policy_other
+        self.product_12.property_planning_policy_id = self.policy_closest
+        self.product_22.property_planning_policy_id = self.policy_other
+
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_both.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_1.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_2.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_12.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_22.id,
+            'name': 'demo',
+        })
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)],
+                                                                skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
+        self.assertTrue(planner.planning_option_ids.sub_options)
+
+        sub_options = json_decode(planner.planning_option_ids.sub_options)
+        _logger.error(sub_options)
+        wh_1_ids = sorted([self.product_1.id, self.product_12.id])
+        wh_2_ids = sorted([self.product_both.id, self.product_2.id, self.product_22.id])
+        self.assertEqual(sorted(sub_options[str(self.warehouse_1.id)]['product_ids']), wh_1_ids)
+        self.assertEqual(sorted(sub_options[str(self.warehouse_2.id)]['product_ids']), wh_2_ids)
+
+    def test_45_policy_merge_3(self):
+        """
+        Different order of products for test_44
+        - 3 policy groups
+        - 2 base options from different warehouses
+        """
+        self.product_both.property_planning_policy_id = self.policy_other
+        self.product_12.property_planning_policy_id = self.policy_closest
+        self.product_22.property_planning_policy_id = self.policy_other
+
+
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_1.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_2.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_12.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_22.id,
+            'name': 'demo',
+        })
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_both.id,
+            'name': 'demo',
+        })
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)],
+                                                                skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_1)
+        self.assertTrue(planner.planning_option_ids.sub_options)
+
+        sub_options = json_decode(planner.planning_option_ids.sub_options)
+        _logger.error(sub_options)
+        wh_1_ids = sorted([self.product_1.id, self.product_12.id])
+        wh_2_ids = sorted([self.product_both.id, self.product_2.id, self.product_22.id])
+        self.assertEqual(sorted(sub_options[str(self.warehouse_1.id)]['product_ids']), wh_1_ids)
+        self.assertEqual(sorted(sub_options[str(self.warehouse_2.id)]['product_ids']), wh_2_ids)
+
+    def test_51_policy_specific_warehouse(self):
+        """
+        Force one item to TWH2.
+        """
+        self.product_both.property_planning_policy_id = self.policy_wh_2
+
+        self.env['sale.order.line'].create({
+            'order_id': self.so.id,
+            'product_id': self.product_both.id,
+            'name': 'demo',
+        })
+        both_wh_ids = self.both_wh_ids()
+        planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)],
+                                                                skip_plan_shipping=True).create({'order_id': self.so.id})
+        self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
diff --git a/sale_planner/views/product.xml b/sale_planner/views/product.xml
new file mode 100644
index 00000000..aed5aec5
--- /dev/null
+++ b/sale_planner/views/product.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+    <record id="product_template_form_view_inherit" model="ir.ui.view">
+        <field name="name">product.template.common.form.inherit</field>
+        <field name="model">product.template</field>
+        <field name="inherit_id" ref="product.product_template_form_view" />
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='categ_id']" position="after">
+                <field name="property_planning_policy_id"/>
+            </xpath>
+        </field>
+    </record>
+    <record id="product_category_form_view_inherit" model="ir.ui.view">
+        <field name="name">product.category.form.inherit</field>
+        <field name="model">product.category</field>
+        <field name="inherit_id" ref="product.product_category_form_view" />
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='parent_id']" position="after">
+                <field name="property_planning_policy_categ_id"/>
+            </xpath>
+        </field>
+    </record>
+</odoo>
\ No newline at end of file
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index dd48dd78..6d9fe64d 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -2,6 +2,7 @@ from math import sin, cos, sqrt, atan2, radians
 from json import dumps, loads
 from copy import deepcopy
 from datetime import datetime
+from collections import defaultdict
 from logging import getLogger
 
 _logger = getLogger(__name__)
@@ -255,59 +256,70 @@ class SaleOrderMakePlan(models.TransientModel):
 
         return options
 
-    def get_warehouses(self, warehouse_id=None):
+    def get_warehouses(self, warehouse_id=None, domain=None):
         warehouse = self.env['stock.warehouse'].sudo()
         if warehouse_id:
-            return warehouse.search([('id', '=', warehouse_id)])
+            return warehouse.browse(warehouse_id)
+
+        if domain:
+            if not isinstance(domain, (list, tuple)):
+                domain = tools.safe_eval(domain)
+        else:
+            domain = []
 
         if self.env.context.get('warehouse_domain'):
-            #potential bug here if this is textual
-            return warehouse.search(self.env.context.get('warehouse_domain'))
+            domain.extend(self.env.context.get('warehouse_domain'))
 
         irconfig_parameter = self.env['ir.config_parameter'].sudo()
         if irconfig_parameter.get_param('sale.order.planner.warehouse_domain'):
-            domain = tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.warehouse_domain'))
-            return warehouse.search(domain)
+            domain.extend(tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.warehouse_domain')))
 
-        return warehouse.search([])
+        return warehouse.search(domain)
 
-    def get_shipping_carriers(self, carrier_id=None):
+    def get_shipping_carriers(self, carrier_id=None, domain=None):
         Carrier = self.env['delivery.carrier'].sudo()
         if carrier_id:
-            return Carrier.search([('id', '=', carrier_id)])
+            return Carrier.browse(carrier_id)
+
+        if domain:
+            if not isinstance(domain, (list, tuple)):
+                domain = tools.safe_eval(domain)
+        else:
+            domain = []
 
         if self.env.context.get('carrier_domain'):
             # potential bug here if this is textual
-            return Carrier.search(self.env.context.get('carrier_domain'))
+            domain.extend(self.env.context.get('carrier_domain'))
 
         irconfig_parameter = self.env['ir.config_parameter'].sudo()
         if irconfig_parameter.get_param('sale.order.planner.carrier_domain'):
-            domain = tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.carrier_domain'))
-            return Carrier.search(domain)
+            domain.extend(tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.carrier_domain')))
 
-        return Carrier.search([])
+        return Carrier.search(domain)
 
-    def generate_base_option(self, order_fake):
-        product_lines = list(filter(lambda line: line.product_id.type == 'product', order_fake.order_line))
-        if not product_lines:
-            return {}
+    def _generate_base_option(self, order_fake, policy_group):
+        policy = False
+        flag_force_closest = False
+        warehouse_domain = False
+        if 'policy' in policy_group:
+            policy = policy_group['policy']
+            flag_force_closest = policy.always_closest_warehouse
+            warehouse_domain = policy.warehouse_filter_id.domain
+            # Need to look at warehouse filter.
+            # Eventually need to look at shipping filter....
 
-        buy_qty = {line.product_id.id: line.product_uom_qty for line in product_lines}
-
-        products = self.env['product.product']
-        for line in product_lines:
-            products |= line.product_id
-
-        warehouses = self.get_warehouses()
-        product_stock = self._fetch_product_stock(warehouses, products)
+        warehouses = self.get_warehouses(domain=warehouse_domain)
+        if flag_force_closest:
+            warehouses = self._find_closest_warehouse_by_partner(warehouses, order_fake.partner_shipping_id)
+        product_stock = self._fetch_product_stock(warehouses, policy_group['products'])
         sub_options = {}
         wh_date_planning = {}
 
-        p_len = len(products)
+        p_len = len(policy_group['products'])
         full_candidates = set()
         partial_candidates = set()
         for wh_id, stock in product_stock.items():
-            available = sum(1 for p_id, p_vals in stock.items() if self._is_in_stock(p_vals, buy_qty[p_id]))
+            available = sum(1 for p_id, p_vals in stock.items() if self._is_in_stock(p_vals, policy_group['buy_qty'][p_id]))
             if available == p_len:
                 full_candidates.add(wh_id)
             elif available > 0:
@@ -316,32 +328,35 @@ class SaleOrderMakePlan(models.TransientModel):
         if full_candidates:
             if len(full_candidates) == 1:
                 warehouse = warehouses.filtered(lambda wh: wh.id in full_candidates)
-                date_planned = self._next_warehouse_shipping_date(warehouse)
-                order_fake.warehouse_id = warehouse
-                return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
-
-            warehouse = self._find_closest_warehouse_by_partner(
-                warehouses.filtered(lambda wh: wh.id in full_candidates), order_fake.partner_shipping_id)
+            else:
+                warehouse = self._find_closest_warehouse_by_partner(
+                    warehouses.filtered(lambda wh: wh.id in full_candidates), order_fake.partner_shipping_id)
             date_planned = self._next_warehouse_shipping_date(warehouse)
-            order_fake.warehouse_id = warehouse
+            #order_fake.warehouse_id = warehouse
             return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
 
+        _logger.error('      partial_candidates: ' + str(partial_candidates))
         if partial_candidates:
+            _logger.error('      using...')
             if len(partial_candidates) == 1:
                 warehouse = warehouses.filtered(lambda wh: wh.id in partial_candidates)
-                order_fake.warehouse_id = warehouse
+                #order_fake.warehouse_id = warehouse
                 return {'warehouse_id': warehouse.id}
 
-            sorted_warehouses = self._sort_warehouses_by_partner(warehouses.filtered(lambda wh: wh.id in partial_candidates), order_fake.partner_shipping_id)
-            primary_wh = sorted_warehouses[0] #partial_candidates means there is at least one warehouse
+            sorted_warehouses = self._sort_warehouses_by_partner(
+                warehouses.filtered(lambda wh: wh.id in partial_candidates), order_fake.partner_shipping_id)
+            _logger.error('      sorted_warehouses: ' + str(sorted_warehouses) + ' warehouses: ' + str(warehouses))
+            primary_wh = sorted_warehouses[0]  # partial_candidates means there is at least one warehouse
             primary_wh_date_planned = self._next_warehouse_shipping_date(primary_wh)
             wh_date_planning[primary_wh.id] = primary_wh_date_planned
             for wh in sorted_warehouses:
-                if not buy_qty:
+                _logger.error('      wh: ' + str(wh) + ' buy_qty: ' + str(policy_group['buy_qty']))
+                if not policy_group['buy_qty']:
                     continue
                 stock = product_stock[wh.id]
                 for p_id, p_vals in stock.items():
-                    if p_id in buy_qty and self._is_in_stock(p_vals, buy_qty[p_id]):
+                    _logger.error('      p_id: ' + str(p_id) + ' p_vals: ' + str(p_vals))
+                    if p_id in policy_group['buy_qty'] and self._is_in_stock(p_vals, policy_group['buy_qty'][p_id]):
                         if wh.id not in sub_options:
                             sub_options[wh.id] = {
                                 'date_planned': self._next_warehouse_shipping_date(wh),
@@ -350,23 +365,287 @@ class SaleOrderMakePlan(models.TransientModel):
                             }
                         sub_options[wh.id]['product_ids'].append(p_id)
                         sub_options[wh.id]['product_skus'].append(p_vals['sku'])
-                        del buy_qty[p_id]
+                        _logger.error('        removing: ' + str(p_id))
+                        del policy_group['buy_qty'][p_id]
 
-            if not buy_qty:
+            if not policy_group['buy_qty']:
                 # item_details can fulfil all items.
                 # this is good!!
-                order_fake.warehouse_id = primary_wh
-                return {'warehouse_id': primary_wh.id, 'date_planned': primary_wh_date_planned, 'sub_options': sub_options}
+                #order_fake.warehouse_id = primary_wh
+                return {'warehouse_id': primary_wh.id, 'date_planned': primary_wh_date_planned,
+                        'sub_options': sub_options}
 
             # warehouses cannot fulfil all requested items!!
-            order_fake.warehouse_id = primary_wh
+            #order_fake.warehouse_id = primary_wh
             return {'warehouse_id': primary_wh.id}
 
         # nobody has stock!
         primary_wh = self._find_closest_warehouse_by_partner(warehouses, order_fake.partner_shipping_id)
-        order_fake.warehouse_id = primary_wh
+        #order_fake.warehouse_id = primary_wh
         return {'warehouse_id': primary_wh.id}
 
+    def generate_base_option(self, order_fake):
+        _logger.error('generate_base_option:')
+        product_lines = list(filter(lambda line: line.product_id.type == 'product', order_fake.order_line))
+        if not product_lines:
+            return {}
+
+        buy_qty = defaultdict(int)
+        for line in product_lines:
+            buy_qty[line.product_id.id] += line.product_uom_qty
+
+        products = self.env['product.product']
+        for line in product_lines:
+            products |= line.product_id
+
+        policy_groups = defaultdict(lambda: {'products': [], 'buy_qty': {}})
+        for p in products:
+            policy = p.product_tmpl_id.get_planning_policy()
+            if policy:
+                policy_groups[policy.id]['products'].append(p)
+                policy_groups[policy.id]['buy_qty'][p.id] = buy_qty[p.id]
+                policy_groups[policy.id]['policy'] = policy
+            else:
+                policy_groups[0]['products'].append(p)
+                policy_groups[0]['buy_qty'][p.id] = buy_qty[p.id]
+
+
+        for _, policy_group in policy_groups.items():
+            product_set = self.env['product.product'].browse()
+            for p in policy_group['products']:
+                product_set += p
+            policy_group['products'] = product_set
+            policy_group['base_option'] = self._generate_base_option(order_fake, policy_group)
+
+
+        option_policy_groups = defaultdict(lambda: {'products': self.env['product.product'].browse(), 'policies': self.env['sale.order.planning.policy'].browse(), 'date_planned': '1900', 'sub_options': [],})
+        for policy_id, policy_group in policy_groups.items():
+            base_option = policy_group['base_option']
+            _logger.error('  base_option: ' + str(base_option))
+            b_wh_id = base_option['warehouse_id']
+            if 'policy' in policy_group:
+                option_policy_groups[b_wh_id]['policies'] += policy_group['policy']
+            if option_policy_groups[b_wh_id].get('date_planned'):
+                # The first base_option without a date clears it
+                if base_option.get('date_planned'):
+                    if base_option['date_planned'] > option_policy_groups[b_wh_id]['date_planned']:
+                        option_policy_groups[b_wh_id]['date_planned'] = base_option['date_planned']
+                else:
+                    # One of our options has no plan date.  Remove it.
+                    del option_policy_groups[b_wh_id]['date_planned']
+            if 'sub_options' in base_option:
+                option_policy_groups[b_wh_id]['sub_options'].append(base_option['sub_options'])
+            option_policy_groups[b_wh_id]['products'] += policy_group['products']
+            option_policy_groups[b_wh_id]['warehouse_id'] = b_wh_id
+
+        # clean up unused sub_options and collapse used ones
+        for o_wh_id, option_group in option_policy_groups.items():
+            if not option_group['sub_options']:
+                del option_group['sub_options']
+            else:
+                sub_options = defaultdict(lambda: {'date_planned': '1900', 'product_ids': [], 'product_skus': []})
+                remaining_products = option_group['products']
+                for options in option_group['sub_options']:
+                    for wh_id, option in options.items():
+                        if sub_options[wh_id].get('date_planned'):
+                            # The first option without a date clears it
+                            if option.get('date_planned'):
+                                if option['date_planned'] > sub_options[wh_id]['date_planned']:
+                                    sub_options[wh_id]['date_planned'] = option['date_planned']
+                            else:
+                                del sub_options[wh_id]['date_planned']
+                        sub_options[wh_id]['product_ids'] += option['product_ids']
+                        sub_options[wh_id]['product_skus'] += option['product_skus']
+                        remaining_products = remaining_products.filtered(lambda p: p.id not in sub_options[wh_id]['product_ids'])
+                option_group['sub_options'] = sub_options
+                if remaining_products:
+                    option_group['sub_options'][o_wh_id]['product_ids'] += remaining_products.ids
+                    option_group['sub_options'][o_wh_id]['product_skus'] += remaining_products.mapped('default_code')
+
+
+        # At this point we should have all of the policy options collapsed.
+        # Collapse warehouse options.
+        base_option = {'date_planned': '1900', 'products': self.env['product.product'].browse()}
+        for wh_id, intermediate_option in option_policy_groups.items():
+            _logger.error('    base_option: ' + str(base_option))
+            _logger.error('    intermediate_option: ' + str(intermediate_option))
+            if 'warehouse_id' not in base_option:
+                base_option['warehouse_id'] = wh_id
+            b_wh_id = base_option['warehouse_id']
+
+            if base_option.get('date_planned'):
+                if intermediate_option.get('date_planned'):
+                    if intermediate_option['date_planned'] > base_option['date_planned']:
+                        base_option['date_planned'] = intermediate_option['date_planned']
+                else:
+                    del base_option['date_planned']
+                    if 'sub_options' in base_option:
+                        for _, option in base_option['sub_options'].items():
+                            del option['date_planned']
+            if b_wh_id == wh_id:
+                if 'sub_options' in intermediate_option and 'sub_options' not in base_option:
+                    # Base option will get new sub_options
+                    intermediate_option['sub_options'][wh_id]['product_ids'] += base_option['products'].ids
+                    intermediate_option['sub_options'][wh_id]['product_skus'] += base_option['products'].mapped('default_code')
+                    base_option['sub_options'] = intermediate_option['sub_options']
+                elif 'sub_options' in intermediate_option and 'sub_options' in base_option:
+                    # Both have sub_options, merge
+                    for o_wh_id, option in intermediate_option['sub_options'].items():
+                        if o_wh_id not in base_option['sub_options']:
+                            base_option['sub_options'][o_wh_id] = option
+                        else:
+                            base_option['sub_options'][o_wh_id]['product_ids'] += option['product_ids']
+                            base_option['sub_options'][o_wh_id]['product_skus'] += option['product_skus']
+                        if base_option.get('date_planned'):
+                            if option['date_planned'] > base_option['sub_options'][o_wh_id]['date_planned']:
+                                base_option['sub_options'][o_wh_id]['date_planned'] = intermediate_option['date_planned']
+                elif 'sub_options' in base_option:
+                    # merge products from intermediate into base_option's sub_options
+                    base_option['sub_options'][wh_id]['product_ids'] += intermediate_option['products'].ids
+                    base_option['sub_options'][wh_id]['product_skus'] += intermediate_option['products'].mapped('default_code')
+                base_option['products'] += intermediate_option['products']
+            else:
+                # Promote
+                if 'sub_options' not in intermediate_option and 'sub_options' not in base_option:
+                    base_option['sub_options'] = {
+                        wh_id: {
+                            'product_ids': intermediate_option['products'].ids,
+                            'product_skus': intermediate_option['products'].mapped('default_code'),
+                        },
+                        b_wh_id: {
+                            'product_ids': base_option['products'].ids,
+                            'product_skus': base_option['products'].mapped('default_code'),
+                        },
+                    }
+                    if base_option.get('date_planned'):
+                        base_option['sub_options'][wh_id]['date_planned'] = intermediate_option['date_planned']
+                        base_option['sub_options'][b_wh_id]['date_planned'] = base_option['date_planned']
+                elif 'sub_options' in base_option and 'sub_options' not in intermediate_option:
+                    if wh_id not in base_option['sub_options']:
+                        base_option['sub_options'][wh_id] = {
+                            'product_ids': intermediate_option['products'].ids,
+                            'product_skus': intermediate_option['products'].mapped('default_code'),
+                        }
+                        if base_option.get('date_planned'):
+                            base_option['sub_options'][wh_id]['date_planned'] = intermediate_option['date_planned']
+                    else:
+                        base_option['sub_options'][wh_id]['product_ids'] += intermediate_option['products'].ids
+                        base_option['sub_options'][wh_id]['product_skus'] += intermediate_option['products'].mapped('default_code')
+                        if base_option.get('date_planned'):
+                            if intermediate_option['date_planned'] > base_option['sub_options'][wh_id]['date_planned']:
+                                base_option['sub_options'][wh_id]['date_planned'] = intermediate_option['date_planned']
+                elif 'sub_options' in intermediate_option and 'sub_options' in base_option:
+                    # Both have sub_options, merge
+                    for o_wh_id, option in intermediate_option['sub_options'].items():
+                        if o_wh_id not in base_option['sub_options']:
+                            base_option['sub_options'][o_wh_id] = option
+                        else:
+                            base_option['sub_options'][o_wh_id]['product_ids'] += option['product_ids']
+                            base_option['sub_options'][o_wh_id]['product_skus'] += option['product_skus']
+                        if base_option.get('date_planned'):
+                            if option['date_planned'] > base_option['sub_options'][o_wh_id]['date_planned']:
+                                base_option['sub_options'][o_wh_id]['date_planned'] = intermediate_option['date_planned']
+                else:
+                    # intermediate_option has sub_options but base_option doesn't
+                    base_option['sub_options'] = {
+                        b_wh_id: {
+                            'product_ids': base_option['products'].ids,
+                            'product_skus': base_option['products'].mapped('default_code'),
+                        }
+                    }
+                    if base_option.get('date_planned'):
+                        base_option['sub_options'][b_wh_id]['date_planned'] = base_option['date_planned']
+                    for o_wh_id, option in intermediate_option['sub_options'].items():
+                        if o_wh_id not in base_option['sub_options']:
+                            base_option['sub_options'][o_wh_id] = option
+                        else:
+                            base_option['sub_options'][o_wh_id]['product_ids'] += option['product_ids']
+                            base_option['sub_options'][o_wh_id]['product_skus'] += option['product_skus']
+                        if base_option.get('date_planned'):
+                            if option['date_planned'] > base_option['sub_options'][o_wh_id]['date_planned']:
+                                base_option['sub_options'][o_wh_id]['date_planned'] = intermediate_option['date_planned']
+
+        del base_option['products']
+        _logger.error('  returning: ' + str(base_option))
+        order_fake.warehouse_id = self.get_warehouses(warehouse_id=base_option['warehouse_id'])
+        return base_option
+
+
+
+        # Collapse by warehouse_id
+
+
+
+
+        # warehouses = self.get_warehouses()
+        # product_stock = self._fetch_product_stock(warehouses, products)
+        # sub_options = {}
+        # wh_date_planning = {}
+        #
+        # p_len = len(products)
+        # full_candidates = set()
+        # partial_candidates = set()
+        # for wh_id, stock in product_stock.items():
+        #     available = sum(1 for p_id, p_vals in stock.items() if self._is_in_stock(p_vals, buy_qty[p_id]))
+        #     if available == p_len:
+        #         full_candidates.add(wh_id)
+        #     elif available > 0:
+        #         partial_candidates.add(wh_id)
+        #
+        # if full_candidates:
+        #     if len(full_candidates) == 1:
+        #         warehouse = warehouses.filtered(lambda wh: wh.id in full_candidates)
+        #         date_planned = self._next_warehouse_shipping_date(warehouse)
+        #         order_fake.warehouse_id = warehouse
+        #         return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
+        #
+        #     warehouse = self._find_closest_warehouse_by_partner(
+        #         warehouses.filtered(lambda wh: wh.id in full_candidates), order_fake.partner_shipping_id)
+        #     date_planned = self._next_warehouse_shipping_date(warehouse)
+        #     order_fake.warehouse_id = warehouse
+        #     return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
+        #
+        # if partial_candidates:
+        #     if len(partial_candidates) == 1:
+        #         warehouse = warehouses.filtered(lambda wh: wh.id in partial_candidates)
+        #         order_fake.warehouse_id = warehouse
+        #         return {'warehouse_id': warehouse.id}
+        #
+        #     sorted_warehouses = self._sort_warehouses_by_partner(warehouses.filtered(lambda wh: wh.id in partial_candidates), order_fake.partner_shipping_id)
+        #     primary_wh = sorted_warehouses[0] #partial_candidates means there is at least one warehouse
+        #     primary_wh_date_planned = self._next_warehouse_shipping_date(primary_wh)
+        #     wh_date_planning[primary_wh.id] = primary_wh_date_planned
+        #     for wh in sorted_warehouses:
+        #         if not buy_qty:
+        #             continue
+        #         stock = product_stock[wh.id]
+        #         for p_id, p_vals in stock.items():
+        #             if p_id in buy_qty and self._is_in_stock(p_vals, buy_qty[p_id]):
+        #                 if wh.id not in sub_options:
+        #                     sub_options[wh.id] = {
+        #                         'date_planned': self._next_warehouse_shipping_date(wh),
+        #                         'product_ids': [],
+        #                         'product_skus': [],
+        #                     }
+        #                 sub_options[wh.id]['product_ids'].append(p_id)
+        #                 sub_options[wh.id]['product_skus'].append(p_vals['sku'])
+        #                 del buy_qty[p_id]
+        #
+        #     if not buy_qty:
+        #         # item_details can fulfil all items.
+        #         # this is good!!
+        #         order_fake.warehouse_id = primary_wh
+        #         return {'warehouse_id': primary_wh.id, 'date_planned': primary_wh_date_planned, 'sub_options': sub_options}
+        #
+        #     # warehouses cannot fulfil all requested items!!
+        #     order_fake.warehouse_id = primary_wh
+        #     return {'warehouse_id': primary_wh.id}
+        #
+        # # nobody has stock!
+        # primary_wh = self._find_closest_warehouse_by_partner(warehouses, order_fake.partner_shipping_id)
+        # order_fake.warehouse_id = primary_wh
+        # return {'warehouse_id': primary_wh.id}
+
     def _is_in_stock(self, p_stock, buy_qty):
         return p_stock['real_qty_available'] >= buy_qty
 
@@ -391,9 +670,9 @@ class SaleOrderMakePlan(models.TransientModel):
         return [warehouses.filtered(lambda wh: wh.id == distances[d]) for d in wh_distances]
 
     def _next_warehouse_shipping_date(self, warehouse):
-        return fields.Datetime.to_string(warehouse.shipping_calendar_id.plan_days(0.01,
-                                                                                  fields.Datetime.from_string(fields.Datetime.now()),
-                                                                                  compute_leaves=True))
+        if warehouse.shipping_calendar_id:
+            return fields.Datetime.to_string(warehouse.shipping_calendar_id.plan_days(0.01, fields.Datetime.from_string(fields.Datetime.now()), compute_leaves=True))
+        return False
 
     @api.model
     def _fetch_product_stock(self, warehouses, products):
@@ -414,7 +693,16 @@ class SaleOrderMakePlan(models.TransientModel):
     def generate_shipping_options(self, base_option, order_fake):
         # generate a carrier_id, amount, requested_date (promise date)
         # if base_option['carrier_id'] then that is the only carrier we want to collect rates for.
-        carriers = self.get_shipping_carriers(base_option.get('carrier_id'))
+        product_lines = list(filter(lambda line: line.product_id.type == 'product', order_fake.order_line))
+        domain = []
+        for line in product_lines:
+            policy = line.product_id.product_tmpl_id.get_planning_policy()
+            if policy and policy.carrier_filter_id:
+                domain.extend(tools.safe_eval(policy.carrier_filter_id.domain))
+        carriers = self.get_shipping_carriers(base_option.get('carrier_id'), domain=domain)
+
+        if not carriers:
+            return base_option
 
         if not base_option.get('sub_options'):
             options = []

From 15535cef72bd7f7e7bec56d24a57d3d3eb85a8bf Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Mon, 17 Sep 2018 17:25:41 -0700
Subject: [PATCH 04/21] Initial commit of `delivery_hibou` and associated
 refactoring to `sale_planner` and `delivery_stamps` for 11.0

---
 sale_planner/models/delivery.py      |  45 ++++++++--
 sale_planner/tests/test_planner.py   |   2 +-
 sale_planner/wizard/order_planner.py | 118 ++++++++-------------------
 3 files changed, 72 insertions(+), 93 deletions(-)

diff --git a/sale_planner/models/delivery.py b/sale_planner/models/delivery.py
index 47219b76..17a5eb25 100644
--- a/sale_planner/models/delivery.py
+++ b/sale_planner/models/delivery.py
@@ -25,6 +25,36 @@ class DeliveryCarrier(models.Model):
         if hasattr(self, '%s_get_shipping_price_for_plan' % self.delivery_type):
             return getattr(self, '%s_get_shipping_price_for_plan' % self.delivery_type)(orders, date_planned)
 
+    def rate_shipment_date_planned(self, order, date_planned=None):
+        """
+        For every sale order, compute the price of the shipment and potentially when it will arrive.
+        :param order: `sale.order`
+        :param date_planned: The date the shipment is expected to leave/be picked up by carrier.
+        :return: rate in the same form the normal `rate_shipment` method does BUT
+        -- Additional keys
+        - transit_days: int
+        - date_delivered: string
+        """
+        self.ensure_one()
+        if hasattr(self, '%s_rate_shipment_date_planned' % self.delivery_type):
+            # New API Odoo 11 - Carrier specific override.
+            return getattr(self, '%s_rate_shipment_date_planned' % self.delivery_type)(order, date_planned)
+
+        rate = self.with_context(date_planned=date_planned).rate_shipment(order)
+        if rate and date_planned:
+            if rate.get('date_delivered'):
+                date_delivered = rate['date_delivered']
+                transit_days = self.calculate_transit_days(date_planned, date_delivered)
+                if not rate.get('transit_days') or transit_days < rate.get('transit_days'):
+                    rate['transit_days'] = transit_days
+            elif rate.get('transit_days'):
+                rate['date_delivered'] = self.calculate_date_delivered(date_planned, rate.get('transit_days'))
+        elif rate:
+            if rate.get('date_delivered'):
+                rate.pop('date_delivered')
+
+        return rate
+
     def calculate_transit_days(self, date_planned, date_delivered):
         self.ensure_one()
         if isinstance(date_planned, str):
@@ -36,11 +66,14 @@ class DeliveryCarrier(models.Model):
         while date_planned < date_delivered:
             if transit_days > 10:
                 break
-            interval = self.delivery_calendar_id.plan_days(1, date_planned, compute_leaves=True)
 
-            if not interval:
+            current_date_planned = self.delivery_calendar_id.plan_days(1, date_planned, compute_leaves=True)
+            if not current_date_planned:
                 return self._calculate_transit_days_naive(date_planned, date_delivered)
-            date_planned = interval[0][1]
+            if current_date_planned == date_planned:
+                date_planned += timedelta(days=1)
+            else:
+                date_planned = current_date_planned
             transit_days += 1
 
         if transit_days > 1:
@@ -59,11 +92,11 @@ class DeliveryCarrier(models.Model):
         # date calculations needs an extra day
         effective_transit_days = transit_days + 1
 
-        interval = self.delivery_calendar_id.plan_days(effective_transit_days, date_planned, compute_leaves=True)
-        if not interval:
+        last_day = self.delivery_calendar_id.plan_days(effective_transit_days, date_planned, compute_leaves=True)
+        if not last_day:
             return self._calculate_date_delivered_naive(date_planned, transit_days)
 
-        return fields.Datetime.to_string(interval[-1][1])
+        return fields.Datetime.to_string(last_day)
 
     def _calculate_date_delivered_naive(self, date_planned, transit_days):
         return fields.Datetime.to_string(date_planned + timedelta(days=transit_days))
diff --git a/sale_planner/tests/test_planner.py b/sale_planner/tests/test_planner.py
index 49696bc0..35dad49c 100644
--- a/sale_planner/tests/test_planner.py
+++ b/sale_planner/tests/test_planner.py
@@ -384,7 +384,7 @@ class TestPlanner(common.TransactionCase):
         planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)],
                                                                 skip_plan_shipping=True).create({'order_id': self.so.id})
         self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
-        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_1, 'If this fails, it will probably pass next time.')
         self.assertTrue(planner.planning_option_ids.sub_options)
 
         sub_options = json_decode(planner.planning_option_ids.sub_options)
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 6d9fe64d..470f1135 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -51,7 +51,6 @@ class FakePartner():
         self.partner_longitude = 0.0
         self.is_company = False
         for attr, value in kwargs.items():
-            _logger.warn('  ' + str(attr) + ': ' + str(value))
             setattr(self, attr, value)
 
     @property
@@ -220,6 +219,8 @@ class SaleOrderMakePlan(models.TransientModel):
         planner = super(SaleOrderMakePlan, self).create(values)
 
         for option_vals in self.generate_order_options(planner.order_id):
+            if type(option_vals) != dict:
+                continue
             option_vals['plan_id'] = planner.id
             planner.planning_option_ids |= self.env['sale.order.planning.option'].create(option_vals)
 
@@ -570,82 +571,6 @@ class SaleOrderMakePlan(models.TransientModel):
         order_fake.warehouse_id = self.get_warehouses(warehouse_id=base_option['warehouse_id'])
         return base_option
 
-
-
-        # Collapse by warehouse_id
-
-
-
-
-        # warehouses = self.get_warehouses()
-        # product_stock = self._fetch_product_stock(warehouses, products)
-        # sub_options = {}
-        # wh_date_planning = {}
-        #
-        # p_len = len(products)
-        # full_candidates = set()
-        # partial_candidates = set()
-        # for wh_id, stock in product_stock.items():
-        #     available = sum(1 for p_id, p_vals in stock.items() if self._is_in_stock(p_vals, buy_qty[p_id]))
-        #     if available == p_len:
-        #         full_candidates.add(wh_id)
-        #     elif available > 0:
-        #         partial_candidates.add(wh_id)
-        #
-        # if full_candidates:
-        #     if len(full_candidates) == 1:
-        #         warehouse = warehouses.filtered(lambda wh: wh.id in full_candidates)
-        #         date_planned = self._next_warehouse_shipping_date(warehouse)
-        #         order_fake.warehouse_id = warehouse
-        #         return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
-        #
-        #     warehouse = self._find_closest_warehouse_by_partner(
-        #         warehouses.filtered(lambda wh: wh.id in full_candidates), order_fake.partner_shipping_id)
-        #     date_planned = self._next_warehouse_shipping_date(warehouse)
-        #     order_fake.warehouse_id = warehouse
-        #     return {'warehouse_id': warehouse.id, 'date_planned': date_planned}
-        #
-        # if partial_candidates:
-        #     if len(partial_candidates) == 1:
-        #         warehouse = warehouses.filtered(lambda wh: wh.id in partial_candidates)
-        #         order_fake.warehouse_id = warehouse
-        #         return {'warehouse_id': warehouse.id}
-        #
-        #     sorted_warehouses = self._sort_warehouses_by_partner(warehouses.filtered(lambda wh: wh.id in partial_candidates), order_fake.partner_shipping_id)
-        #     primary_wh = sorted_warehouses[0] #partial_candidates means there is at least one warehouse
-        #     primary_wh_date_planned = self._next_warehouse_shipping_date(primary_wh)
-        #     wh_date_planning[primary_wh.id] = primary_wh_date_planned
-        #     for wh in sorted_warehouses:
-        #         if not buy_qty:
-        #             continue
-        #         stock = product_stock[wh.id]
-        #         for p_id, p_vals in stock.items():
-        #             if p_id in buy_qty and self._is_in_stock(p_vals, buy_qty[p_id]):
-        #                 if wh.id not in sub_options:
-        #                     sub_options[wh.id] = {
-        #                         'date_planned': self._next_warehouse_shipping_date(wh),
-        #                         'product_ids': [],
-        #                         'product_skus': [],
-        #                     }
-        #                 sub_options[wh.id]['product_ids'].append(p_id)
-        #                 sub_options[wh.id]['product_skus'].append(p_vals['sku'])
-        #                 del buy_qty[p_id]
-        #
-        #     if not buy_qty:
-        #         # item_details can fulfil all items.
-        #         # this is good!!
-        #         order_fake.warehouse_id = primary_wh
-        #         return {'warehouse_id': primary_wh.id, 'date_planned': primary_wh_date_planned, 'sub_options': sub_options}
-        #
-        #     # warehouses cannot fulfil all requested items!!
-        #     order_fake.warehouse_id = primary_wh
-        #     return {'warehouse_id': primary_wh.id}
-        #
-        # # nobody has stock!
-        # primary_wh = self._find_closest_warehouse_by_partner(warehouses, order_fake.partner_shipping_id)
-        # order_fake.warehouse_id = primary_wh
-        # return {'warehouse_id': primary_wh.id}
-
     def _is_in_stock(self, p_stock, buy_qty):
         return p_stock['real_qty_available'] >= buy_qty
 
@@ -700,6 +625,7 @@ class SaleOrderMakePlan(models.TransientModel):
             if policy and policy.carrier_filter_id:
                 domain.extend(tools.safe_eval(policy.carrier_filter_id.domain))
         carriers = self.get_shipping_carriers(base_option.get('carrier_id'), domain=domain)
+        _logger.info('generate_shipping_options:: base_optoin: ' + str(base_option) + ' order_fake: ' + str(order_fake) + ' carriers: ' + str(carriers))
 
         if not carriers:
             return base_option
@@ -711,8 +637,9 @@ class SaleOrderMakePlan(models.TransientModel):
                 option = self._generate_shipping_carrier_option(base_option, order_fake, carrier)
                 if option:
                     options.append(option)
-
-            return options
+            if options:
+                return options
+            return [base_option]
         else:
             warehouses = self.get_warehouses()
             original_order_fake_warehouse_id = order_fake.warehouse_id
@@ -776,14 +703,33 @@ class SaleOrderMakePlan(models.TransientModel):
 
         # this logic comes from "delivery.models.sale_order.SaleOrder"
         try:
+            result = None
             date_delivered = None
             transit_days = 0
             if carrier.delivery_type not in ['fixed', 'base_on_rule']:
-                result = carrier.get_shipping_price_for_plan(order_fake, base_option.get('date_planned'))
-                if result:
+                if hasattr(carrier, 'rate_shipment_date_planned'):
+                    # New API
+                    result = carrier.rate_shipment_date_planned(order_fake, base_option.get('date_planned'))
+                    if result:
+                        if not result.get('success'):
+                            return None
+                        price_unit, transit_days, date_delivered = result['price'], result.get('transit_days'), result.get('date_delivered')
+                elif hasattr(carrier, 'get_shipping_price_for_plan'):
+                    # Old API
+                    result = carrier.get_shipping_price_for_plan(order_fake, base_option.get('date_planned'))
+                if result and isinstance(result, list):
                     price_unit, transit_days, date_delivered = result[0]
-                else:
-                    price_unit = carrier.get_shipping_price_from_so(order_fake)[0]
+                elif not result:
+                    rate = carrier.rate_shipment(order_fake)
+                    if rate and rate.get('success'):
+                        price_unit = rate['price']
+                        if rate.get('transit_days'):
+                            transit_days = rate.get('transit_days')
+                        if rate.get('date_delivered'):
+                            date_delivered = rate.get('date_delivered')
+                    else:
+                        _logger.warn('returning None because carrier: ' + str(carrier))
+                        return None
             else:
                 carrier = carrier.verify_carrier(order_fake.partner_shipping_id)
                 if not carrier:
@@ -802,13 +748,13 @@ class SaleOrderMakePlan(models.TransientModel):
             option = deepcopy(base_option)
             option['carrier_id'] = carrier.id
             option['shipping_price'] = final_price
-            option['requested_date'] = fields.Datetime.to_string(date_delivered) if date_delivered and isinstance(date_delivered, datetime) else date_delivered
+            option['requested_date'] = fields.Datetime.to_string(date_delivered) if (date_delivered and isinstance(date_delivered, datetime)) else date_delivered
             option['transit_days'] = transit_days
             return option
         except Exception as e:
-            # _logger.warn("Exception collecting carrier rates: " + str(e))
+            _logger.info("Exception collecting carrier rates: " + str(e))
+            # Want to see more?
             # _logger.exception(e)
-            pass
 
         return None
 

From 1c0eb33539571d909f830e2ba57712ce80f5a476 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@jaredkipe.com>
Date: Mon, 24 Sep 2018 10:27:01 -0700
Subject: [PATCH 05/21] FIX `sale_planner` Issue where ZIP with additional '-'
 does not geolocate

---
 sale_planner/wizard/order_planner.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 470f1135..8bea53b3 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -60,8 +60,8 @@ class FakePartner():
             # The fast way.
             if ZipcodeSearchEngine and self.zip:
                 with ZipcodeSearchEngine() as search:
-                    zipcode = search.by_zipcode(self.zip)
-                    if zipcode:
+                    zipcode = search.by_zipcode(str(self.zip).split('-')[0])
+                    if zipcode and zipcode['Latitude']:
                         self.partner_latitude = zipcode['Latitude']
                         self.partner_longitude = zipcode['Longitude']
                         return self.date_localization

From fb708881190f57c6531d56e5f04ee2fa7bdaf4af Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@jaredkipe.com>
Date: Mon, 24 Sep 2018 11:21:54 -0700
Subject: [PATCH 06/21] IMP `sale_planner` better error handling and fixing '-'
 in `res.partner`.geo_localize()

---
 sale_planner/models/partner.py       | 4 ++--
 sale_planner/wizard/order_planner.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/sale_planner/models/partner.py b/sale_planner/models/partner.py
index a0790ce7..a14c45d3 100644
--- a/sale_planner/models/partner.py
+++ b/sale_planner/models/partner.py
@@ -15,8 +15,8 @@ class Partner(models.Model):
         for partner in self.with_context(lang='en_US'):
             if ZipcodeSearchEngine and partner.zip:
                 with ZipcodeSearchEngine() as search:
-                    zipcode = search.by_zipcode(partner.zip)
-                    if zipcode:
+                    zipcode = search.by_zipcode(str(self.zip).split('-')[0])
+                    if zipcode and zipcode['Latitude']:
                         partner.write({
                             'partner_latitude': zipcode['Latitude'],
                             'partner_longitude': zipcode['Longitude'],
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 8bea53b3..10ac7aba 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -55,7 +55,7 @@ class FakePartner():
 
     @property
     def date_localization(self):
-        if not hasattr(self, 'date_localization'):
+        if not hasattr(self, 'date_localization') and self.date_localization:
             self.date_localization = 'TODAY!'
             # The fast way.
             if ZipcodeSearchEngine and self.zip:

From 042d141702588ea497e03cee8820191706d04ad6 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Sun, 30 Dec 2018 09:40:32 -0800
Subject: [PATCH 07/21] #63 Migrate to new API.

---
 sale_planner/models/partner.py       | 14 +++++++-------
 sale_planner/wizard/order_planner.py | 14 +++++++-------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/sale_planner/models/partner.py b/sale_planner/models/partner.py
index a14c45d3..fe44f548 100644
--- a/sale_planner/models/partner.py
+++ b/sale_planner/models/partner.py
@@ -1,9 +1,9 @@
 from odoo import api, fields, models
 
 try:
-    from uszipcode import ZipcodeSearchEngine
+    from uszipcode import SearchEngine
 except ImportError:
-    ZipcodeSearchEngine = None
+    SearchEngine = None
 
 
 class Partner(models.Model):
@@ -13,13 +13,13 @@ class Partner(models.Model):
     def geo_localize(self):
         # We need country names in English below
         for partner in self.with_context(lang='en_US'):
-            if ZipcodeSearchEngine and partner.zip:
-                with ZipcodeSearchEngine() as search:
+            if SearchEngine and partner.zip:
+                with SearchEngine() as search:
                     zipcode = search.by_zipcode(str(self.zip).split('-')[0])
-                    if zipcode and zipcode['Latitude']:
+                    if zipcode and zipcode.lat:
                         partner.write({
-                            'partner_latitude': zipcode['Latitude'],
-                            'partner_longitude': zipcode['Longitude'],
+                            'partner_latitude': zipcode.lat,
+                            'partner_longitude': zipcode.lng,
                             'date_localization': fields.Date.context_today(partner),
                         })
                     else:
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 10ac7aba..75c81fca 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -8,10 +8,10 @@ from logging import getLogger
 _logger = getLogger(__name__)
 
 try:
-    from uszipcode import ZipcodeSearchEngine
+    from uszipcode import SearchEngine
 except ImportError:
     _logger.warn('module "uszipcode" cannot be loaded, falling back to Google API')
-    ZipcodeSearchEngine = None
+    SearchEngine = None
 
 from odoo import api, fields, models, tools
 from odoo.addons.base_geolocalize.models.res_partner import geo_find, geo_query_address
@@ -58,12 +58,12 @@ class FakePartner():
         if not hasattr(self, 'date_localization') and self.date_localization:
             self.date_localization = 'TODAY!'
             # The fast way.
-            if ZipcodeSearchEngine and self.zip:
-                with ZipcodeSearchEngine() as search:
+            if SearchEngine and self.zip:
+                with SearchEngine() as search:
                     zipcode = search.by_zipcode(str(self.zip).split('-')[0])
-                    if zipcode and zipcode['Latitude']:
-                        self.partner_latitude = zipcode['Latitude']
-                        self.partner_longitude = zipcode['Longitude']
+                    if zipcode and zipcode.lat:
+                        self.partner_latitude = zipcode.lat
+                        self.partner_longitude = zipcode.lng
                         return self.date_localization
 
             # The slow way.

From d1b8411dc580b94be91951c1b9d8d55603d3ac94 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@jaredkipe.com>
Date: Sat, 16 Mar 2019 10:43:43 -0700
Subject: [PATCH 08/21] MIG `sale_planner` to 12.0

---
 sale_planner/__manifest__.py              |  4 +-
 sale_planner/models/__init__.py           |  9 +++--
 sale_planner/models/resource.py           | 47 +++++++++++++++++++++++
 sale_planner/security/ir.model.access.csv |  2 +
 sale_planner/tests/test_planner.py        | 24 +++++++++---
 sale_planner/wizard/order_planner.py      | 36 ++++++-----------
 6 files changed, 85 insertions(+), 37 deletions(-)
 create mode 100644 sale_planner/models/resource.py
 create mode 100644 sale_planner/security/ir.model.access.csv

diff --git a/sale_planner/__manifest__.py b/sale_planner/__manifest__.py
index bdb3d28c..680a4538 100644
--- a/sale_planner/__manifest__.py
+++ b/sale_planner/__manifest__.py
@@ -1,7 +1,7 @@
 {
     'name': 'Sale Order Planner',
     'summary': 'Plans order dates and warehouses.',
-    'version': '11.0.1.0.0',
+    'version': '12.0.1.0.0',
     'author': "Hibou Corp.",
     'category': 'Sale',
     'license': 'AGPL-3',
@@ -23,7 +23,6 @@ on the specific method's characteristics. (e.g. Do they deliver on Saturday?)
 
 """,
     'depends': [
-        'sale_order_dates',
         'sale_sourced_by_line',
         'base_geolocalize',
         'delivery',
@@ -32,6 +31,7 @@ on the specific method's characteristics. (e.g. Do they deliver on Saturday?)
     ],
     'demo': [],
     'data': [
+        'security/ir.model.access.csv',
         'wizard/order_planner_views.xml',
         'views/sale.xml',
         'views/stock.xml',
diff --git a/sale_planner/models/__init__.py b/sale_planner/models/__init__.py
index 4257587e..ff524f40 100644
--- a/sale_planner/models/__init__.py
+++ b/sale_planner/models/__init__.py
@@ -1,6 +1,7 @@
+from . import delivery
+from . import partner
+from . import planning
+from . import product
+from . import resource
 from . import sale
 from . import stock
-from . import delivery
-from . import product
-from . import planning
-from . import partner
diff --git a/sale_planner/models/resource.py b/sale_planner/models/resource.py
new file mode 100644
index 00000000..0f4e7b43
--- /dev/null
+++ b/sale_planner/models/resource.py
@@ -0,0 +1,47 @@
+from functools import partial
+from datetime import timedelta
+from odoo import api, models
+from odoo.addons.resource.models.resource import make_aware
+
+
+class ResourceCalendar(models.Model):
+    _inherit = 'resource.calendar'
+
+    @api.multi
+    def plan_days_end(self, days, day_dt, compute_leaves=False, domain=None):
+        """
+        Override to `plan_days` that allows you to get the nearest 'end' including today.
+        """
+        day_dt, revert = make_aware(day_dt)
+
+        # which method to use for retrieving intervals
+        if compute_leaves:
+            get_intervals = partial(self._work_intervals, domain=domain)
+        else:
+            get_intervals = self._attendance_intervals
+
+        if days >= 0:
+            found = set()
+            delta = timedelta(days=14)
+            for n in range(100):
+                dt = day_dt + delta * n
+                for start, stop, meta in get_intervals(dt, dt + delta):
+                    found.add(start.date())
+                    if len(found) >= days:
+                        return revert(stop)
+            return False
+
+        elif days < 0:
+            days = abs(days)
+            found = set()
+            delta = timedelta(days=14)
+            for n in range(100):
+                dt = day_dt - delta * n
+                for start, stop, meta in reversed(get_intervals(dt - delta, dt)):
+                    found.add(start.date())
+                    if len(found) == days:
+                        return revert(start)
+            return False
+
+        else:
+            return revert(day_dt)
diff --git a/sale_planner/security/ir.model.access.csv b/sale_planner/security/ir.model.access.csv
new file mode 100644
index 00000000..76f4df22
--- /dev/null
+++ b/sale_planner/security/ir.model.access.csv
@@ -0,0 +1,2 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_sale_order_planning_policy,access_sale_order_planning_policy,model_sale_order_planning_policy,base.group_user,1,1,1,1
\ No newline at end of file
diff --git a/sale_planner/tests/test_planner.py b/sale_planner/tests/test_planner.py
index 35dad49c..9f5e3f16 100644
--- a/sale_planner/tests/test_planner.py
+++ b/sale_planner/tests/test_planner.py
@@ -48,26 +48,38 @@ class TestPlanner(common.TransactionCase):
             'partner_latitude': 40.51525,
             'partner_longitude': -107.54645,
         })
+        hour_from = (self.today.hour - 1) % 24
+        hour_to = (self.today.hour + 1) % 24
+        if hour_to < hour_from:
+            hour_to, hour_from = hour_from, hour_to
+
         self.warehouse_calendar_1 = self.env['resource.calendar'].create({
             'name': 'Washington Warehouse Hours',
+            'tz': 'UTC',
             'attendance_ids': [
                 (0, 0, {'name': 'today',
                         'dayofweek': str(self.today.weekday()),
-                        'hour_from': (self.today.hour - 1) % 24,
-                        'hour_to': (self.today.hour + 1) % 24}),
+                        'hour_from': hour_from,
+                        'hour_to': hour_to,
+                        'day_period': 'morning'}),
+
                 (0, 0, {'name': 'tomorrow',
                         'dayofweek': str(self.tomorrow.weekday()),
-                        'hour_from': (self.tomorrow.hour - 1) % 24,
-                        'hour_to': (self.tomorrow.hour + 1) % 24}),
+                        'hour_from': hour_from,
+                        'hour_to': hour_to,
+                        'day_period': 'morning'}),
+
             ]
         })
         self.warehouse_calendar_2 = self.env['resource.calendar'].create({
             'name': 'Colorado Warehouse Hours',
+            'tz': 'UTC',
             'attendance_ids': [
                 (0, 0, {'name': 'tomorrow',
                         'dayofweek': str(self.tomorrow.weekday()),
-                        'hour_from': (self.tomorrow.hour - 1) % 24,
-                        'hour_to': (self.tomorrow.hour + 1) % 24}),
+                        'hour_from': hour_from,
+                        'hour_to': hour_to,
+                        'day_period': 'morning'}),
             ]
         })
         self.warehouse_1 = self.env['stock.warehouse'].create({
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 75c81fca..fd3c7445 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -1,7 +1,7 @@
 from math import sin, cos, sqrt, atan2, radians
 from json import dumps, loads
 from copy import deepcopy
-from datetime import datetime
+from datetime import datetime, timedelta
 from collections import defaultdict
 from logging import getLogger
 
@@ -299,7 +299,6 @@ class SaleOrderMakePlan(models.TransientModel):
         return Carrier.search(domain)
 
     def _generate_base_option(self, order_fake, policy_group):
-        policy = False
         flag_force_closest = False
         warehouse_domain = False
         if 'policy' in policy_group:
@@ -382,11 +381,11 @@ class SaleOrderMakePlan(models.TransientModel):
 
         # nobody has stock!
         primary_wh = self._find_closest_warehouse_by_partner(warehouses, order_fake.partner_shipping_id)
-        #order_fake.warehouse_id = primary_wh
         return {'warehouse_id': primary_wh.id}
 
     def generate_base_option(self, order_fake):
         _logger.error('generate_base_option:')
+        __start_date = datetime.now() - timedelta(days=-30)
         product_lines = list(filter(lambda line: line.product_id.type == 'product', order_fake.order_line))
         if not product_lines:
             return {}
@@ -410,7 +409,6 @@ class SaleOrderMakePlan(models.TransientModel):
                 policy_groups[0]['products'].append(p)
                 policy_groups[0]['buy_qty'][p.id] = buy_qty[p.id]
 
-
         for _, policy_group in policy_groups.items():
             product_set = self.env['product.product'].browse()
             for p in policy_group['products']:
@@ -418,8 +416,7 @@ class SaleOrderMakePlan(models.TransientModel):
             policy_group['products'] = product_set
             policy_group['base_option'] = self._generate_base_option(order_fake, policy_group)
 
-
-        option_policy_groups = defaultdict(lambda: {'products': self.env['product.product'].browse(), 'policies': self.env['sale.order.planning.policy'].browse(), 'date_planned': '1900', 'sub_options': [],})
+        option_policy_groups = defaultdict(lambda: {'products': self.env['product.product'].browse(), 'policies': self.env['sale.order.planning.policy'].browse(), 'date_planned': __start_date, 'sub_options': [],})
         for policy_id, policy_group in policy_groups.items():
             base_option = policy_group['base_option']
             _logger.error('  base_option: ' + str(base_option))
@@ -444,7 +441,7 @@ class SaleOrderMakePlan(models.TransientModel):
             if not option_group['sub_options']:
                 del option_group['sub_options']
             else:
-                sub_options = defaultdict(lambda: {'date_planned': '1900', 'product_ids': [], 'product_skus': []})
+                sub_options = defaultdict(lambda: {'date_planned': __start_date, 'product_ids': [], 'product_skus': []})
                 remaining_products = option_group['products']
                 for options in option_group['sub_options']:
                     for wh_id, option in options.items():
@@ -466,7 +463,7 @@ class SaleOrderMakePlan(models.TransientModel):
 
         # At this point we should have all of the policy options collapsed.
         # Collapse warehouse options.
-        base_option = {'date_planned': '1900', 'products': self.env['product.product'].browse()}
+        base_option = {'date_planned': __start_date, 'products': self.env['product.product'].browse()}
         for wh_id, intermediate_option in option_policy_groups.items():
             _logger.error('    base_option: ' + str(base_option))
             _logger.error('    intermediate_option: ' + str(intermediate_option))
@@ -596,7 +593,7 @@ class SaleOrderMakePlan(models.TransientModel):
 
     def _next_warehouse_shipping_date(self, warehouse):
         if warehouse.shipping_calendar_id:
-            return fields.Datetime.to_string(warehouse.shipping_calendar_id.plan_days(0.01, fields.Datetime.from_string(fields.Datetime.now()), compute_leaves=True))
+            return warehouse.shipping_calendar_id.plan_days_end(0, fields.Datetime.now(), compute_leaves=True)
         return False
 
     @api.model
@@ -683,15 +680,11 @@ class SaleOrderMakePlan(models.TransientModel):
         max_requested_date = None
         for option in sub_options.values():
             requested_date = option.get('requested_date')
-            if requested_date and isinstance(requested_date, str):
-                requested_date = fields.Datetime.from_string(requested_date)
             if requested_date and not max_requested_date:
                 max_requested_date = requested_date
             elif requested_date:
                 if requested_date > max_requested_date:
                     max_requested_date = requested_date
-        if max_requested_date:
-            return fields.Datetime.to_string(max_requested_date)
         return max_requested_date
 
     def _get_max_transit_days(self, sub_options):
@@ -748,7 +741,7 @@ class SaleOrderMakePlan(models.TransientModel):
             option = deepcopy(base_option)
             option['carrier_id'] = carrier.id
             option['shipping_price'] = final_price
-            option['requested_date'] = fields.Datetime.to_string(date_delivered) if (date_delivered and isinstance(date_delivered, datetime)) else date_delivered
+            option['requested_date'] = date_delivered
             option['transit_days'] = transit_days
             return option
         except Exception as e:
@@ -759,13 +752,15 @@ class SaleOrderMakePlan(models.TransientModel):
         return None
 
 
-
 class SaleOrderPlanningOption(models.TransientModel):
     _name = 'sale.order.planning.option'
     _description = 'Order Planning Option'
 
     def create(self, values):
         if 'sub_options' in values and not isinstance(values['sub_options'], str):
+            for wh_id, option in values['sub_options'].items():
+                if option.get('date_planned'):
+                    option['date_planned'] = str(option['date_planned'])
             values['sub_options'] = dumps(values['sub_options'])
         return super(SaleOrderPlanningOption, self).create(values)
 
@@ -782,13 +777,9 @@ class SaleOrderPlanningOption(models.TransientModel):
             line = ''
             for wh_id, wh_option in sub_options.items():
                 product_skus = wh_option.get('product_skus', [])
+                date_planned = wh_option.get('date_planned')
                 product_skus = ', '.join(product_skus)
                 requested_date = wh_option.get('requested_date', '')
-                if requested_date:
-                    requested_date = self._context_datetime(requested_date)
-                date_planned = wh_option.get('date_planned', '')
-                if date_planned:
-                    date_planned = self._context_datetime(date_planned)
                 shipping_price = float(wh_option.get('shipping_price', 0.0))
                 transit_days = int(wh_option.get('transit_days', 0))
 
@@ -817,8 +808,3 @@ class SaleOrderPlanningOption(models.TransientModel):
         for option in self:
             option.plan_id.select_option(option)
             return
-
-    def _context_datetime(self, date):
-        date = fields.Datetime.from_string(date)
-        date = fields.Datetime.context_timestamp(self, date)
-        return fields.Datetime.to_string(date)

From 76026a0b4e053ea483689352375aa1c7eaa123e5 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@jaredkipe.com>
Date: Sat, 16 Mar 2019 11:01:01 -0700
Subject: [PATCH 09/21] FIX `sale_planner` sentinal date should be in the past.

---
 sale_planner/wizard/order_planner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index fd3c7445..db9d2fda 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -385,7 +385,7 @@ class SaleOrderMakePlan(models.TransientModel):
 
     def generate_base_option(self, order_fake):
         _logger.error('generate_base_option:')
-        __start_date = datetime.now() - timedelta(days=-30)
+        __start_date = datetime.now() - timedelta(days=30)
         product_lines = list(filter(lambda line: line.product_id.type == 'product', order_fake.order_line))
         if not product_lines:
             return {}

From 09666007ff7504c23447628777c3db644acc3caf Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@jaredkipe.com>
Date: Sat, 16 Mar 2019 14:14:17 -0700
Subject: [PATCH 10/21] FIX `sale_planner` Carrier testing/plannning in 12.0

---
 sale_planner/models/delivery.py      |  6 +++---
 sale_planner/wizard/order_planner.py | 16 ++++++++--------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/sale_planner/models/delivery.py b/sale_planner/models/delivery.py
index 17a5eb25..08c0a8d5 100644
--- a/sale_planner/models/delivery.py
+++ b/sale_planner/models/delivery.py
@@ -92,11 +92,11 @@ class DeliveryCarrier(models.Model):
         # date calculations needs an extra day
         effective_transit_days = transit_days + 1
 
-        last_day = self.delivery_calendar_id.plan_days(effective_transit_days, date_planned, compute_leaves=True)
+        last_day = self.delivery_calendar_id.plan_days_end(effective_transit_days, date_planned, compute_leaves=True)
         if not last_day:
             return self._calculate_date_delivered_naive(date_planned, transit_days)
 
-        return fields.Datetime.to_string(last_day)
+        return last_day
 
     def _calculate_date_delivered_naive(self, date_planned, transit_days):
-        return fields.Datetime.to_string(date_planned + timedelta(days=transit_days))
+        return date_planned + timedelta(days=transit_days)
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index db9d2fda..e02d8b90 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -134,6 +134,7 @@ class FakeSaleOrder():
         self.team_id = None
         self.project_id = None
         self.amount_total = 0.0
+        self.date_order = fields.Date.today()
         for attr, value in kwargs.items():
             setattr(self, attr, value)
 
@@ -143,6 +144,8 @@ class FakeSaleOrder():
         """
         yield self
 
+    def _compute_amount_total_without_delivery(self):
+        return self.amount_total
 
 def distance(lat_1, lon_1, lat_2, lon_2):
     R = 6373.0
@@ -251,6 +254,8 @@ class SaleOrderMakePlan(models.TransientModel):
             base_option['carrier_id'] = order.carrier_id.id
 
         if plan_shipping and not self.env.context.get('skip_plan_shipping'):
+            if base_option.get('date_planned'):
+                fake_order.date_order = base_option['date_planned']
             options = self.generate_shipping_options(base_option, fake_order)
         else:
             options = [base_option]
@@ -724,16 +729,11 @@ class SaleOrderMakePlan(models.TransientModel):
                         _logger.warn('returning None because carrier: ' + str(carrier))
                         return None
             else:
-                carrier = carrier.verify_carrier(order_fake.partner_shipping_id)
+                carrier = carrier.available_carriers(order_fake.partner_shipping_id)
                 if not carrier:
                     return None
-                #price_unit = carrier.get_price_available(order)
-                # ^^ ends up calling carrier.get_price_from_picking(order_total, weight, volume, quantity)
-                order_total = order_fake.amount_total
-                weight = sum((line.product_id.weight or 0.0) * line.product_uom_qty for line in order_fake.order_line if line.product_id.type == 'product')
-                volume = sum((line.product_id.volume or 0.0) * line.product_uom_qty for line in order_fake.order_line if line.product_id.type == 'product')
-                quantity = sum((line.product_uom_qty or 0.0) for line in order_fake.order_line if line.product_id.type == 'product')
-                price_unit = carrier.get_price_from_picking(order_total, weight, volume, quantity)
+                res = carrier.rate_shipment(order_fake)
+                price_unit = res['price']
                 if order_fake.company_id.currency_id.id != order_fake.pricelist_id.currency_id.id:
                     price_unit = order_fake.company_id.currency_id.with_context(date=order_fake.date_order).compute(price_unit, order_fake.pricelist_id.currency_id)
 

From 2fc6143a9d47628baca911a6d7ea4cf2b6e6709d Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Fri, 31 May 2019 14:20:08 -0700
Subject: [PATCH 11/21] FIX `sale_planner` Add property from Enterprise
 `delivery_ups` on FakeSaleOrder

---
 sale_planner/wizard/order_planner.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index e02d8b90..c884fb58 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -135,6 +135,8 @@ class FakeSaleOrder():
         self.project_id = None
         self.amount_total = 0.0
         self.date_order = fields.Date.today()
+        self.shipping_account_id = False  # from delivery_hibou
+        self.ups_service_type = False  # Added in 12
         for attr, value in kwargs.items():
             setattr(self, attr, value)
 

From 387df6075fc8c421f04adbb5615a31bd72f1f412 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Mon, 15 Jul 2019 08:17:42 -0700
Subject: [PATCH 12/21] FIX `sale_planner` FakeSaleOrder project_id =>
 analytic_accout_id

---
 sale_planner/wizard/order_planner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index c884fb58..75db1e3b 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -132,7 +132,7 @@ class FakeSaleOrder():
         self.id = 0
         self.name = 'Quote'
         self.team_id = None
-        self.project_id = None
+        self.analytic_account_id = None
         self.amount_total = 0.0
         self.date_order = fields.Date.today()
         self.shipping_account_id = False  # from delivery_hibou

From 6a754d38aba6cc6922e02d4cd2133f09e74f558a Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Mon, 15 Jul 2019 09:47:51 -0700
Subject: [PATCH 13/21] IMP `sale_planner` Fake objects now return False for
 any attribute they don't implement.

---
 sale_planner/wizard/order_planner.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 75db1e3b..09b69169 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -78,6 +78,9 @@ class FakePartner():
 
         return self.date_localization
 
+    def __getattr__(self, item):
+        return False
+
 
 class FakeOrderLine():
     def __init__(self, **kwargs):
@@ -108,6 +111,9 @@ class FakeOrderLine():
         """
         return qty
 
+    def __getattr__(self, item):
+        return False
+
 
 class FakeSaleOrder():
     """
@@ -149,6 +155,10 @@ class FakeSaleOrder():
     def _compute_amount_total_without_delivery(self):
         return self.amount_total
 
+    def __getattr__(self, item):
+        return False
+
+
 def distance(lat_1, lon_1, lat_2, lon_2):
     R = 6373.0
 

From 5f73a21ba6904419c02b21e1ac8120e91cb04873 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Mon, 15 Jul 2019 12:29:38 -0700
Subject: [PATCH 14/21] IMP `order_planner` allow subscription access to Fakes

---
 sale_planner/wizard/order_planner.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 09b69169..c23bf8f8 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -81,6 +81,11 @@ class FakePartner():
     def __getattr__(self, item):
         return False
 
+    def __getitem__(self, item):
+        if item == '__last_update':
+            return str(datetime.now())
+        return getattr(self, item)
+
 
 class FakeOrderLine():
     def __init__(self, **kwargs):
@@ -114,6 +119,11 @@ class FakeOrderLine():
     def __getattr__(self, item):
         return False
 
+    def __getitem__(self, item):
+        if item == '__last_update':
+            return str(datetime.now())
+        return getattr(self, item)
+
 
 class FakeSaleOrder():
     """
@@ -158,6 +168,11 @@ class FakeSaleOrder():
     def __getattr__(self, item):
         return False
 
+    def __getitem__(self, item):
+        if item == '__last_update':
+            return str(datetime.now())
+        return getattr(self, item)
+
 
 def distance(lat_1, lon_1, lat_2, lon_2):
     R = 6373.0

From 5464621ab0708d1470682bc612393b49d3555412 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Tue, 16 Jul 2019 15:07:41 -0700
Subject: [PATCH 15/21] IMP `sale_planner` FakePartner now provides a
 FakePartner parent_id

---
 sale_planner/wizard/order_planner.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index c23bf8f8..6e27fcff 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -50,6 +50,9 @@ class FakePartner():
         self.partner_latitude = 0.0
         self.partner_longitude = 0.0
         self.is_company = False
+        self._date_localization = kwargs.pop('date_localization', False)
+        if not kwargs.pop('PARENT', False):
+            self.parent_id = FakePartner(PARENT=True)
         for attr, value in kwargs.items():
             setattr(self, attr, value)
 

From b8ea97c27bf579dfb06fe204898707d810ed12e1 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Tue, 6 Aug 2019 16:11:36 -0700
Subject: [PATCH 16/21] FIX `sale_planner` It is possible that the 'fall back'
 core geo_localize can raise an index error

---
 sale_planner/models/partner.py       | 29 ++++++++++--------
 sale_planner/wizard/order_planner.py | 44 +++++++++++++++-------------
 2 files changed, 39 insertions(+), 34 deletions(-)

diff --git a/sale_planner/models/partner.py b/sale_planner/models/partner.py
index fe44f548..23e258d3 100644
--- a/sale_planner/models/partner.py
+++ b/sale_planner/models/partner.py
@@ -13,17 +13,20 @@ class Partner(models.Model):
     def geo_localize(self):
         # We need country names in English below
         for partner in self.with_context(lang='en_US'):
-            if SearchEngine and partner.zip:
-                with SearchEngine() as search:
-                    zipcode = search.by_zipcode(str(self.zip).split('-')[0])
-                    if zipcode and zipcode.lat:
-                        partner.write({
-                            'partner_latitude': zipcode.lat,
-                            'partner_longitude': zipcode.lng,
-                            'date_localization': fields.Date.context_today(partner),
-                        })
-                    else:
-                        super(Partner, partner).geo_localize()
-            else:
-                super(Partner, partner).geo_localize()
+            try:
+                if SearchEngine and partner.zip:
+                    with SearchEngine() as search:
+                        zipcode = search.by_zipcode(str(self.zip).split('-')[0])
+                        if zipcode and zipcode.lat:
+                            partner.write({
+                                'partner_latitude': zipcode.lat,
+                                'partner_longitude': zipcode.lng,
+                                'date_localization': fields.Date.context_today(partner),
+                            })
+                        else:
+                            super(Partner, partner).geo_localize()
+                else:
+                    super(Partner, partner).geo_localize()
+            except:
+                pass
         return True
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 6e27fcff..d7274e88 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -58,28 +58,30 @@ class FakePartner():
 
     @property
     def date_localization(self):
-        if not hasattr(self, 'date_localization') and self.date_localization:
-            self.date_localization = 'TODAY!'
-            # The fast way.
-            if SearchEngine and self.zip:
-                with SearchEngine() as search:
-                    zipcode = search.by_zipcode(str(self.zip).split('-')[0])
-                    if zipcode and zipcode.lat:
-                        self.partner_latitude = zipcode.lat
-                        self.partner_longitude = zipcode.lng
-                        return self.date_localization
+        if not self._date_localization:
+            try:
+                self._date_localization = 'TODAY!'
+                # The fast way.
+                if SearchEngine and self.zip:
+                    with SearchEngine() as search:
+                        zipcode = search.by_zipcode(str(self.zip).split('-')[0])
+                        if zipcode and zipcode.lat:
+                            self.partner_latitude = zipcode.lat
+                            self.partner_longitude = zipcode.lng
+                            return self._date_localization
 
-            # The slow way.
-            result = geo_find(geo_query_address(
-                city=self.city,
-                state=self.state_id.name,
-                country=self.country_id.name,
-            ))
-            if result:
-                self.partner_latitude = result[0]
-                self.partner_longitude = result[1]
-
-        return self.date_localization
+                # The slow way.
+                result = geo_find(geo_query_address(
+                    city=self.city,
+                    state=self.state_id.name,
+                    country=self.country_id.name,
+                ))
+                if result:
+                    self.partner_latitude = result[0]
+                    self.partner_longitude = result[1]
+            except:
+                self._date_localization = 'ERROR'
+        return self._date_localization
 
     def __getattr__(self, item):
         return False

From 051acda21a2598f86a6aee3a6bc2adccb59559bc Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Wed, 2 Oct 2019 02:30:51 -0700
Subject: [PATCH 17/21] FIX  `sale_planner` correctly serialize suboption
 datetime

---
 sale_planner/wizard/order_planner.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index d7274e88..179f8617 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -725,7 +725,7 @@ class SaleOrderMakePlan(models.TransientModel):
         return max_requested_date
 
     def _get_max_transit_days(self, sub_options):
-        return max(wh_option.get('transit_days', 0) for wh_option in sub_options.values())
+        return max(wh_option.get('transit_days', 0) or 0 for wh_option in sub_options.values())
 
     def _generate_shipping_carrier_option(self, base_option, order_fake, carrier):
         # some carriers look at the order carrier_id
@@ -789,11 +789,15 @@ class SaleOrderPlanningOption(models.TransientModel):
     _description = 'Order Planning Option'
 
     def create(self, values):
+        def datetime_converter(o):
+            if isinstance(o, datetime):
+                return str(o)
+
         if 'sub_options' in values and not isinstance(values['sub_options'], str):
             for wh_id, option in values['sub_options'].items():
                 if option.get('date_planned'):
                     option['date_planned'] = str(option['date_planned'])
-            values['sub_options'] = dumps(values['sub_options'])
+            values['sub_options'] = dumps(values['sub_options'], default=datetime_converter)
         return super(SaleOrderPlanningOption, self).create(values)
 
     @api.multi
@@ -808,12 +812,12 @@ class SaleOrderPlanningOption(models.TransientModel):
 
             line = ''
             for wh_id, wh_option in sub_options.items():
-                product_skus = wh_option.get('product_skus', [])
-                date_planned = wh_option.get('date_planned')
+                product_skus = (str(s) for s in wh_option.get('product_skus', []))
+                date_planned = wh_option.get('date_planned') or ''
                 product_skus = ', '.join(product_skus)
-                requested_date = wh_option.get('requested_date', '')
-                shipping_price = float(wh_option.get('shipping_price', 0.0))
-                transit_days = int(wh_option.get('transit_days', 0))
+                requested_date = wh_option.get('requested_date', '') or ''
+                shipping_price = float(wh_option.get('shipping_price', 0.0) or 0)
+                transit_days = int(wh_option.get('transit_days', 0) or 0)
 
                 line += """WH %d :: %s
   Date Planned:   %s

From 958633ed504070f5c2f760ce4a50dfa39985f550 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Thu, 28 May 2020 10:48:20 -0700
Subject: [PATCH 18/21] [IMP] sale_planner: fall back calculate transit days
 when we have no planned date but do have an estimated delivery date (e.g.
 GSO)

---
 sale_planner/models/delivery.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/sale_planner/models/delivery.py b/sale_planner/models/delivery.py
index 08c0a8d5..c8526c34 100644
--- a/sale_planner/models/delivery.py
+++ b/sale_planner/models/delivery.py
@@ -50,8 +50,12 @@ class DeliveryCarrier(models.Model):
             elif rate.get('transit_days'):
                 rate['date_delivered'] = self.calculate_date_delivered(date_planned, rate.get('transit_days'))
         elif rate:
-            if rate.get('date_delivered'):
-                rate.pop('date_delivered')
+            date_delivered = rate.get('date_delivered')
+            if date_delivered and not rate.get('transit_days'):
+                # we could have a date delivered based on shipping it "now"
+                # so we can still calculate the transit days
+                rate['transit_days'] = self.calculate_transit_days(fields.Datetime.now(), date_delivered)
+                rate.pop('date_delivered')  # because we don't have a date_planned, we cannot have a guarenteed delivery
 
         return rate
 

From c18e58fd905b38562e6c098b304fc1c5d69972fa Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Sat, 31 Oct 2020 12:50:08 -0700
Subject: [PATCH 19/21] [MIG] sale_planner: to Odoo 13.0

---
 sale_planner/__manifest__.py                |  2 +-
 sale_planner/models/partner.py              |  1 -
 sale_planner/models/product.py              |  1 -
 sale_planner/models/resource.py             |  1 -
 sale_planner/models/sale.py                 |  1 -
 sale_planner/tests/test_planner.py          | 45 ++++++++++++---------
 sale_planner/wizard/order_planner.py        | 35 ++++++++--------
 sale_planner/wizard/order_planner_views.xml |  3 +-
 8 files changed, 45 insertions(+), 44 deletions(-)

diff --git a/sale_planner/__manifest__.py b/sale_planner/__manifest__.py
index 680a4538..9619a669 100644
--- a/sale_planner/__manifest__.py
+++ b/sale_planner/__manifest__.py
@@ -1,7 +1,7 @@
 {
     'name': 'Sale Order Planner',
     'summary': 'Plans order dates and warehouses.',
-    'version': '12.0.1.0.0',
+    'version': '13.0.1.0.0',
     'author': "Hibou Corp.",
     'category': 'Sale',
     'license': 'AGPL-3',
diff --git a/sale_planner/models/partner.py b/sale_planner/models/partner.py
index 23e258d3..a87ff4f0 100644
--- a/sale_planner/models/partner.py
+++ b/sale_planner/models/partner.py
@@ -9,7 +9,6 @@ except ImportError:
 class Partner(models.Model):
     _inherit = 'res.partner'
 
-    @api.multi
     def geo_localize(self):
         # We need country names in English below
         for partner in self.with_context(lang='en_US'):
diff --git a/sale_planner/models/product.py b/sale_planner/models/product.py
index 8c666a60..55cb677e 100644
--- a/sale_planner/models/product.py
+++ b/sale_planner/models/product.py
@@ -8,7 +8,6 @@ class ProductTemplate(models.Model):
         string="Order Planner Policy",
         help="The Order Planner Policy to use when making a sale order planner.")
 
-    @api.multi
     def get_planning_policy(self):
         self.ensure_one()
         return self.property_planning_policy_id or self.categ_id.property_planning_policy_categ_id
diff --git a/sale_planner/models/resource.py b/sale_planner/models/resource.py
index 0f4e7b43..07556ce7 100644
--- a/sale_planner/models/resource.py
+++ b/sale_planner/models/resource.py
@@ -7,7 +7,6 @@ from odoo.addons.resource.models.resource import make_aware
 class ResourceCalendar(models.Model):
     _inherit = 'resource.calendar'
 
-    @api.multi
     def plan_days_end(self, days, day_dt, compute_leaves=False, domain=None):
         """
         Override to `plan_days` that allows you to get the nearest 'end' including today.
diff --git a/sale_planner/models/sale.py b/sale_planner/models/sale.py
index 6d5e46b0..30396792 100644
--- a/sale_planner/models/sale.py
+++ b/sale_planner/models/sale.py
@@ -4,7 +4,6 @@ from odoo import api, fields, models
 class SaleOrder(models.Model):
     _inherit = 'sale.order'
 
-    @api.multi
     def action_planorder(self):
         plan_obj = self.env['sale.order.make.plan']
         for order in self:
diff --git a/sale_planner/tests/test_planner.py b/sale_planner/tests/test_planner.py
index 9f5e3f16..4bc58ad8 100644
--- a/sale_planner/tests/test_planner.py
+++ b/sale_planner/tests/test_planner.py
@@ -128,36 +128,36 @@ class TestPlanner(common.TransactionCase):
             'standard_price': 1.0,
         })
         self.product_both = self.product_both.product_variant_id
-        self.env['stock.change.product.qty'].create({
+        self.env['stock.quant'].create({
             'location_id': self.warehouse_1.lot_stock_id.id,
             'product_id': self.product_1.id,
-            'new_quantity': 100,
-        }).change_product_qty()
-        self.env['stock.change.product.qty'].create({
+            'quantity': 100,
+        })
+        self.env['stock.quant'].create({
             'location_id': self.warehouse_1.lot_stock_id.id,
             'product_id': self.product_12.id,
-            'new_quantity': 100,
-        }).change_product_qty()
-        self.env['stock.change.product.qty'].create({
+            'quantity': 100,
+        })
+        self.env['stock.quant'].create({
             'location_id': self.warehouse_1.lot_stock_id.id,
             'product_id': self.product_both.id,
-            'new_quantity': 100,
-        }).change_product_qty()
-        self.env['stock.change.product.qty'].create({
+            'quantity': 100,
+        })
+        self.env['stock.quant'].create({
             'location_id': self.warehouse_2.lot_stock_id.id,
             'product_id': self.product_2.id,
-            'new_quantity': 100,
-        }).change_product_qty()
-        self.env['stock.change.product.qty'].create({
+            'quantity': 100,
+        })
+        self.env['stock.quant'].create({
             'location_id': self.warehouse_2.lot_stock_id.id,
             'product_id': self.product_22.id,
-            'new_quantity': 100,
-        }).change_product_qty()
-        self.env['stock.change.product.qty'].create({
+            'quantity': 100,
+        })
+        self.env['stock.quant'].create({
             'location_id': self.warehouse_2.lot_stock_id.id,
             'product_id': self.product_both.id,
-            'new_quantity': 100,
-        }).change_product_qty()
+            'quantity': 100,
+        })
 
         self.policy_closest = self.env['sale.order.planning.policy'].create({
             'always_closest_warehouse': True,
@@ -210,8 +210,11 @@ class TestPlanner(common.TransactionCase):
             'product_id': self.product_1.id,
             'name': 'demo',
         })
-        self.assertEqual(self.product_1.with_context(warehouse=self.warehouse_1.id).qty_available, 100)
         self.assertEqual(self.product_1.with_context(warehouse=self.warehouse_2.id).qty_available, 0)
+        self.product_1.invalidate_cache(fnames=['qty_available'], ids=self.product_1.ids)
+        self.assertEqual(self.product_1.with_context(warehouse=self.warehouse_1.id).qty_available, 100)
+        self.product_1.invalidate_cache(fnames=['qty_available'], ids=self.product_1.ids)
+
         both_wh_ids = self.both_wh_ids()
         planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)], skip_plan_shipping=True).create({'order_id': self.so.id})
         self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
@@ -229,7 +232,9 @@ class TestPlanner(common.TransactionCase):
             'name': 'demo',
         })
         self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_1.id).qty_available, 0)
+        self.product_2.invalidate_cache(fnames=['qty_available'], ids=self.product_2.ids)
         self.assertEqual(self.product_2.with_context(warehouse=self.warehouse_2.id).qty_available, 100)
+        self.product_2.invalidate_cache(fnames=['qty_available'], ids=self.product_2.ids)
         both_wh_ids = self.both_wh_ids()
         planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)], skip_plan_shipping=True).create({'order_id': self.so.id})
         self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
@@ -396,7 +401,7 @@ class TestPlanner(common.TransactionCase):
         planner = self.env['sale.order.make.plan'].with_context(warehouse_domain=[('id', 'in', both_wh_ids)],
                                                                 skip_plan_shipping=True).create({'order_id': self.so.id})
         self.assertTrue(planner.planning_option_ids, 'Must have one or more plans.')
-        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_1, 'If this fails, it will probably pass next time.')
+        self.assertEqual(planner.planning_option_ids.warehouse_id, self.warehouse_2)
         self.assertTrue(planner.planning_option_ids.sub_options)
 
         sub_options = json_decode(planner.planning_option_ids.sub_options)
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 179f8617..8d664ce1 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -14,7 +14,6 @@ except ImportError:
     SearchEngine = None
 
 from odoo import api, fields, models, tools
-from odoo.addons.base_geolocalize.models.res_partner import geo_find, geo_query_address
 
 
 class FakeCollection():
@@ -28,8 +27,11 @@ class FakeCollection():
     def filtered(self, f):
         return filter(f, self.vals)
 
+    def sudo(self, *args, **kwargs):
+        return self
 
-class FakePartner():
+
+class FakePartner(FakeCollection):
     def __init__(self, **kwargs):
         """
         'delivery.carrier'.verify_carrier(contact) ->
@@ -71,11 +73,9 @@ class FakePartner():
                             return self._date_localization
 
                 # The slow way.
-                result = geo_find(geo_query_address(
-                    city=self.city,
-                    state=self.state_id.name,
-                    country=self.country_id.name,
-                ))
+                geo_obj = self.env['base.geocoder']
+                search = geo_obj.geo_query_address(city=self.city, state=self.state_id.name, country=self.country_id.name)
+                result = geo_obj.geo_find(search, force_country=self.country_id.id)
                 if result:
                     self.partner_latitude = result[0]
                     self.partner_longitude = result[1]
@@ -92,7 +92,7 @@ class FakePartner():
         return getattr(self, item)
 
 
-class FakeOrderLine():
+class FakeOrderLine(FakeCollection):
     def __init__(self, **kwargs):
         """
         'delivery.carrier'.get_price_available(order) ->
@@ -130,7 +130,7 @@ class FakeOrderLine():
         return getattr(self, item)
 
 
-class FakeSaleOrder():
+class FakeSaleOrder(FakeCollection):
     """
     partner_id :: used in shipping
     partner_shipping_id :: is used in several places
@@ -209,7 +209,6 @@ class SaleOrderMakePlan(models.TransientModel):
     def plan_order(self, vals):
         pass
 
-    @api.multi
     def select_option(self, option):
         for plan in self:
             self.plan_order_option(plan.order_id, option)
@@ -304,6 +303,8 @@ class SaleOrderMakePlan(models.TransientModel):
                 domain = tools.safe_eval(domain)
         else:
             domain = []
+            if 'allowed_company_ids' in self.env.context:
+                domain.append(('company_id', 'in', self.env.context['allowed_company_ids']))
 
         if self.env.context.get('warehouse_domain'):
             domain.extend(self.env.context.get('warehouse_domain'))
@@ -606,7 +607,7 @@ class SaleOrderMakePlan(models.TransientModel):
         return base_option
 
     def _is_in_stock(self, p_stock, buy_qty):
-        return p_stock['real_qty_available'] >= buy_qty
+        return p_stock['type'] == 'consu' or p_stock['qty_available'] >= buy_qty
 
     def _find_closest_warehouse_by_partner(self, warehouses, partner):
         if not partner.date_localization:
@@ -637,6 +638,8 @@ class SaleOrderMakePlan(models.TransientModel):
     def _fetch_product_stock(self, warehouses, products):
         output = {}
         for wh in warehouses:
+            products.invalidate_cache(fnames=['qty_available', 'virtual_available', 'incoming_qty', 'outgoing_qty'],
+                                      ids=products.ids)
             products = products.with_context({'location': wh.lot_stock_id.id})
             output[wh.id] = {
                 p.id: {
@@ -644,22 +647,22 @@ class SaleOrderMakePlan(models.TransientModel):
                     'virtual_available': p.virtual_available,
                     'incoming_qty': p.incoming_qty,
                     'outgoing_qty': p.outgoing_qty,
-                    'real_qty_available': p.qty_available - p.outgoing_qty,
-                    'sku': p.default_code
+                    'sku': p.default_code or str(p.id),
+                    'type': p.type,
                 } for p in products}
         return output
 
     def generate_shipping_options(self, base_option, order_fake):
         # generate a carrier_id, amount, requested_date (promise date)
         # if base_option['carrier_id'] then that is the only carrier we want to collect rates for.
-        product_lines = list(filter(lambda line: line.product_id.type == 'product', order_fake.order_line))
+        product_lines = list(filter(lambda line: line.product_id.type in ('product', 'consu'), order_fake.order_line))
         domain = []
         for line in product_lines:
             policy = line.product_id.product_tmpl_id.get_planning_policy()
             if policy and policy.carrier_filter_id:
                 domain.extend(tools.safe_eval(policy.carrier_filter_id.domain))
         carriers = self.get_shipping_carriers(base_option.get('carrier_id'), domain=domain)
-        _logger.info('generate_shipping_options:: base_optoin: ' + str(base_option) + ' order_fake: ' + str(order_fake) + ' carriers: ' + str(carriers))
+        _logger.info('generate_shipping_options:: base_option: ' + str(base_option) + ' order_fake: ' + str(order_fake) + ' carriers: ' + str(carriers))
 
         if not carriers:
             return base_option
@@ -800,7 +803,6 @@ class SaleOrderPlanningOption(models.TransientModel):
             values['sub_options'] = dumps(values['sub_options'], default=datetime_converter)
         return super(SaleOrderPlanningOption, self).create(values)
 
-    @api.multi
     def _compute_sub_options_text(self):
         for option in self:
             sub_options = option.sub_options
@@ -839,7 +841,6 @@ class SaleOrderPlanningOption(models.TransientModel):
     sub_options = fields.Text('Sub Options JSON')
     sub_options_text = fields.Text('Sub Options', compute=_compute_sub_options_text)
 
-    @api.multi
     def select_plan(self):
         for option in self:
             option.plan_id.select_option(option)
diff --git a/sale_planner/wizard/order_planner_views.xml b/sale_planner/wizard/order_planner_views.xml
index bf30f96d..9fd50a39 100644
--- a/sale_planner/wizard/order_planner_views.xml
+++ b/sale_planner/wizard/order_planner_views.xml
@@ -6,7 +6,7 @@
         <field name="type">form</field>
         <field name="arch" type="xml">
             <form>
-                <field name="planning_option_ids">
+                <field name="planning_option_ids" readonly="1" force_save="1">
                     <tree>
                         <field name="warehouse_id" />
                         <field name="date_planned" />
@@ -32,7 +32,6 @@
      <record id="action_plan_sale_order" model="ir.actions.act_window">
         <field name="name">Plan Sale Order</field>
         <field name="res_model">sale.order.make.plan</field>
-        <field name="view_type">form</field>
         <field name="view_mode">form</field>
         <field name="view_id" ref="view_plan_sale_order" />
         <field name="target">new</field>

From 4a3dbb32d218de4101d1d1c5b637f62411e63461 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Sat, 31 Oct 2020 13:39:30 -0700
Subject: [PATCH 20/21] [MIG] sale_planner: to Odoo 14.0

---
 sale_planner/__manifest__.py              |  2 +-
 sale_planner/security/ir.model.access.csv |  2 ++
 sale_planner/wizard/order_planner.py      | 13 +++++++------
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/sale_planner/__manifest__.py b/sale_planner/__manifest__.py
index 9619a669..cce9a189 100644
--- a/sale_planner/__manifest__.py
+++ b/sale_planner/__manifest__.py
@@ -1,7 +1,7 @@
 {
     'name': 'Sale Order Planner',
     'summary': 'Plans order dates and warehouses.',
-    'version': '13.0.1.0.0',
+    'version': '14.0.1.0.0',
     'author': "Hibou Corp.",
     'category': 'Sale',
     'license': 'AGPL-3',
diff --git a/sale_planner/security/ir.model.access.csv b/sale_planner/security/ir.model.access.csv
index 76f4df22..57dffffb 100644
--- a/sale_planner/security/ir.model.access.csv
+++ b/sale_planner/security/ir.model.access.csv
@@ -1,2 +1,4 @@
 id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_sale_order_make_plan,access_sale_order_make_plan,model_sale_order_make_plan,base.group_user,1,1,1,1
+access_sale_order_planning_option,access_sale_order_planning_option,model_sale_order_planning_option,base.group_user,1,1,1,1
 access_sale_order_planning_policy,access_sale_order_planning_policy,model_sale_order_planning_policy,base.group_user,1,1,1,1
\ No newline at end of file
diff --git a/sale_planner/wizard/order_planner.py b/sale_planner/wizard/order_planner.py
index 8d664ce1..01ef8b62 100644
--- a/sale_planner/wizard/order_planner.py
+++ b/sale_planner/wizard/order_planner.py
@@ -13,7 +13,8 @@ except ImportError:
     _logger.warn('module "uszipcode" cannot be loaded, falling back to Google API')
     SearchEngine = None
 
-from odoo import api, fields, models, tools
+from odoo import api, fields, models
+from odoo.tools.safe_eval import safe_eval
 
 
 class FakeCollection():
@@ -300,7 +301,7 @@ class SaleOrderMakePlan(models.TransientModel):
 
         if domain:
             if not isinstance(domain, (list, tuple)):
-                domain = tools.safe_eval(domain)
+                domain = safe_eval(domain)
         else:
             domain = []
             if 'allowed_company_ids' in self.env.context:
@@ -311,7 +312,7 @@ class SaleOrderMakePlan(models.TransientModel):
 
         irconfig_parameter = self.env['ir.config_parameter'].sudo()
         if irconfig_parameter.get_param('sale.order.planner.warehouse_domain'):
-            domain.extend(tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.warehouse_domain')))
+            domain.extend(safe_eval(irconfig_parameter.get_param('sale.order.planner.warehouse_domain')))
 
         return warehouse.search(domain)
 
@@ -322,7 +323,7 @@ class SaleOrderMakePlan(models.TransientModel):
 
         if domain:
             if not isinstance(domain, (list, tuple)):
-                domain = tools.safe_eval(domain)
+                domain = safe_eval(domain)
         else:
             domain = []
 
@@ -332,7 +333,7 @@ class SaleOrderMakePlan(models.TransientModel):
 
         irconfig_parameter = self.env['ir.config_parameter'].sudo()
         if irconfig_parameter.get_param('sale.order.planner.carrier_domain'):
-            domain.extend(tools.safe_eval(irconfig_parameter.get_param('sale.order.planner.carrier_domain')))
+            domain.extend(safe_eval(irconfig_parameter.get_param('sale.order.planner.carrier_domain')))
 
         return Carrier.search(domain)
 
@@ -660,7 +661,7 @@ class SaleOrderMakePlan(models.TransientModel):
         for line in product_lines:
             policy = line.product_id.product_tmpl_id.get_planning_policy()
             if policy and policy.carrier_filter_id:
-                domain.extend(tools.safe_eval(policy.carrier_filter_id.domain))
+                domain.extend(safe_eval(policy.carrier_filter_id.domain))
         carriers = self.get_shipping_carriers(base_option.get('carrier_id'), domain=domain)
         _logger.info('generate_shipping_options:: base_option: ' + str(base_option) + ' order_fake: ' + str(order_fake) + ' carriers: ' + str(carriers))
 

From 0ee1926887edef36c4b1fc0c12497af64c7ada89 Mon Sep 17 00:00:00 2001
From: Jared Kipe <jared@hibou.io>
Date: Wed, 6 Oct 2021 08:54:21 -0700
Subject: [PATCH 21/21] [MIG] sale_planner: to Odoo 15.0

---
 sale_planner/__manifest__.py    | 2 +-
 sale_planner/models/resource.py | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/sale_planner/__manifest__.py b/sale_planner/__manifest__.py
index cce9a189..c87d85f2 100644
--- a/sale_planner/__manifest__.py
+++ b/sale_planner/__manifest__.py
@@ -1,7 +1,7 @@
 {
     'name': 'Sale Order Planner',
     'summary': 'Plans order dates and warehouses.',
-    'version': '14.0.1.0.0',
+    'version': '15.0.1.0.0',
     'author': "Hibou Corp.",
     'category': 'Sale',
     'license': 'AGPL-3',
diff --git a/sale_planner/models/resource.py b/sale_planner/models/resource.py
index 07556ce7..de7895aa 100644
--- a/sale_planner/models/resource.py
+++ b/sale_planner/models/resource.py
@@ -15,16 +15,16 @@ class ResourceCalendar(models.Model):
 
         # which method to use for retrieving intervals
         if compute_leaves:
-            get_intervals = partial(self._work_intervals, domain=domain)
+            get_intervals = partial(self._work_intervals_batch, domain=domain)
         else:
-            get_intervals = self._attendance_intervals
+            get_intervals = self._attendance_intervals_batch
 
         if days >= 0:
             found = set()
             delta = timedelta(days=14)
             for n in range(100):
                 dt = day_dt + delta * n
-                for start, stop, meta in get_intervals(dt, dt + delta):
+                for start, stop, meta in get_intervals(dt, dt + delta)[False]:
                     found.add(start.date())
                     if len(found) >= days:
                         return revert(stop)
@@ -36,7 +36,7 @@ class ResourceCalendar(models.Model):
             delta = timedelta(days=14)
             for n in range(100):
                 dt = day_dt - delta * n
-                for start, stop, meta in reversed(get_intervals(dt - delta, dt)):
+                for start, stop, meta in reversed(get_intervals(dt - delta, dt))[False]:
                     found.add(start.date())
                     if len(found) == days:
                         return revert(start)