'date_due': fields.date('Due Date', readonly=True, states={'draft':[('readonly',False)]}, select=True,
help="If you use payment terms, the due date will be computed automatically at the generation "\
"of accounting entries. The payment term may compute several due dates, for example 50% now and 50% in one month, but if you want to force a due date, make sure that the payment term is not set on the invoice. If you keep the payment term and the due date empty, it means direct payment."),
- 'partner_id': fields.many2one('res.partner', 'Partner', change_default=True, readonly=True, required=True, states={'draft':[('readonly',False)]}),
+ 'partner_id': fields.many2one('res.partner', 'Partner', change_default=True, readonly=True, required=True, states={'draft':[('readonly',False)]}, track_visibility='always'),
- 'payment_term': fields.many2one('account.payment.term', 'Payment Term',readonly=True, states={'draft':[('readonly',False)]},
+ 'payment_term': fields.many2one('account.payment.term', 'Payment Terms',readonly=True, states={'draft':[('readonly',False)]},
help="If you use payment terms, the due date will be computed automatically at the generation "\
"of accounting entries. If you keep the payment term and the due date empty, it means direct payment. "\
"The payment term may compute several due dates, for example 50% now, 50% in one month."),
'tax_line': fields.one2many('account.invoice.tax', 'invoice_id', 'Tax Lines', readonly=True, states={'draft':[('readonly',False)]}),
'move_id': fields.many2one('account.move', 'Journal Entry', readonly=True, select=1, ondelete='restrict', help="Link to the automatically generated Journal Items."),
- 'amount_untaxed': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Untaxed', track_visibility='always',
- 'amount_untaxed': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Subtotal',
++ 'amount_untaxed': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Subtotal', track_visibility='always',
store={
'account.invoice': (lambda self, cr, uid, ids, c={}: ids, ['invoice_line'], 20),
'account.invoice.tax': (_get_invoice_tax, None, 20),
context = {}
sale_ids = self.pool.get('sale.order').search(cr,uid,[('project_id','=',context.get('search_default_project_id',False)),('partner_id','in',context.get('search_default_partner_id',False))])
names = [record.name for record in self.browse(cr, uid, ids, context=context)]
-- name = _('Sale Order Lines of %s') % ','.join(names)
++ name = _('Sales Order Lines of %s') % ','.join(names)
return {
'type': 'ir.actions.act_window',
'name': name,
_columns = {
'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of analytic distribution"),
'analytic_id': fields.many2one('account.analytic.account', 'Analytic Account'),
-- 'product_id': fields.many2one('product.product', 'Product', ondelete='cascade', help="Select a product which will use analytic account specified in analytic default (e.g. create new customer invoice or Sale order if we select this product, it will automatically take this as an analytic account)"),
-- 'partner_id': fields.many2one('res.partner', 'Partner', ondelete='cascade', help="Select a partner which will use analytic account specified in analytic default (e.g. create new customer invoice or Sale order if we select this partner, it will automatically take this as an analytic account)"),
++ 'product_id': fields.many2one('product.product', 'Product', ondelete='cascade', help="Select a product which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this product, it will automatically take this as an analytic account)"),
++ 'partner_id': fields.many2one('res.partner', 'Partner', ondelete='cascade', help="Select a partner which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this partner, it will automatically take this as an analytic account)"),
'user_id': fields.many2one('res.users', 'User', ondelete='cascade', help="Select a user which will use analytic account specified in analytic default."),
-- 'company_id': fields.many2one('res.company', 'Company', ondelete='cascade', help="Select a company which will use analytic account specified in analytic default (e.g. create new customer invoice or Sale order if we select this company, it will automatically take this as an analytic account)"),
++ 'company_id': fields.many2one('res.company', 'Company', ondelete='cascade', help="Select a company which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this company, it will automatically take this as an analytic account)"),
'date_start': fields.date('Start Date', help="Default start date for this Analytic Account."),
'date_stop': fields.date('End Date', help="Default end date for this Analytic Account."),
}
<dl>
<dt><a href="#" class="oe_import_toggle">
How can I import a one2many relationship (e.g. several
-- Order Lines of a Sale Order)?</a></dt>
++ Order Lines of a Sales Order)?</a></dt>
<dd>
<p>If you want to import sales order having several
order lines; for each order line, you need to reserve
to each method.
</p><p>
These methods allows to automaticaly compute the delivery price
-- according to your settings; on the sale order (based on the
++ according to your settings; on the sales order (based on the
quotation) or the invoice (based on the delivery orders).
</p>
</field>
"""Event Registration"""
_name= 'event.registration'
_description = __doc__
- _inherit = ['ir.needaction_mixin','mail.thread']
+ _inherit = ['mail.thread', 'ir.needaction_mixin']
_columns = {
'id': fields.integer('ID'),
-- 'origin': fields.char('Source Document', size=124,readonly=True,help="Name of the sale order which create the registration"),
++ 'origin': fields.char('Source Document', size=124,readonly=True,help="Reference of the sales order which created the registration"),
'nb_register': fields.integer('Number of Participants', required=True, readonly=True, states={'draft': [('readonly', False)]}),
'event_id': fields.many2one('event.event', 'Event', required=True, readonly=True, states={'draft': [('readonly', False)]}),
'partner_id': fields.many2one('res.partner', 'Partner', states={'done': [('readonly', True)]}),
class product(osv.osv):
_inherit = 'product.product'
_columns = {
-- 'event_ok': fields.boolean('Event Subscription', help='Determine if a product needs to create automatically an event registration at the confirmation of a sale order line.'),
-- 'event_type_id': fields.many2one('event.type', 'Type of Event', help='Select event types so when we use this product in Sale order line, it will filter events of this type only.'),
++ 'event_ok': fields.boolean('Event Subscription', help='Determine if a product needs to create automatically an event registration at the confirmation of a sales order line.'),
++ 'event_type_id': fields.many2one('event.type', 'Type of Event', help='Select event types so when we use this product in sales order lines, it will filter events of this type only.'),
}
def onchange_event_ok(self, cr, uid, ids, event_ok, context=None):
def button_confirm(self, cr, uid, ids, context=None):
'''
-- create registration with sale order
++ create registration with sales order
'''
registration_obj = self.pool.get('event.registration')
sale_obj = self.pool.get('sale.order')
'event_id': order_line.event_id.id,
}
registration_id = registration_obj.create(cr, uid, dic, context=context)
-- message = _("The registration %s has been created from the Sale Order %s.") % (registration_id, order_line.order_id.name)
++ message = _("The registration %s has been created from the Sales Order %s.") % (registration_id, order_line.order_id.name)
registration_obj.message_post(cr, uid, [registration_id], body=message, context=context)
return super(sale_order_line, self).button_confirm(cr, uid, ids, context=context)
'amount_invoiced': fields.function(_invoiced_calc, string='Invoiced Amount',
help="Total invoiced"),
'to_invoice': fields.many2one('hr_timesheet_invoice.factor', 'Timesheet Invoicing Ratio',
-- help="You usually invoice 100% of the timesheets. But if you mix fixed price and timesheet invoicing, you may use another ratio. For instance, if you do a 20% advance invoice (fixed price, based on a sale order), you should invoice the rest on timesheet with a 80% ratio."),
++ help="You usually invoice 100% of the timesheets. But if you mix fixed price and timesheet invoicing, you may use another ratio. For instance, if you do a 20% advance invoice (fixed price, based on a sales order), you should invoice the rest on timesheet with a 80% ratio."),
}
_defaults = {
'pricelist_id': lambda self, cr, uid, ctx: ctx.get('pricelist_id', False),
Define specific property groups that can be assigned to your
bill of materials and sales orders. Properties allows OpenERP
to automatically select the right bill of materials according
-- to properties selected in the sale order by salesperson.
++ to properties selected in the sales order by salesperson.
</p><p>
For instance, in the property group "Warranty", you an have
two properties: 1 year warranty, 3 years warranty. Depending
-- on the propoerties selected in the sale order, OpenERP will
++ on the propoerties selected in the sales order, OpenERP will
schedule a production using the matching bill of materials.
</p>
</field>
materials for manufacturing a product when you have different
ways of building the same product. You can assign several
properties to each bill of materials. When a salesperson
-- creates a sale order, they can relate it to several properties
++ creates a sales order, they can relate it to several properties
and OpenERP will automatically select the BoM to use according
the needs.
</p>
<field name="code" string="Reference"/>
<field name="type"/>
<p colspan="2" class="oe_grey" attrs="{'invisible': [('type','=','normal')]}">
-- When processing a sale order for this product, the delivery order
++ When processing a sales order for this product, the delivery order
will contain the raw materials, instead of the finished product.
</p>
<field name="company_id" groups="base.group_multi_company" widget="selection"/>
that will define the required raw materials."""),
'group_mrp_properties': fields.boolean("Allow several bill of materials per products using properties",
implied_group='product.group_mrp_properties',
-- help="""The selection of the right Bill of Material to use will depend on the properties specified on the sale order and the Bill of Material."""),
++ help="""The selection of the right Bill of Material to use will depend on the properties specified on the sales order and the Bill of Material."""),
'module_product_manufacturer': fields.boolean("Define manufacturers on products ",
help="""This allows you to define the following for a product:
* Manufacturer
<li>kind: the kind of document on which the payment form is rendered (translated to user language, e.g. "Invoice")</li>
<li>currency: the currency record in which the document is issued (e.g. currency.name could be EUR)</li>
<li>amount: the total amount to pay, as a float</li>
-- <li>object: the document on which the payment form is rendered (usually an invoice or sale order record)</li>
++ <li>object: the document on which the payment form is rendered (usually an invoice or sales order record)</li>
<li>quote(): a method to quote special string character to make them suitable for inclusion in a URL</li>
<li>cr: the current database cursor</li>
<li>uid: the current user id</li>
<!--Email template -->
<record id="email_template_edi_sale" model="email.template">
-- <field name="name">Sale Order - Send by Email (Portal)</field>
++ <field name="name">Sales Order - Send by Email (Portal)</field>
<field name="email_from">${object.user_id.email or ''}</field>
<field name="subject">${object.company_id.name} ${object.state in ('draft', 'sent') and 'Quotation' or 'Order'} (Ref ${object.name or 'n/a' })</field>
<field name="email_recipients">${object.partner_invoice_id.id}</field>
</record>
</data>
--</openerp>
++</openerp>
<field name="view_mode">tree,form</field>
<field name="search_view_id" ref="sale.view_sales_order_filter"/>
<field name="context">{"search_default_sales":1}</field>
-- <field name="help">We haven't sent you any sale order.</field>
++ <field name="help">We haven't sent you any sales order.</field>
</record>
<record id="portal_action_invoices" model="ir.actions.act_window">
<record id="node_quotation" model="process.node">
<field name="name">Quotation</field>
-- <field name="note">Quotations are sale orders in draft mode</field>
-- <field name="model_id" model="ir.model" search="[('name', '=', 'Sale Order')]"></field>
++ <field name="note">Quotations are sales orders in draft mode</field>
++ <field name="model_id" model="ir.model" search="[('name', '=', 'Sales Order')]"></field>
<field name="menu_id" model="ir.ui.menu" search="[('name', '=', 'My Quotations')]"></field>
<field name="kind">state</field>
<field name="model_states">object.state == 'draft'</field>
</record>
<record id="node_sale_order" model="process.node">
-- <field name="name">Sale Order</field>
++ <field name="name">Sales Order</field>
<field name="note">Manages the delivery in invoicing process</field>
-- <field name="model_id" model="ir.model" search="[('name', '=', 'Sale Order')]"></field>
++ <field name="model_id" model="ir.model" search="[('name', '=', 'Sales Order')]"></field>
<field name="menu_id" model="ir.ui.menu" search="[('name', '=', 'All Sales Order')]"></field>
<field name="kind">state</field>
<field name="model_states">object.state == 'manual'</field>
<record id="node_invoice_on_sale" model="process.node">
<field name="name">Invoice</field>
-- <field name="note">In case you invoiced on Sale Order</field>
++ <field name="note">In case you invoiced on Sales Order</field>
<field name="model_id" model="ir.model" search="[('name', '=', 'Invoice')]"></field>
<field name="menu_id" model="ir.ui.menu" search="[('name', '=', 'Invoices')]"></field>
<field name="kind">state</field>
<record id="node_condition_invoice_on_order" model="process.condition">
<field name="name">Invoice on order</field>
-- <field name="model_id" model="ir.model" search="[('name', '=', 'Sale Order')]"></field>
++ <field name="model_id" model="ir.model" search="[('name', '=', 'Sales Order')]"></field>
<field name="model_states">object.order_policy != 'picking'</field>
<field name="node_id" ref="node_invoice_on_sale"/>
</record>
<record id="node_condition_invoice_on_delivery" model="process.condition">
<field name="name">Invoice on delivery</field>
-- <field name="model_id" model="ir.model" search="[('name', '=', 'Sale Order')]"></field>
++ <field name="model_id" model="ir.model" search="[('name', '=', 'Sales Order')]"></field>
<field name="model_states">object.order_policy == 'picking'</field>
<field name="node_id" ref="node_invoice_on_delivery"/>
</record>
<field name="menu_id" ref="sale.menu_sale_order"/>
<field name="model_id" ref="sale.model_sale_order"/>
<field eval=""""subflow"""" name="kind"/>
-- <field eval=""""Sale Order Task"""" name="name"/>
-- <field eval=""""In case you sell services on sale order"""" name="note"/>
++ <field eval=""""Sales Order Task"""" name="name"/>
++ <field eval=""""In case you sell services on sales order"""" name="note"/>
<field name="subflow_id" ref="sale.process_process_salesprocess0"/>
<field name="process_id" ref="project.process_process_tasksprocess0"/>
<field eval=""""object.state=='draft'"""" name="model_states"/>
_inherit = "project.task"
_columns = {
'procurement_id': fields.many2one('procurement.order', 'Procurement', ondelete='set null'),
-- 'sale_line_id': fields.related('procurement_id', 'sale_line_id', type='many2one', relation='sale.order.line', store=True, string='Sale Order Line'),
++ 'sale_line_id': fields.related('procurement_id', 'sale_line_id', type='many2one', relation='sale.order.line', store=True, string='Sales Order Line'),
}
def _validate_subflows(self, cr, uid, ids):
<p attrs="{'invisible': ['|','|',('type','<>','service'),('procure_method','<>','make_to_order'),('supply_method','<>','produce')]}">
When you sell this service to a customer, <b>a task</b> will be
created to follow up the job to do. This task will appear
-- in the project related to the contract of the sale order.
++ in the project related to the contract of the sales order.
</p>
</group>
</field>
_inherit = "procurement.order"
_columns = {
'task_id': fields.many2one('project.task', 'Task'),
-- 'sale_line_id': fields.many2one('sale.order.line', 'Sale order line')
++ 'sale_line_id': fields.many2one('sale.order.line', 'Sales order line')
}
def action_check_finished(self, cr, uid, ids):
project_project = self.pool.get('project.project')
project = procurement.product_id.project_id
if not project and procurement.sale_line_id:
-- # find the project corresponding to the analytic account of the sale order
++ # find the project corresponding to the analytic account of the sales order
account = procurement.sale_line_id.order_id.project_id
project_ids = project_project.search(cr, uid, [('analytic_account_id', '=', account.id)])
projects = project_project.browse(cr, uid, project_ids, context=context)
<field eval=""""subflow"""" name="kind"/>
<field eval=""""Trigger Invoice"""" name="name"/>
<field name="subflow_id" ref="account.process_process_invoiceprocess0"/>
-- <field eval=""""Trigger invoices from sale order lines"""" name="note"/>
++ <field eval=""""Trigger invoices from sales order lines"""" name="note"/>
<field name="process_id" ref="project.process_process_tasksprocess0"/>
<field eval=""""object.state=='paid'"""" name="model_states"/>
<field eval="0" name="flow_start"/>
<record id="process_transition_packinginvoice0" model="process.transition">
<field eval="[(6,0,[])]" name="transition_ids"/>
<field eval=""""From a Pick list"""" name="name"/>
-- <field eval=""""A Pick list generates an invoice. Depending on the Invoicing control of the sale order, the invoice is based on delivered or on ordered quantities."""" name="note"/>
++ <field eval=""""A Pick list generates an invoice. Depending on the Invoicing control of the sales order, the invoice is based on delivered or on ordered quantities."""" name="note"/>
<field model="process.node" name="target_node_id" ref="account.process_node_draftinvoices0"/>
<field model="process.node" name="source_node_id" ref="process_node_packinginvoice0"/>
</record>
_columns = {
'name': fields.char('Order Reference', size=64, required=True, select=True, help="Unique number of the purchase order, computed automatically when the purchase order is created."),
'origin': fields.char('Source Document', size=64,
-- help="Reference of the document that generated this purchase order request; a sale order or an internal procurement request."
++ help="Reference of the document that generated this purchase order request; a sales order or an internal procurement request."
),
'partner_ref': fields.char('Supplier Reference', states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]}, size=64,
-- help="Reference of the sale order or quotation sent by your supplier. It's mainly used to do the matching when you receive the products as this reference is usually written on the delivery order sent by your supplier."),
++ help="Reference of the sales order or quotation sent by your supplier. It's mainly used to do the matching when you receive the products as this reference is usually written on the delivery order sent by your supplier."),
'date_order':fields.date('Order Date', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}, select=True, help="Date on which this document has been created."),
'date_approve':fields.date('Date Approved', readonly=1, select=True, help="Date on which purchase order has been approved"),
- 'partner_id':fields.many2one('res.partner', 'Supplier', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]}, change_default=True),
+ 'partner_id':fields.many2one('res.partner', 'Supplier', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]},
+ change_default=True, track_visibility='always'),
'dest_address_id':fields.many2one('res.partner', 'Customer Address (Direct Delivery)',
states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]},
help="Put an address if you want to deliver directly from the supplier to the customer. " \
def view_invoice(self, cr, uid, ids, context=None):
'''
-- This function returns an action that display existing invoices of given sale order ids. It can either be a in a list or in a form view, if there is only one invoice to show.
++ This function returns an action that display existing invoices of given sales order ids. It can either be a in a list or in a form view, if there is only one invoice to show.
'''
mod_obj = self.pool.get('ir.model.data')
wizard_obj = self.pool.get('purchase.order.line_invoice')
<field name="name">Create invoices</field>
<field name="model">purchase.order.line_invoice</field>
<field name="arch" type="xml">
-- <form string="Select an Open Sale Order" version="7.0">
++ <form string="Select an Open Sales Order" version="7.0">
<group>
<label string="Do you want to generate the supplier invoices?"/>
</group>
<!--Email template -->
<record id="email_template_edi_sale" model="email.template">
-- <field name="name">Sale Order - Send by Email</field>
++ <field name="name">Sales Order - Send by Email</field>
<field name="email_from">${object.user_id.email or ''}</field>
<field name="subject">${object.company_id.name} ${object.state in ('draft', 'sent') and 'Quotation' or 'Order'} (Ref ${object.name or 'n/a' })</field>
<field name="email_recipients">${object.partner_invoice_id.id}</field>
<?xml version="1.0"?>
--<document filename="Sale Order.pdf">
-- <template title="Sale Order" author="OpenERP S.A.(sales@openerp.com)" allowSplitting="20">
++<document filename="Sales Order.pdf">
++ <template title="Sales Order" author="OpenERP S.A.(sales@openerp.com)" allowSplitting="20">
<pageTemplate id="first">
<frame id="first" x1="15.0" y1="42.0" width="539" height="758"/>
</pageTemplate>
_inherit = 'sale.config.settings'
_columns = {
-- 'group_invoice_so_lines': fields.boolean('Generate invoices based on the sale order lines',
++ 'group_invoice_so_lines': fields.boolean('Generate invoices based on the sales order lines',
implied_group='sale.group_invoice_so_lines',
-- help="To allow your salesman to make invoices for sale order lines using the menu 'Lines to Invoice'."),
++ help="To allow your salesman to make invoices for sales order lines using the menu 'Lines to Invoice'."),
'timesheet': fields.boolean('Prepare invoices based on timesheets',
help = """For modifying account analytic view to show important data to project manager of services companies.
You can also view the report of account analytic summary user-wise as well as month wise.
'group_uom':fields.boolean("Allow using different units of measures",
implied_group='product.group_uom',
help="""Allows you to select and maintain different units of measure for products."""),
-- 'group_discount_per_so_line': fields.boolean("Allow setting a discount on the sale order lines",
++ 'group_discount_per_so_line': fields.boolean("Allow setting a discount on the sales order lines",
implied_group='sale.group_discount_per_so_line',
-- help="Allows you to apply some discount per sale order line."),
++ help="Allows you to apply some discount per sales order line."),
'module_warning': fields.boolean("Allow configuring alerts by customer or products",
help="""Allow to configure notification on products and trigger them when a user wants to sale a given product or a given customer.
Example: Product: this product is deprecated, do not purchase more than 5.
('manual', 'Sale to Invoice'),
('invoice_except', 'Invoice Exception'),
('done', 'Done'),
- ], 'Status', readonly=True, help="Gives the status of the quotation or sales order. \nThe exception status is automatically set when a cancel operation occurs in the processing of a document linked to the sale order. \nThe 'Waiting Schedule' status is set when the invoice is confirmed but waiting for the scheduler to run on the order date.", select=True),
+ ], 'Status', readonly=True, track_visibility='onchange',
- help="Gives the status of the quotation or sales order. \nThe exception status is automatically set when a cancel operation occurs in the processing of a document linked to the sale order. \nThe 'Waiting Schedule' status is set when the invoice is confirmed but waiting for the scheduler to run on the order date.", select=True),
++ help="Gives the status of the quotation or sales order. \nThe exception status is automatically set when a cancel operation occurs in the processing of a document linked to the sales order. \nThe 'Waiting Schedule' status is set when the invoice is confirmed but waiting for the scheduler to run on the order date.", select=True),
'date_order': fields.date('Date', required=True, readonly=True, select=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}),
'create_date': fields.datetime('Creation Date', readonly=True, select=True, help="Date on which sales order is created."),
'date_confirm': fields.date('Confirmation Date', readonly=True, select=True, help="Date on which sales order is confirmed."),
'invoiced': fields.function(_invoiced, string='Paid',
fnct_search=_invoiced_search, type='boolean', help="It indicates that an invoice has been paid."),
'invoice_exists': fields.function(_invoice_exists, string='Invoiced',
-- fnct_search=_invoiced_search, type='boolean', help="It indicates that sale order has at least one invoice."),
++ fnct_search=_invoiced_search, type='boolean', help="It indicates that sales order has at least one invoice."),
'note': fields.text('Terms and conditions'),
- 'amount_untaxed': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Untaxed Amount',
- store = {
+ 'amount_untaxed': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Untaxed Amount',
+ store={
'sale.order': (lambda self, cr, uid, ids, c={}: ids, ['order_line'], 10),
'sale.order.line': (_get_order, ['price_unit', 'tax_id', 'discount', 'product_uom_qty'], 10),
},
},
multi='sums', help="The total amount."),
-- 'invoice_quantity': fields.selection([('order', 'Ordered Quantities')], 'Invoice on', help="The sale order will automatically create the invoice proposition (draft invoice).", required=True, readonly=True, states={'draft': [('readonly', False)]}),
++ 'invoice_quantity': fields.selection([('order', 'Ordered Quantities')], 'Invoice on', help="The sales order will automatically create the invoice proposition (draft invoice).", required=True, readonly=True, states={'draft': [('readonly', False)]}),
'payment_term': fields.many2one('account.payment.term', 'Payment Term'),
'fiscal_position': fields.many2one('account.fiscal.position', 'Fiscal Position'),
'company_id': fields.related('shop_id','company_id',type='many2one',relation='res.company',string='Company',store=True,readonly=True)
if s['state'] in ['draft', 'cancel']:
unlink_ids.append(s['id'])
else:
-- raise osv.except_osv(_('Invalid Action!'), _('In order to delete a confirmed sale order, you must cancel it before !'))
++ raise osv.except_osv(_('Invalid Action!'), _('In order to delete a confirmed sales order, you must cancel it before !'))
return osv.osv.unlink(self, cr, uid, unlink_ids, context=context)
def _prepare_invoice(self, cr, uid, order, lines, context=None):
"""Prepare the dict of values to create the new invoice for a
-- sale order. This method may be overridden to implement custom
++ sales order. This method may be overridden to implement custom
invoice generation (making sure to call super() to establish
a clean extension chain).
def print_quotation(self, cr, uid, ids, context=None):
'''
-- This function prints the sale order and mark it as sent, so that we can see more easily the next step of the workflow
++ This function prints the sales order and mark it as sent, so that we can see more easily the next step of the workflow
'''
assert len(ids) == 1, 'This option should only be used for a single id at a time'
wf_service = netsvc.LocalService("workflow")
return {'type': 'ir.actions.report.xml', 'report_name': 'sale.order', 'datas': datas, 'nodestroy': True}
def manual_invoice(self, cr, uid, ids, context=None):
-- """ create invoices for the given sale orders (ids), and open the form
++ """ create invoices for the given sales orders (ids), and open the form
view of one of the newly created invoices
"""
mod_obj = self.pool.get('ir.model.data')
wf_service = netsvc.LocalService("workflow")
-- # create invoices through the sale orders' workflow
++ # create invoices through the sales orders' workflow
inv_ids0 = set(inv.id for sale in self.browse(cr, uid, ids, context) for inv in sale.invoice_ids)
for id in ids:
wf_service.trg_validate(uid, 'sale.order', id, 'manual_invoice', cr)
def action_view_invoice(self, cr, uid, ids, context=None):
'''
-- This function returns an action that display existing invoices of given sale order ids. It can either be a in a list or in a form view, if there is only one invoice to show.
++ This function returns an action that display existing invoices of given sales order ids. It can either be a in a list or in a form view, if there is only one invoice to show.
'''
mod_obj = self.pool.get('ir.model.data')
act_obj = self.pool.get('ir.actions.act_window')
wf_service = netsvc.LocalService('workflow')
wf_service.trg_validate(uid, 'sale.order', ids[0], 'order_confirm', cr)
-- # redisplay the record as a sale order
++ # redisplay the record as a sales order
view_ref = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'sale', 'view_order_form')
view_id = view_ref and view_ref[1] or False,
return {
context = context or {}
for o in self.browse(cr, uid, ids):
if not o.order_line:
-- raise osv.except_osv(_('Error!'),_('You cannot confirm a sale order which has no line.'))
++ raise osv.except_osv(_('Error!'),_('You cannot confirm a sales order which has no line.'))
noprod = self.test_no_product(cr, uid, o, context)
if (o.order_policy == 'manual') or noprod:
self.write(cr, uid, [o.id], {'state': 'manual', 'date_confirm': fields.date.context_today(self, cr, uid, context=context)})
def _prepare_order_line_invoice_line(self, cr, uid, line, account_id=False, context=None):
"""Prepare the dict of values to create the new invoice line for a
-- sale order line. This method may be overridden to implement custom
++ sales order line. This method may be overridden to implement custom
invoice generation (making sure to call super() to establish
a clean extension chain).
def button_cancel(self, cr, uid, ids, context=None):
for line in self.browse(cr, uid, ids, context=context):
if line.invoiced:
-- raise osv.except_osv(_('Invalid Action!'), _('You cannot cancel a sale order line that has already been invoiced.'))
++ raise osv.except_osv(_('Invalid Action!'), _('You cannot cancel a sales order line that has already been invoiced.'))
return self.write(cr, uid, ids, {'state': 'cancel'})
def button_confirm(self, cr, uid, ids, context=None):
<field name="body"><![CDATA[<p>This application lets you create and send quotations and process your sales orders; from delivery to invoicing.</p>
<p>If you need to manage your sales pipeline (leads, opportunities, phonecalls), the <i>CRM</i> application may be useful. Use the Settings menu to install it.</p>]]></field>
</record>
+
+ <!-- Sale-related subtypes for messaging / Chatter -->
+ <record id="mt_order_sent" model="mail.message.subtype">
+ <field name="name">Quotation send</field>
+ <field name="res_model">sale.order</field>
+ <field name="description">Quotation send</field>
+ </record>
+ <record id="mt_order_confirmed" model="mail.message.subtype">
- <field name="name">Sale Order Confirmed</field>
++ <field name="name">Sales Order Confirmed</field>
+ <field name="res_model">sale.order</field>
+ <field name="description">Quotation confirmed</field>
+ </record>
+
</data>
</openerp>
<p class="oe_view_nocontent_create">
Click to define a new sale shop.
</p><p>
-- Each quotation or sale order must be linked to a shop. The
++ Each quotation or sales order must be linked to a shop. The
shop also defines the warehouse from which the products will be
delivered for each particular sales.
</p>
<field name="model">sale.order.line</field>
<field name="arch" type="xml">
<search string="Search Sales Order">
-- <filter icon="terp-dolar_ok!" string="To Invoice" domain="[('invoiced','<>', 1),('state','=','done')]" help="Sale Order Lines ready to be invoiced"/>
++ <filter icon="terp-dolar_ok!" string="To Invoice" domain="[('invoiced','<>', 1),('state','=','done')]" help="Sales Order Lines ready to be invoiced"/>
<separator/>
<filter string="My Sales Order Lines" icon="terp-personnal" domain="[('salesman_id','=',uid)]" help="Sales Order Lines related to a Sales Order of mine"/>
<field name="order_id"/>
<field name="model">sale.order.line</field>
<field name="arch" type="xml">
<search string="Search Uninvoiced Lines">
-- <filter icon="terp-gtk-go-back-rtl" string="To Do" domain="[('state','=','confirmed')]" name="sale order" help="Confirmed sale order lines, not yet delivered"/>
-- <filter icon="terp-dialog-close" string="Done" domain="[('state','=','done')]" name="sale_order_done" help="Sale order lines done"/>
-- <filter icon="terp-accessories-archiver" string="Shipped" domain="[('state','=','done')]" name="unshipped" help="Sale Order Lines that are in 'done' state"/>
++ <filter icon="terp-gtk-go-back-rtl" string="To Do" domain="[('state','=','confirmed')]" name="sale order" help="Confirmed sales order lines, not yet delivered"/>
++ <filter icon="terp-dialog-close" string="Done" domain="[('state','=','done')]" name="sale_order_done" help="Sales order lines done"/>
++ <filter icon="terp-accessories-archiver" string="Shipped" domain="[('state','=','done')]" name="unshipped" help="Sales Order Lines that are in 'done' state"/>
<separator/>
-- <filter icon="terp-dolar_ok!" string="Uninvoiced" name="uninvoiced" domain="[('invoiced','<>', 1),('state','<>','draft'),('state','<>','cancel')]" help="Sale Order Lines that are confirmed, done or in exception state and haven't yet been invoiced"/>
++ <filter icon="terp-dolar_ok!" string="Uninvoiced" name="uninvoiced" domain="[('invoiced','<>', 1),('state','<>','draft'),('state','<>','cancel')]" help="Sales Order Lines that are confirmed, done or in exception state and haven't yet been invoiced"/>
<separator/>
<filter string="My Sales Order Lines" icon="terp-personal" domain="[('salesman_id','=',uid)]" help="My Sales Order Lines"/>
<field name="order_id"/>
</record>
<record id="group_invoice_so_lines" model="res.groups">
-- <field name="name">Enable Invoicing Sale order lines</field>
++ <field name="name">Enable Invoicing Sales order lines</field>
<field name="category_id" ref="base.module_category_hidden"/>
</record>
<!-- Multi - Company Rules -->
<record model="ir.rule" id="sale_order_comp_rule">
-- <field name="name">Sale Order multi-company</field>
++ <field name="name">Sales Order multi-company</field>
<field name="model_id" ref="model_sale_order"/>
<field name="global" eval="True"/>
<field name="domain_force">['|',('company_id','=',False),('company_id','child_of',[user.company_id.id])]</field>
</record>
<record model="ir.rule" id="sale_order_line_comp_rule">
-- <field name="name">Sale Order Line multi-company</field>
++ <field name="name">Sales Order Line multi-company</field>
<field name="model_id" ref="model_sale_order_line"/>
<field name="global" eval="True"/>
<field name="domain_force">['|',('company_id','=',False),('company_id','child_of',[user.company_id.id])]</field>
<field name="arch" type="xml">
<form string="Create invoices" version="7.0">
<p class="oe_grey">
-- All items in these order lines will be invoiced. You can also invoice a percentage of the sale order
-- or a fixed price (for advances) directly from the sale order form if you prefer.
++ All items in these order lines will be invoiced. You can also invoice a percentage of the sales order
++ or a fixed price (for advances) directly from the sales order form if you prefer.
</p>
<footer>
<button name="make_invoices" string="Create & View Invoice" type="object"
_columns = {
'advance_payment_method':fields.selection(
-- [('all', 'Invoice the whole sale order'), ('percentage','Percentage'), ('fixed','Fixed price (deposit)'),
++ [('all', 'Invoice the whole sales order'), ('percentage','Percentage'), ('fixed','Fixed price (deposit)'),
('lines', 'Some order lines')],
'What do you want to invoice?', required=True,
help="""Use All to create the final invoice.
Use Percentage to invoice a percentage of the total amount.
Use Fixed Price to invoice a specific amound in advance.
-- Use Some Order Lines to invoice a selection of the sale order lines."""),
++ Use Some Order Lines to invoice a selection of the sales order lines."""),
'qtty': fields.float('Quantity', digits=(16, 2), required=True),
'product_id': fields.many2one('product.product', 'Advance Product',
help="""Select a product of type service which is called 'Advance Product'.
sale_obj = self.pool.get('sale.order')
inv_id = inv_obj.create(cr, uid, inv_values, context=context)
inv_obj.button_reset_taxes(cr, uid, [inv_id], context=context)
-- # add the invoice to the sale order's invoices
++ # add the invoice to the sales order's invoices
sale_obj.write(cr, uid, sale_id, {'invoice_ids': [(4, inv_id)]}, context=context)
return inv_id
def create_invoices(self, cr, uid, ids, context=None):
-- """ create invoices for the active sale orders """
++ """ create invoices for the active sales orders """
sale_obj = self.pool.get('sale.order')
act_window = self.pool.get('ir.actions.act_window')
wizard = self.browse(cr, uid, ids[0], context)
sale_ids = context.get('active_ids', [])
if wizard.advance_payment_method == 'all':
-- # create the final invoices of the active sale orders
++ # create the final invoices of the active sales orders
res = sale_obj.manual_invoice(cr, uid, sale_ids, context)
if context.get('open_invoices', False):
return res
return {'type': 'ir.actions.act_window_close'}
if wizard.advance_payment_method == 'lines':
-- # open the list view of sale order lines to invoice
++ # open the list view of sales order lines to invoice
res = act_window.for_xml_id(cr, uid, 'sale', 'action_order_line_tree2', context)
res['context'] = {
'search_default_uninvoiced': 1,
<field name="name">Invoice Order</field>
<field name="model">sale.advance.payment.inv</field>
<field name="arch" type="xml">
-- <form string="Invoice Sale Order" version="7.0">
++ <form string="Invoice Sales Order" version="7.0">
<p class="oe_grey">
Select how you want to invoice this order. This
will create a draft invoice that can be modified
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<openerp>
+ <data noupdate="1">
+
+ <!-- Salesteam-related subtypes for messaging / Chatter -->
+ <record id="mt_salesteam_order_sent" model="mail.message.subtype">
+ <field name="name">Quotation Send</field>
+ <field name="res_model">crm.case.section</field>
+ <field name="parent_id" eval="ref('sale.mt_order_sent')"/>
+ <field name="relation_field">section_id</field>
+ </record>
+ <record id="mt_salesteam_order_confirmed" model="mail.message.subtype">
- <field name="name">Sale Order Confirmed</field>
++ <field name="name">Sales Order Confirmed</field>
+ <field name="res_model">crm.case.section</field>
+ <field name="parent_id" eval="ref('sale.mt_order_confirmed')"/>
+ <field name="relation_field">section_id</field>
+ </record>
+
+ </data>
+</openerp>
_columns = {
'shop_id': fields.many2one('sale.shop', 'Shop', required=True),
'partner_id': fields.many2one('res.partner', 'Customer', required=True, domain=[('customer','=',True)]),
-- 'close': fields.boolean('Mark Won', help='Check this to close the opportunity after having created the sale order.'),
++ 'close': fields.boolean('Mark Won', help='Check this to close the opportunity after having created the sales order.'),
}
_defaults = {
'shop_id': _get_shop_id,
Add additional date information to the sales order.
===================================================
--You can add the following additional dates to a sale order:
-------------------------------------------------------------
++You can add the following additional dates to a sales order:
++------------------------------------------------------------
* Requested Date
* Commitment Date
* Effective Date
_columns = {
'group_sale_delivery_address': fields.boolean("Allow a different address for delivery and invoicing ",
implied_group='sale.group_delivery_invoice_address',
-- help="Allows you to specify different delivery and invoice addresses on a sale order."),
++ help="Allows you to specify different delivery and invoice addresses on a sales order."),
'group_invoice_deli_orders': fields.boolean('Generate invoices after and based on delivery orders',
implied_group='sale_stock.group_invoice_deli_orders',
help="To allow your salesman to make invoices for Delivery Orders using the menu 'Deliveries to Invoice'."),
'The default invoicing method is', default_model='sale.order',
help="You can generate invoices based on sales orders or based on shippings."),
'module_delivery': fields.boolean('Allow adding shipping costs',
-- help ="""Allows you to add delivery methods in sale orders and delivery orders.
++ help ="""Allows you to add delivery methods in sales orders and delivery orders.
You can define your own carrier and delivery grids for prices.
This installs the module delivery."""),
'default_picking_policy' : fields.boolean("Deliver all at once when all products are available.",
help = "Sales order by default will be configured to deliver all products at once instead of delivering each product when it is available. This may have an impact on the shipping price."),
'group_mrp_properties': fields.boolean('Product properties on order lines',
implied_group='sale.group_mrp_properties',
-- help="Allows you to tag sale order lines with properties."),
++ help="Allows you to tag sales order lines with properties."),
'group_multiple_shops': fields.boolean("Manage multiple shops",
implied_group='stock.group_locations',
help="This allows to configure and use multiple shops."),
'shipped': fields.boolean('Delivered', readonly=True, help="It indicates that the sales order has been delivered. This field is updated only after the scheduler(s) have been launched."),
'picked_rate': fields.function(_picked_rate, string='Picked', type='float'),
'invoice_quantity': fields.selection([('order', 'Ordered Quantities'), ('procurement', 'Shipped Quantities')], 'Invoice on',
-- help="The sale order will automatically create the invoice proposition (draft invoice).\
++ help="The sales order will automatically create the invoice proposition (draft invoice).\
You have to choose if you want your invoice based on ordered ", required=True, readonly=True, states={'draft': [('readonly', False)]}),
}
_defaults = {
def action_view_delivery(self, cr, uid, ids, context=None):
'''
-- This function returns an action that display existing delivery orders of given sale order ids. It can either be a in a list or in a form view, if there is only one delivery order to show.
++ This function returns an action that display existing delivery orders of given sales order ids. It can either be a in a list or in a form view, if there is only one delivery order to show.
'''
mod_obj = self.pool.get('ir.model.data')
act_obj = self.pool.get('ir.actions.act_window')
# FIXME: deals with potentially cancelled shipments, seems broken (specially if shipment has production lot)
"""
Define ship_recreate for process after shipping exception
-- param order: sale order to which the order lines belong
-- param line: sale order line records to procure
++ param order: sales order to which the order lines belong
++ param line: sales order line records to procure
param move_id: the ID of stock move
param proc_id: the ID of procurement
"""
return date_planned
def _create_pickings_and_procurements(self, cr, uid, order, order_lines, picking_id=False, context=None):
-- """Create the required procurements to supply sale order lines, also connecting
++ """Create the required procurements to supply sales order lines, also connecting
the procurements to appropriate stock moves in order to bring the goods to the
-- sale order's requested location.
++ sales order's requested location.
If ``picking_id`` is provided, the stock moves will be added to it, otherwise
a standard outgoing picking will be created to wrap the stock moves, as returned
multiple stock pickings may override this method and call ``super()`` with
different subsets of ``order_lines`` and/or preset ``picking_id`` values.
-- :param browse_record order: sale order to which the order lines belong
-- :param list(browse_record) order_lines: sale order line records to procure
++ :param browse_record order: sales order to which the order lines belong
++ :param list(browse_record) order_lines: sales order line records to procure
:param int picking_id: optional ID of a stock picking to which the created stock moves
will be added. A new picking will be created if ommitted.
:return: True
def _get_partner_to_invoice(self, cr, uid, picking, context=None):
""" Inherit the original function of the 'stock' module
-- We select the partner of the sale order as the partner of the customer invoice
++ We select the partner of the sales order as the partner of the customer invoice
"""
if picking.sale_id:
return picking.sale_id.partner_id
def _prepare_invoice(self, cr, uid, picking, partner, inv_type, journal_id, context=None):
""" Inherit the original function of the 'stock' module in order to override some
-- values if the picking has been generated by a sale order
++ values if the picking has been generated by a sales order
"""
invoice_vals = super(stock_picking, self)._prepare_invoice(cr, uid, picking, partner, inv_type, journal_id, context=context)
if picking.sale_id:
'group_uom': fields.boolean("Manage different units of measure for products",
implied_group='product.group_uom',
help="""Allows you to select and maintain different units of measure for products."""),
-- 'group_uos': fields.boolean("Invoice products in a different unit of measure than the sale order",
++ 'group_uos': fields.boolean("Invoice products in a different unit of measure than the sales order",
implied_group='product.group_uos',
help="""Allows you to sell units of a product, but invoice based on a different unit of measure.
For instance, you can sell pieces of meat that you invoice based on their weight."""),
# name of new picking according to its type
new_pick_name = seq_obj.get(cr, uid, 'stock.picking.' + ptype)
pickid = self._create_chained_picking(cr, uid, new_pick_name, picking, ptype, todo, context=context)
-- # Need to check name of old picking because it always considers picking as "OUT" when created from Sale Order
++ # Need to check name of old picking because it always considers picking as "OUT" when created from Sales Order
old_ptype = location_obj.picking_type_get(cr, uid, picking.move_lines[0].location_id, picking.move_lines[0].location_dest_id)
if old_ptype != picking.type:
old_pick_name = seq_obj.get(cr, uid, 'stock.picking.' + old_ptype)
class res_partner(osv.osv):
_inherit = 'res.partner'
_columns = {
-- 'sale_warn' : fields.selection(WARNING_MESSAGE, 'Sale Order', help=WARNING_HELP, required=True),
-- 'sale_warn_msg' : fields.text('Message for Sale Order'),
++ 'sale_warn' : fields.selection(WARNING_MESSAGE, 'Sales Order', help=WARNING_HELP, required=True),
++ 'sale_warn_msg' : fields.text('Message for Sales Order'),
'purchase_warn' : fields.selection(WARNING_MESSAGE, 'Purchase Order', help=WARNING_HELP, required=True),
'purchase_warn_msg' : fields.text('Message for Purchase Order'),
'picking_warn' : fields.selection(WARNING_MESSAGE, 'Stock Picking', help=WARNING_HELP, required=True),
class product_product(osv.osv):
_inherit = 'product.product'
_columns = {
-- 'sale_line_warn' : fields.selection(WARNING_MESSAGE,'Sale Order Line', help=WARNING_HELP, required=True),
-- 'sale_line_warn_msg' : fields.text('Message for Sale Order Line'),
++ 'sale_line_warn' : fields.selection(WARNING_MESSAGE,'Sales Order Line', help=WARNING_HELP, required=True),
++ 'sale_line_warn_msg' : fields.text('Message for Sales Order Line'),
'purchase_line_warn' : fields.selection(WARNING_MESSAGE,'Purchase Order Line', help=WARNING_HELP, required=True),
'purchase_line_warn_msg' : fields.text('Message for Purchase Order Line'),
}
<notebook position="inside">
<page string="Warnings">
<group colspan="2" col="2">
-- <separator string="Warning on the Sale Order" colspan="4"/>
++ <separator string="Warning on the Sales Order" colspan="4"/>
<field name="sale_warn" nolabel="1" />
<field name="sale_warn_msg" colspan="3" nolabel="1"
attrs="{'required':[('sale_warn','!=','no-message')],'readonly':[('sale_warn','=','no-message')]}"/>
projects / odoo / odoo.git / commitdiff