[MERGE] forward port branch 11.0 up to c5ed372

Author: KangOl

addons/account/report/account_aged_partner_balance.py

@@ -194,7 +194,7 @@ def _get_partner_move_lines(self, account_type, date_from, target_move, period_l
                 values['name'] = _('Unknown Partner')
                 values['trust'] = False
 
-            if at_least_one_amount or self._context.get('include_nullified_amount'):
+            if at_least_one_amount or (self._context.get('include_nullified_amount') and lines[partner['partner_id']]):
                 res.append(values)
 
         return res, total, lines

addons/account/report/account_general_ledger.py

@@ -38,7 +38,7 @@ def _get_account_move_entry(self, accounts, init_balance, sortby, display_accoun
                 init_wheres.append(init_where_clause.strip())
             init_filters = " AND ".join(init_wheres)
             filters = init_filters.replace('account_move_line__move_id', 'm').replace('account_move_line', 'l')
-            sql = ("""SELECT 0 AS lid, l.account_id AS account_id, '' AS ldate, '' AS lcode, NULL AS amount_currency, '' AS lref, 'Initial Balance' AS lname, COALESCE(SUM(l.debit),0.0) AS debit, COALESCE(SUM(l.credit),0.0) AS credit, COALESCE(SUM(l.debit),0) - COALESCE(SUM(l.credit), 0) as balance, '' AS lpartner_id,\
+            sql = ("""SELECT 0 AS lid, l.account_id AS account_id, '' AS ldate, '' AS lcode, 0.0 AS amount_currency, '' AS lref, 'Initial Balance' AS lname, COALESCE(SUM(l.debit),0.0) AS debit, COALESCE(SUM(l.credit),0.0) AS credit, COALESCE(SUM(l.debit),0) - COALESCE(SUM(l.credit), 0) as balance, '' AS lpartner_id,\
                 '' AS move_name, '' AS mmove_id, '' AS currency_code,\
                 NULL AS currency_id,\
                 '' AS invoice_id, '' AS invoice_type, '' AS invoice_number,\

addons/account/tests/test_reconciliation.py

@@ -758,6 +758,63 @@ def test_revert_payment_and_reconcile(self):
         self.assertEqual(reversed_bank_line.full_reconcile_id.id, bank_line.full_reconcile_id.id)
         self.assertEqual(reversed_customer_line.full_reconcile_id.id, customer_line.full_reconcile_id.id)
 
+    def create_invoice_partner(self, type='out_invoice', invoice_amount=50, currency_id=None, partner_id=False):
+        #we create an invoice in given currency
+        invoice = self.account_invoice_model.create({'partner_id': partner_id,
+            'reference_type': 'none',
+            'currency_id': currency_id,
+            'name': type == 'out_invoice' and 'invoice to client' or 'invoice to vendor',
+            'account_id': self.account_rcv.id,
+            'type': type,
+            'date_invoice': time.strftime('%Y') + '-07-01',
+            })
+        self.account_invoice_line_model.create({'product_id': self.product.id,
+            'quantity': 1,
+            'price_unit': invoice_amount,
+            'invoice_id': invoice.id,
+            'name': 'product that cost ' + str(invoice_amount),
+            'account_id': self.env['account.account'].search([('user_type_id', '=', self.env.ref('account.data_account_type_revenue').id)], limit=1).id,
+        })
+
+        #validate invoice
+        invoice.action_invoice_open()
+        return invoice
+
+    def test_aged_report(self):
+        AgedReport = self.env['report.account.report_agedpartnerbalance'].with_context(include_nullified_amount=True)
+        account_type = ['receivable']
+        report_date_to = time.strftime('%Y') + '-07-15'
+        partner = self.env['res.partner'].create({'name': 'AgedPartner'})
+        currency = self.env.user.company_id.currency_id
+
+        invoice = self.create_invoice_partner(currency_id=currency.id, partner_id=partner.id)
+        journal = self.env['account.journal'].create({'name': 'Bank', 'type': 'bank', 'code': 'THE', 'currency_id': currency.id})
+
+        statement = self.make_payment(invoice, journal, 50)
+
+        # Case 1: The invoice and payment are reconciled: Nothing should appear
+        report_lines, total, amls = AgedReport._get_partner_move_lines(account_type, report_date_to, 'posted', 30)
+
+        partner_lines = [line for line in report_lines if line['partner_id'] == partner.id]
+        self.assertEqual(partner_lines, [], 'The aged receivable shouldn\'t have lines at this point')
+        self.assertFalse(partner.id in amls, 'The aged receivable should not have amls either')
+
+        # Case 2: The invoice and payment are not reconciled: we should have one line on the report
+        # and 2 amls
+        invoice.move_id.line_ids.with_context(invoice_id=invoice.id).remove_move_reconcile()
+        report_lines, total, amls = AgedReport._get_partner_move_lines(account_type, report_date_to, 'posted', 30)
+
+        partner_lines = [line for line in report_lines if line['partner_id'] == partner.id]
+        self.assertEqual(partner_lines, [{'trust': 'normal', '1': 0.0, '0': 0.0, 'direction': 0.0, 'partner_id': partner.id, '3': 0.0, 'total': 0.0, 'name': 'AgedPartner', '4': 0.0, '2': 0.0}],
+            'We should have a line in the report for the partner')
+        self.assertEqual(len(amls[partner.id]), 2, 'We should have 2 account move lines for the partner')
+
+        positive_line = [line for line in amls[partner.id] if line['line'].balance > 0]
+        negative_line = [line for line in amls[partner.id] if line['line'].balance < 0]
+
+        self.assertEqual(positive_line[0]['amount'], 50.0, 'The amount of the amls should be 50')
+        self.assertEqual(negative_line[0]['amount'], -50.0, 'The amount of the amls should be -50')
+
     def test_partial_reconcile_currencies_02(self):
         ####
         # Day 1: Invoice Cust/001 to customer (expressed in USD)

addons/account_payment/controllers/payment.py

@@ -17,7 +17,6 @@ def invoice_pay_form(self, acquirer_id, invoice_id, save_token=False, access_tok
         :return html: form containing all values related to the acquirer to
                       redirect customers to the acquirer website """
         success_url = kwargs.get('success_url', '/my')
-        callback_method = kwargs.get('callback_method', '')
 
         invoice_sudo = request.env['account.invoice'].sudo().browse(invoice_id)
         if not invoice_sudo:
@@ -28,17 +27,16 @@ def invoice_pay_form(self, acquirer_id, invoice_id, save_token=False, access_tok
         except:
             return False
 
+        if request.env.user == request.env.ref('base.public_user'):
+            save_token = False # we avoid to create a token for the public user
+
         token = request.env['payment.token'].sudo()  # currently no support of payment tokens
         tx = request.env['payment.transaction'].sudo()._check_or_create_invoice_tx(
             invoice_sudo,
             acquirer,
             payment_token=token,
             tx_type='form_save' if save_token else 'form',
-            add_tx_values={
-                'callback_model_id': request.env['ir.model'].sudo().search([('model', '=', invoice_sudo._name)], limit=1).id,
-                'callback_res_id': invoice_sudo.id,
-                'callback_method': callback_method,
-            })
+        )
 
         # set the transaction id into the session
         request.session['portal_invoice_%s_transaction_id' % invoice_sudo.id] = tx.id
@@ -58,7 +56,6 @@ def invoice_pay_token(self, invoice_id, pm_id=None, **kwargs):
         """ Use a token to perform a s2s transaction """
         error_url = kwargs.get('error_url', '/my')
         success_url = kwargs.get('success_url', '/my')
-        callback_method = kwargs.get('callback_method', '')
         access_token = kwargs.get('access_token')
         params = {}
         if access_token:
@@ -73,7 +70,8 @@ def invoice_pay_token(self, invoice_id, pm_id=None, **kwargs):
             token = request.env['payment.token'].sudo().browse(int(pm_id))
         except (ValueError, TypeError):
             token = False
-        if not token:
+        token_owner = invoice_sudo.partner_id if request.env.user == request.env.ref('base.public_user') else request.env.user.partner_id
+        if not token or token.partner_id != token_owner:
             params['error'] = 'pay_invoice_invalid_token'
             return request.redirect(_build_url_w_params(error_url, params))
 
@@ -83,11 +81,7 @@ def invoice_pay_token(self, invoice_id, pm_id=None, **kwargs):
             token.acquirer_id,
             payment_token=token,
             tx_type='server2server',
-            add_tx_values={
-                'callback_model_id': request.env['ir.model'].sudo().search([('model', '=', invoice_sudo._name)], limit=1).id,
-                'callback_res_id': invoice_sudo.id,
-                'callback_method': callback_method,
-            })
+        )
 
         # set the transaction id into the session
         request.session['portal_invoice_%s_transaction_id' % invoice_sudo.id] = tx.id

addons/account_payment/controllers/portal.py

@@ -9,5 +9,18 @@ class PortalAccount(PortalAccount):
 
     def _invoice_get_page_view_values(self, invoice, access_token, **kwargs):
         values = super(PortalAccount, self)._invoice_get_page_view_values(invoice, access_token, **kwargs)
-        values.update(request.env['payment.acquirer']._get_available_payment_input(invoice.partner_id, invoice.company_id))
+        payment_inputs = request.env['payment.acquirer']._get_available_payment_input(company=invoice.company_id)
+        # if not connected (using public user), the method _get_available_payment_input will return public user tokens
+        is_public_user = request.env.ref('base.public_user') == request.env.user
+        if is_public_user:
+            # we should not display payment tokens owned by the public user
+            payment_inputs.pop('pms', None)
+            token_count = request.env['payment.token'].sudo().search_count([('acquirer_id.company_id', '=', invoice.company_id.id),
+                                                                      ('partner_id', '=', invoice.partner_id.id),
+                                                                    ])
+            values['existing_token'] = token_count > 0
+        values.update(payment_inputs)
+        # if the current user is connected we set partner_id to his partner otherwise we set it as the invoice partner
+        # we do this to force the creation of payment tokens to the correct partner and avoid token linked to the public user
+        values['partner_id'] = invoice.partner_id if is_public_user else request.env.user.partner_id,
         return values

addons/account_payment/views/account_portal_templates.xml

@@ -83,6 +83,11 @@
                     </t>
                 </div>
             </div>
+            <div class="panel-body" t-if="existing_token">
+                <div class="col-md-offset-3 col-md-6">
+                    <i class="fa fa-info"></i> You have credits card registered, you can log-in to be able to use them.
+                </div>
+            </div>
         </xpath>
     </template>
 

addons/barcodes/static/src/js/barcode_parser.js

@@ -18,6 +18,9 @@ var BarcodeParser = Class.extend({
     // only when those data have been loaded
     load: function(){
         var self = this;
+        if (!this.nomenclature_id) {
+            return;
+        }
         var id = this.nomenclature_id[0];
         rpc.query({
                 model: 'barcode.nomenclature',

addons/base_address_extended/__manifest__.py

@@ -16,7 +16,8 @@
 with the street name, the house number, and room number.
         """,
     'data': [
-        'views/base_address_extended.xml'
+        'views/base_address_extended.xml',
+        'data/base_address_extended_data.xml',
     ],
     'depends': ['base'],
 }

addons/base_address_extended/data/base_address_extended_data.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<odoo>
+    <data noupdate="1">
+        <record id="base.nl" model="res.country">
+            <field eval="'%(street_name)s %(street_number)s/%(street_number2)s'" name="street_format" />
+        </record>
+    </data>
+</odoo>

addons/calendar/models/calendar.py

@@ -4,7 +4,7 @@
 
 import babel.dates
 import collections
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, MAXYEAR
 from dateutil import parser
 from dateutil import rrule
 from dateutil.relativedelta import relativedelta
@@ -632,7 +632,7 @@ def todate(date):
                     recurring_date = todate(meeting.recurrent_id_date)
                 rset1.exdate(recurring_date)
             invalidate = True
-        return [d.astimezone(pytz.UTC) if d.tzinfo else d for d in rset1]
+        return [d.astimezone(pytz.UTC) if d.tzinfo else d for d in rset1 if d.year < MAXYEAR]
 
     @api.multi
     def _get_recurrency_end_date(self):
@@ -902,8 +902,8 @@ def _inverse_dates(self):
                 startdate = startdate.astimezone(pytz.utc)  # Convert to UTC
                 meeting.start = fields.Datetime.to_string(startdate)
             else:
-                meeting.start = meeting.start_datetime
-                meeting.stop = meeting.stop_datetime
+                meeting.write({'start': meeting.start_datetime,
+                               'stop': meeting.stop_datetime})
 
     @api.depends('byday', 'recurrency', 'final_date', 'rrule_type', 'month_by', 'interval', 'count', 'end_type', 'mo', 'tu', 'we', 'th', 'fr', 'sa', 'su', 'day', 'week_list')
     def _compute_rrule(self):