If you want make sure the invoice due date should contain due date ,entered by user when there is no payment term defined in Odoo you have to customized .py file in account.invoice module.For example you can see below code .

import itertools
from lxml import etree
from openerp import SUPERUSER_ID
from openerp import models, fields, api, _
from openerp.exceptions import except_orm, Warning, RedirectWarning
import openerp.addons.decimal_precision as dp
import time
import math

class account_invoice(models.Model): 
    _inherit = 'account.invoice'

    @api.one
    @api.depends('invoice_line.price_subtotal', 'tax_line.amount','discount',)
    def _compute_amount(self):
        self.amount_untaxed = (sum(line.price_subtotal for line in self.invoice_line))
        self.amount_tax = sum(line.amount for line in self.tax_line)
        self.amount_total = round(self.amount_untaxed + self.amount_tax) 
        if self.discount:
        	self.amount_total -= round((self.amount_untaxed + self.amount_tax)*self.discount/100)
        #self.discount = self.amount_untaxed * self.discount / 100 

    @api.model
    def line_get_convert(self, line, part, date):
        return {
            'date_maturity': line.get('date_maturity', False),
            'partner_id': part,
            'name': line['name'][:64],
            'date': date,
            'debit': line['price']>0 and line['price'],
            'credit': line['price']<0 and -line['price'],
            'account_id': line['account_id'],
            'analytic_lines': line.get('analytic_lines', []),
            'amount_currency': round(line['price']>0 and abs(round(line.get('amount_currency', False)))) or -abs(round(line.get('amount_currency', False))),
            'currency_id': line.get('currency_id', False),
            'tax_code_id': line.get('tax_code_id', False),
            'tax_amount': line.get('tax_amount', False),
            'ref': line.get('ref', False),
            'quantity': line.get('quantity',1.00),
            'product_id': line.get('product_id', False),
            'product_uom_id': line.get('uos_id', False),
            'analytic_account_id': line.get('account_analytic_id', False),
        }
        
        
    @api.one
    @api.depends(
        'state', 'currency_id', 'invoice_line.price_subtotal',
        'move_id.line_id.account_id.type',
        'move_id.line_id.amount_residual',
        # Fixes the fact that move_id.line_id.amount_residual, being not stored and old API, doesn't trigger recomputation
        'move_id.line_id.reconcile_id',
        'move_id.line_id.amount_residual_currency',
        'move_id.line_id.currency_id',
        'move_id.line_id.reconcile_partial_id.line_partial_ids.invoice.type',
    )
    # An invoice's residual amount is the sum of its unreconciled move lines and,
    # for partially reconciled move lines, their residual amount divided by the
    # number of times this reconciliation is used in an invoice (so we split
    # the residual amount between all invoice)
    def _compute_residual(self):
        self.residual = 0.0
        # Each partial reconciliation is considered only once for each invoice it appears into,
        # and its residual amount is divided by this number of invoices
        partial_reconciliations_done = []
        for line in self.sudo().move_id.line_id:
            if line.account_id.type not in ('receivable', 'payable'):
                continue
            if line.reconcile_partial_id and line.reconcile_partial_id.id in partial_reconciliations_done:
                continue
            # Get the correct line residual amount
            if line.currency_id == self.currency_id:
                line_amount = line.amount_residual_currency if line.currency_id else line.amount_residual
            else:
                from_currency = line.company_id.currency_id.with_context(date=line.date)
                line_amount = from_currency.compute(line.amount_residual, self.currency_id)
            # For partially reconciled lines, split the residual amount
            if line.reconcile_partial_id:
                partial_reconciliation_invoices = set()
                for pline in line.reconcile_partial_id.line_partial_ids:
                    if pline.invoice and self.type == pline.invoice.type:
                        partial_reconciliation_invoices.update([pline.invoice.id])
                line_amount = self.currency_id.round(line_amount / len(partial_reconciliation_invoices))
                partial_reconciliations_done.append(line.reconcile_partial_id.id)
            self.residual += round(line_amount)
        self.residual = max(self.residual, 0.0)
#          @@@@@@ Fields @@@@@@
    
    discount = fields.Float('Discount(%)', readonly=True, states={'draft': [('readonly', False)]})
    customer_code = fields.Char('Customer Code', readonly=True, states={'draft': [('readonly', False)]})
    total_cash = fields.Float('Total Paid (Cash)', readonly=True, states={'draft': [('readonly', False)]})
    total_cheque = fields.Float('Total Paid (Cheque)', readonly=True, states={'draft': [('readonly', False)]})
    check_amount = fields.Float('Cheque Amount', readonly=True, states={'draft': [('readonly', False)]})
    cheque_number = fields.Char('Cheque Number', readonly=True, states={'draft': [('readonly', False)]})
    bank = fields.Char('Bank', readonly=True, states={'draft': [('readonly', False)]})
    branch = fields.Char('Branch', readonly=True, states={'draft': [('readonly', False)]})
    balance_amount = fields.Float('Balance Amount', readonly=True, states={'draft': [('readonly', False)]})
    date_hijri  = fields.Date('Date Hijri', readonly=True, states={'draft': [('readonly', False)]})
    cheque = fields.Boolean('Pay By Cheque', readonly=True, states={'draft': [('readonly', False)]})
    chq_date = fields.Date('Cheque Date', readonly=True, states={'draft': [('readonly', False)]})
    new_name = fields.Char('Name', readonly=True, states={'draft': [('readonly', False)]})
    salesperson_code = fields.Char('Salesperson Code', readonly=True, states={'draft': [('readonly', False)]})
    card = fields.Boolean('Pay By Card')
    total_paid_by_card = fields.Float('Total Paid (Card)')
    card_number = fields.Char('Card Number')
    bank = fields.Char('Bank')
    expiry_date = fields.Date('Expiry Date')
    date_invoice = fields.Date(string='Invoice Date', readonly=False, states={'draft': [('readonly', False)]}, index=True,
        help="Keep empty to use the current date", copy=False)
       

    
    @api.multi
    def onchange_payment_term_date_invoice(self, payment_term_id, date_invoice):
        if not date_invoice:
            date_invoice = fields.Date.context_today(self)
        if not payment_term_id:
            # To make sure the invoice due date should contain due date which is
            # entered by user when there is no payment term defined
            return {'value': {'date_due': self.date_due or date_invoice}}
        pterm = self.env['account.payment.term'].browse(payment_term_id)
        pterm_list = pterm.compute(value=1, date_ref=date_invoice)[0]
        if pterm_list:
            return {'value': {'date_due': max(line[0] for line in pterm_list)}}
        else:
            raise except_orm(_('Insufficient Data!'),
                _('The payment term of supplier does not have a payment term line.'))
    
    @api.multi
    def invoice_print(self):
        """ Print the invoice and mark it as sent, so that we can see more
            easily the next step of the workflow
        """
        assert len(self) == 1, 'This option should only be used for a single id at a time.'
        self.sent = True
        return self.env['report'].get_action(self, 'al_bander.report_invoices')

    @api.multi
    def payment_print(self):
        """ Print the invoice and mark it as sent, so that we can see more
            easily the next step of the workflow
        """
        assert len(self) == 1, 'This option should only be used for a single id at a time.'
        self.sent = True
        return self.env['report'].get_action(self, 'al_bander.payment_slip')


    @api.multi
    def invoice_pay(self):
        print "self",self
        ctx = dict(self._context)
        for rec in self:
            ctx['cheque_number'] = rec.cheque_number
            ctx['bank'] = rec.bank
            ctx['branch'] = rec.branch
            ctx['chq_date'] = rec.chq_date
            if rec.total_cash:
                ctx['journal_type'] = 'cash'
                ctx['amount'] = rec.total_cash
                self.with_context(ctx).make_payment_of_invoice()
            if rec.total_cheque:
                ctx['journal_type'] = 'bank'
                ctx['amount'] = rec.total_cheque 
                self.with_context(ctx).make_payment_of_invoice()
        return True

    def make_payment_of_invoice(self, cr, uid, ids, context):
#         logger = netsvc.Logger()
         if not context:
             context = {}
         ctx = context.copy()
         inv_obj = self.browse(cr,uid,ids[0])
         voucher_id = False
         invoice_number = inv_obj.number
         voucher_pool = self.pool.get('account.voucher')
         journal_pool = self.pool.get('account.journal')
         period_obj = self.pool.get('account.period')
         if ctx.get('journal_type',''):
            bank_journal_ids=  journal_pool.search(cr, uid, [('type', '=', context.get('journal_type'))])
         else:
            bank_journal_ids = journal_pool.search(cr, uid, [('type', '=', 'bank')])
         if not len(bank_journal_ids):
             return True
         ctx.update({
                 'default_partner_id': inv_obj.partner_id.id,
                 'default_amount': inv_obj.amount_total,
                 'default_name':inv_obj.name,
                 'close_after_process': True,
                 'invoice_type':inv_obj.type,
                 'invoice_id':inv_obj.id,
                 'journal_id':bank_journal_ids[0],
                 'default_type': inv_obj.type in ('out_invoice','out_refund') and 'receipt' or 'payment'
         })
         if inv_obj.type in ('out_refund','in_refund'):
             ctx.update({'default_amount':-inv_obj.amount_total})
         tax_id = self._get_tax(cr, uid, context)

         account_data = self.get_accounts(cr,uid,inv_obj.partner_id.id,bank_journal_ids[0])
         date = time.strftime('%Y-%m-%d')
         voucher_data = {
                 'period_id': inv_obj.period_id.id,
                 'account_id': account_data['value']['account_id'],
                 'partner_id': inv_obj.partner_id.id,
                 'journal_id':bank_journal_ids[0],
                 'currency_id': inv_obj.currency_id.id,
                 'reference': inv_obj.name,
                 'amount': ctx.get('amount',0.0),
                 'type':account_data['value']['type'],
                 'state': 'draft',
                 'pay_now': 'pay_later',
                 'name': '',
                 'cheque_number' : ctx.get('cheque_number',0.0),
                 'bank' : ctx.get('bank', ''),
                 'branch' : ctx.get('branch', ''),
                 'chq_date' : ctx.get('chq_date', time.strftime('%Y-%m-%d')),
                 'date': time.strftime('%Y-%m-%d'),
                 'company_id': self.pool.get('res.company')._company_default_get(cr, uid, 'account.voucher',context=None),
                 'tax_id': tax_id,
                 'payment_option': 'without_writeoff',
                 'comment': _('Write-Off'),
             }
         if inv_obj.type in ('out_refund','in_refund'):
             voucher_data.update({'amount':-inv_obj.amount_total})
         if not voucher_data['period_id']:
             period_ids = period_obj.find(cr, uid, inv_obj.date_invoice, context=context)
             period_id = period_ids and period_ids[0] or False
             voucher_data.update({'period_id':period_id})
#         logger.notifyChannel("warning", netsvc.LOG_WARNING,"voucher_data '%s'." % voucher_data)
         voucher_id = voucher_pool.create(cr,uid,voucher_data)
#         logger.notifyChannel("warning", netsvc.LOG_WARNING,"voucher_id '%s'." % voucher_id)

         if voucher_id:
             #Get all the Documents for a Partner
             if inv_obj.type in ('out_refund','in_refund'):
                 amount=-inv_obj.amount_total
                 res = voucher_pool.onchange_partner_id(cr, uid, [voucher_id], inv_obj.partner_id.id, bank_journal_ids[0], amount, inv_obj.currency_id.id, account_data['value']['type'], date, context=context)
             else:
                 res = voucher_pool.onchange_partner_id(cr, uid, [voucher_id], inv_obj.partner_id.id, bank_journal_ids[0], inv_obj.amount_total, inv_obj.currency_id.id, account_data['value']['type'], date, context=context)
             #Loop through each document and Pay only selected documents and create a single receipt
             for line_data in res['value']['line_cr_ids']:
                 if line_data['name'] in [invoice_number]:
                     voucher_lines = {
                         'move_line_id': line_data['move_line_id'],
                         'amount': ctx.get('amount',0.0),
                         'name': line_data['name'],
                         'amount_unreconciled': line_data['amount_unreconciled'],
                         'type': line_data['type'],
                         'amount_original': line_data['amount_original'],
                         'account_id': line_data['account_id'],
                         'voucher_id': voucher_id,
                     }
#                     logger.notifyChannel("warning", netsvc.LOG_WARNING,"voucher_lines '%s'." % voucher_lines)
                     voucher_line_id = self.pool.get('account.voucher.line').create(cr,uid,voucher_lines)
#                     logger.notifyChannel("warning", netsvc.LOG_WARNING,"voucher_line_id '%s'." % voucher_line_id)
             for line_data in res['value']['line_dr_ids']:
                 if line_data['name'] in [invoice_number]:
                     voucher_lines = {
                         'move_line_id': line_data['move_line_id'],
                         'amount': ctx.get('amount',0.0),
                         'name': line_data['name'],
                         'amount_unreconciled': line_data['amount_unreconciled'],
                         'type': line_data['type'],
                         'amount_original': line_data['amount_original'],
                         'account_id': line_data['account_id'],
                         'voucher_id': voucher_id,
                     }
#                     logger.notifyChannel("warning", netsvc.LOG_WARNING,"voucher_lines '%s'." % voucher_lines)
                     voucher_line_id = self.pool.get('account.voucher.line').create(cr,uid,voucher_lines)
#                     logger.notifyChannel("warning", netsvc.LOG_WARNING,"voucher_line_id '%s'." % voucher_line_id)

             #Add Journal Entries
             voucher_pool.action_move_line_create(cr,uid,[voucher_id])

         return voucher_id


    def get_accounts(self, cr, uid, partner_id=False, journal_id=False, context=None):

        """price
        Returns a dict that contains new values and context

        @param partner_id: latest value from user input for field partner_id
        @param args: other arguments
        @param context: context arguments, like lang, time zone

        @return: Returns a dict which contains new values, and context
        """
        default = {
            'value':{},
        }
        if not partner_id or not journal_id:
            return default

        partner_pool = self.pool.get('res.partner')
        journal_pool = self.pool.get('account.journal')

        journal = journal_pool.browse(cr, uid, journal_id, context=context)
        partner = partner_pool.browse(cr, uid, partner_id, context=context)
        account_id = False
        tr_type = False
        if journal.type in ('sale','sale_refund'):
            account_id = partner.property_account_receivable.id
            tr_type = 'sale'
        elif journal.type in ('purchase', 'purchase_refund','expense'):
            account_id = partner.property_account_payable.id
            tr_type = 'purchase'
        else:
            account_id = journal.default_credit_account_id.id or journal.default_debit_account_id.id
            tr_type = 'receipt'

        default['value']['account_id'] = account_id
        default['value']['type'] = tr_type

        return default

    def _get_tax(self, cr, uid, context=None):
        if context is None: context = {}
        journal_pool = self.pool.get('account.journal')
        journal_id = context.get('journal_id', False)
        if not journal_id:
            ttype = context.get('type', 'bank')
            res = journal_pool.search(cr, uid, [('type', '=', ttype)], limit=1)
            if not res:
                return False
            journal_id = res[0]

        if not journal_id:
            return False
        journal = journal_pool.browse(cr, uid, journal_id, context=context)
        account_id = journal.default_credit_account_id or journal.default_debit_account_id
        if account_id and account_id.tax_ids:
            tax_id = account_id.tax_ids[0].id
            return tax_id
        return False


    def onchange_partner_id(self, cr, uid, ids, type, partner_id, date_invoice=False,
            payment_term=False, partner_bank_id=False, company_id=False, context=None):
        print "pssssssssss", partner_id

        partner = self.pool.get('res.partner').browse(cr, uid, partner_id, context=context)

        res =  super(account_invoice, self).onchange_partner_id(cr, uid, ids, type, partner_id, date_invoice, payment_term, partner_bank_id, company_id, context=context) ['value']
        ref = partner.ref
        user_id = partner.user_id
        if ref and user_id:
            res.update({'customer_code': ref or False,
                    'user_id': user_id or False })
        return {'value': res}



class account_invoice_line(models.Model):
    _inherit = 'account.invoice.line'
    

    qty_char = fields.Float('Qty in M. Sqr')

    @api.one
    @api.depends('price_unit', 'qty_char', 'discount', 'invoice_line_tax_id', 'quantity',
        'product_id', 'invoice_id.partner_id', 'invoice_id.currency_id')
    def _compute_price(self):
        price = self.price_unit * (1 - (self.discount or 0.0) / 100.0)
        taxes = self.invoice_line_tax_id.compute_all(price, self.qty_char, product=self.product_id, partner=self.invoice_id.partner_id)
        self.price_subtotal = taxes['total']
        if self.invoice_id:
            self.price_subtotal = self.invoice_id.currency_id.round(self.price_subtotal)


    def on_change_qty_squ(self, cr, uid, ids, qty_char, product  , price_unit=0, discount=0, quantity=0, context=None):
        qty_char = qty_char
        product_obj = self.pool.get('product.product')
        product_obj = product_obj.browse(cr, uid, product, context=context)
        prod_type = product_obj.supp_ref
        squ_meter = product_obj.squ_meter

        price = price_unit
        value = {}
        if prod_type == 'T':
            if qty_char:
                typ = float(qty_char)
                qty = typ / squ_meter
                round = math.ceil(qty)
                new_qty = round * squ_meter
                value['quantity'] = round
            subtotal = (quantity) * (discount)
            value['price_subtotal'] = subtotal
        elif prod_type == 'B':
            if qty_char:
                typ = float(qty_char)
                qty = typ / squ_meter
                round = math.ceil(qty)
                new_qty = round * squ_meter
                value['quantity'] = round
            subtotal = (quantity) * (discount)
            value['price_subtotal'] = subtotal
        else:
            if qty_char:
                typ= float(qty_char)
                value['quantity'] = typ
            subtotal = (quantity) * (discount)
            value['price_subtotal'] = subtotal
            
        return {'value': value}
        
        
    def on_change_qty_squmeter(self, cr, uid, ids, product, qty_char=0,  price_unit=0, discount=0,quantity=0, context=None):
        
        quantity = quantity
        product_obj = self.pool.get('product.product')
        product_obj = product_obj.browse(cr, uid, product, context=context)
        prod_type = product_obj.supp_ref
#	prod_price = product_obj.lst_price
        squ_meter = product_obj.squ_meter

        price = price_unit
        print "pleasssssssss", price
        value = {}
        if prod_type == 'T':
            if quantity:
                print "plssssssssss", quantity
                typ = float(quantity)
                qty = typ * squ_meter
                round = (qty)
                new_qty = round / (squ_meter or 1.00 )
                value['qty_char'] = round
            subtotal = (qty_char) * (discount)
            value['price_subtotal'] = subtotal
            
        else:
            if quantity:
                typ = float(quantity)
                qty = typ * squ_meter
                round = (qty)
                new_qty = round / (squ_meter or 1.00)
                value['qty_char'] = round
            subtotal = (qty_char) * (discount)
            value['price_subtotal'] = subtotal
            
        return {'value': value}

       
   
    def product_id_change(self,cr,uid,ids, product ,uom_id,  qty=0, name='', type='out_invoice',
            partner_id=False, fposition_id=False, price_unit=False, currency_id=False,
            company_id=None,context=None):
        res = super(account_invoice_line, self).product_id_change(cr,uid,ids,product, uom_id, qty, name,type, partner_id, fposition_id,price_unit, currency_id,company_id,context)
        if res['value'].get('name', False):
            name = res['value'].get('name', False)
            name = name.split(" ")
            prod_name=name[0]
            prod_name=prod_name.replace("["," ")
            prod_name=prod_name.replace("]"," ")
            prod_name=prod_name.strip()
            result=res['value'] 
            product_obj=self.pool.get('product.product')
            var=product_obj.search(cr, uid, [('default_code', '=',prod_name)])
            product_obj1 = product_obj.browse(cr, uid, var, context=context)
            prod_type = product_obj1.supp_ref
            prod_price = product_obj1.lst_price
            squ_meter = product_obj1.squ_meter
            subtotal = (qty) * (prod_price)
            result['price_subtotal'] = subtotal
            result['qty_char'] = qty * squ_meter
            return {'value' : result}

        return res

        
    default={
    'discount':0.0,
    }

account_invoice_line() 


class account_move_line(models.Model):
    _inherit='account.move.line'
    
    def _amount_residual(self, cr, uid, ids, field_names, args, context=None):
        """
           This function returns the residual amount on a receivable or payable account.move.line.
           By default, it returns an amount in the currency of this journal entry (maybe different
           of the company currency), but if you pass 'residual_in_company_currency' = True in the
           context then the returned amount will be in company currency.
        """
        res = {}
        if context is None:
            context = {}
        cur_obj = self.pool.get('res.currency')
        for move_line in self.browse(cr, uid, ids, context=context):
            res[move_line.id] = {
                'amount_residual': 0.0,
                'amount_residual_currency': 0.0,
            }

            if move_line.reconcile_id:
                continue
            if not move_line.account_id.reconcile:
                #this function does not suport to be used on move lines not related to a reconcilable account
                continue

            if move_line.currency_id:
                move_line_total = move_line.amount_currency
                sign = move_line.amount_currency < 0 and -1 or 1
            else:
                move_line_total = move_line.debit - move_line.credit
                sign = (move_line.debit - move_line.credit) < 0 and -1 or 1
            line_total_in_company_currency =  move_line.debit - move_line.credit
            context_unreconciled = context.copy()
            if move_line.reconcile_partial_id:
                for payment_line in move_line.reconcile_partial_id.line_partial_ids:
                    if payment_line.id == move_line.id:
                        continue
                    if payment_line.currency_id and move_line.currency_id and payment_line.currency_id.id == move_line.currency_id.id:
                            move_line_total += payment_line.amount_currency
                    else:
                        if move_line.currency_id:
                            context_unreconciled.update({'date': payment_line.date})
                            amount_in_foreign_currency = cur_obj.compute(cr, uid, move_line.company_id.currency_id.id, move_line.currency_id.id, (payment_line.debit - payment_line.credit), round=False, context=context_unreconciled)
                            move_line_total += amount_in_foreign_currency
                        else:
                            move_line_total += (payment_line.debit - payment_line.credit)
                    line_total_in_company_currency += (payment_line.debit - payment_line.credit)

            result = round(move_line_total)
            res[move_line.id]['amount_residual_currency'] =  sign * (move_line.currency_id and self.pool.get('res.currency').round(cr, uid, move_line.currency_id, result) or result)
            res[move_line.id]['amount_residual'] = sign * line_total_in_company_currency
        return res