考核调整表模块

Domain

Domain 代表记录集的条件表达式。Domain 是定义模型子集的规则集合。每个规则是一个包含名称、操作和值的三元组
规则如下:

(1) Start with the outermost operator and move it to the start of the expression.
"(A operator B)" becomes "operator (A B)"
(2) Repeat step 1 for each sub expression with an operator to move.
"A operator (B operator C)" becomes "operator A (B operator C)" then "operator A (operator B C)"
(3) Remove all brackets.
"A operator (B operator C)" becomes "operator A operator B C"
So for my example:
( A or B ) AND ( C or D or E )
First simplification:
AND ( A or B ) ( C or D or E )
left side
AND ( or A B ) ( C or D or E )
right side outer
AND ( or A B ) ( or C ( D or E ) )
right side inner
AND ( or A B ) ( or C ( or D E ) )
remove brackets
AND or A B or C or D E
In OpenERP domain syntax this would be:
[ '&', '|', (A), (B), '|', (C), '|', (D), (E) ]

例如，下面是Product模型子集的Domain表达式，“单价大于1000且类型为服务”的记录集：

[('product_type', '=', 'service'), ('unit_price', '>', 1000)]

多个规则组合时，默认条件组合方式是AND。逻辑运算符&(AND),|(OR),!(NOT)可以用来显示的组合多个规则。它们在前缀位置使用（操作符在参数之前，而不是中间）。例如下面的Domain表达式，含义是"类型为服务或者单价不介于1000和2000之间"

计算字段和默认值

说明
字段也可以通过计算获得。在这种情况下，字段的值不是直接检索自数据库，而是通过调用模型的方法来实时计算获得。要创建计算字段，需要设置它的compute属性为方法名。这个计算方法通过计算self的每条记录来设置字段的值。

self是一个记录的有序集合，它支持标准的Python集合操作，如len(self)和iter(self)，加上额外的集合操作recs1 + recs2。迭代过程逐个提供self记录，其中每个记录本身是大小为1的集合。你可以通过点记号来访问/分配单个记录上的字段record.name

依赖
计算字段的值通常取决于所在记录行的其它字段的值。ORM层期望开发人员使用depends()装饰器来指定计算方法的依赖性。当某些依赖关系被修改后，ORM层通过给定的依赖关系来触发字段的重新计算。

from odoo import models, fields, api

class ComputedModel(models.Model):
    _name = 'test.computed'

   name = fields.Char(compute='_compute_name')
   value = fields.Integer()

   @api.depends('value')
   def _compute_name(self):        
        for record in self:
           record.name = "Record with value %s" % record.value

默认值
任何字段都可以给出默认值。在字段定义中，添加选项default=x,x可以是Python字面值（bool，int，float，string），也可以是一个有返回值的方法。

name = fields.Char(default="Unknown")
user_id = fields.Many2one('res.users', default=lambda self: self.env.user)

self.env 对象给出了访问请求参数和其他有用的信息：
self.env.cr 或者 self._cr 是数据库游标对象，通常用于查询数据库
self.env.uid 或者 self._uid 是当前用户的数据库ID
self.env.user 是当前用户记录
self.env.ref(xml_id) 返回XML ID对应的记录
self.env[model_name] 返回给定模型的实例

onchange 机制

"onchange"机制为客户端界面提供了一种方法，当用户在字段中填写了值，不需要向数据库保存任何内容，就可以更新表单。例如，假设模型有三个字段amount,unit_price和price，当数量和单价改变时，自动重新计算价格，并在表单界面更新。要实现这个需求，需要定义一个方法，并使用onchange()装饰器，onchange()的参数指定了在那个字段改变时，触发方法。其中self代表表单视图中的记录，你所做的任何更改，self都将立刻反应在表单上。

<field name="amount"/>
<field name="unit_price"/>
<field name="price" readonly="1"/>
# onchange handler
@api.onchange('amount', 'unit_price')
def _onchange_price(self):
    # set auto-changing field
    self.price = self.amount * self.unit_price
    # Can optionally return a warning and domains
    return {
        'warning': {
            'title': "Something bad happened",
            'message': "It was very bad indeed",
        }
    }

模型约束

odoo提供两种方式实现自动验证，python constraints和sql constraints
Python约束通过方法装饰器constraints()来定义，并在记录集上调用这个方法。装饰器参数指定了约束涉及的字段，当涉及的字段中任一发生改变时触发方法执行。如果不满足约束条件，该方法将引发异常：

from odoo.exceptions import ValidationError

@api.constrains('age')
def _check_something(self):
    for record in self:
        if record.age > 20:
            raise ValidationError("Your record is too old: %s" % record.age)
    # all records passed the test, don't return anything

sql限制值唯一

_sql_constraints = [('unique_name', 'unique(name)', 'the name must be unique')]

    @api.constrains('name')
    def _check_xxxx(self):
        pass

定义model.Model的时候必须在权限表中定义权限,才会出来添加按钮

<notebook>
                            <page string="收入">
                                <group>
                                        <group>
                                            <field name="assess_operating_income_month" string="考核营业收入本月数"/>
                                            <field name="operating_income_month" string="报表营业收入本月数"/>
                                            <field name="adjust_item_month" string="调整项目合计本月数"/>
                                        </group>
                                        <group>
                                            <field name="assess_operating_income_year" string="考核营业收入本年累计"/>
                                            <field name="operating_income_year" string="报表营业收入本年累计"/>
                                            <field name="adjust_item_year" string="调整项目合计本年累计"/>
                                        </group>
                                    </group>
                                <field name="operate_id" widget="one2many_list" >
# name是主表中定义one2many的字段值
                                    <tree editable="bottom">
                                        <field name="partner_id" string="公司"
                                       options='{"no_open": True, "no_quick_create":True, "no_create_edit": True}'/>
                                        <field name="month_amount" string="本月数"/>
                                        <field name="year_amount" string="本年累计数"/>
                                        <field name="account_id" string="科目"
                                       options='{"no_open": True, "no_quick_create":True, "no_create_edit": True}'/>
                                        <field name="note" string="备注"/>
                                    </tree>
                                </field>
                            </page>
</notebook>

自动生成跟时间相关的编号

1.建立data文件夹,新建xml文件

<?xml version="1.0" encoding="utf-8"?>
<odoo>
    <data noupdate="1">
        <record id="monomer_statements.monomer_statements" model="ir.sequence">
            <field name="name">monomer_statements</field>
            <field name="code">monomer.statements.create.code</field>
            <field name="prefix">MS%(year)s%(month)s</field>
            <field name="suffix"/>
            <field name="padding">5</field>
        </record>

    </data>
</odoo>

field name=code的值要跟py文件中next_by_code()中的值相同
2.py文件中

name = fields.Char(string='name', required=True, default=lambda self: self._compute_name())

    def _compute_name(self):
        return self.env['ir.sequence'].sudo().next_by_code('monomer.statements.create.code') + '/' + \
               str(self.env.user.company_id.id)

@api.onchange 和 @api.depends

@api.onchange相同模型中的字段
@api.depends不同模型中的字段

@api.one和@api.multi

@api.one

• self是单例实例
• 对于recordset中的每条记录,都调用方法,并将结果列成一个列表
• 没有返回

@api.multi

• self是一个记录集
• 有返回

最好使用@api.multi 和 self.ensure_one(),而不是@api.one

查看报错日志信息

try:
  pass
except Exception as e:
  import traceback
  _logger.info({
    'error': traceback.format_exc()
            })

('child_ids', '=', False)消除末级科目
get_last_period取上一级期间,事先写好的方法,直接用就可以了

重写新建和更新方法

区分vals的格式
增加字典中同一个键的值,说明这个键,否则值会被覆盖
vals[key].append(item)

@api.model
    def create(self, vals):
        vals = self._get_create_amount(vals, monomer_model='monomer.statements.income.line', monomer_field='operate_id')
        vals = self._get_create_amount(vals, monomer_model='monomer.statements.cost.line', monomer_field='cost_id')
        vals = self._get_create_amount(vals, monomer_model='monomer.statements.profit.line', monomer_field='profit_id')
        res = super(MonomerStatements, self).create(vals)
        return res


    @api.multi
    def write(self, vals):
        vals = self._get_last_amount(vals, monomer_model='monomer.statements.income.line', monomer_field='operate_id')
        vals = self._get_last_amount(vals, monomer_model='monomer.statements.cost.line', monomer_field='cost_id')
        vals = self._get_last_amount(vals, monomer_model='monomer.statements.profit.line', monomer_field='profit_id')
        res = super(MonomerStatements, self).write(vals)
        return res

    def _get_create_amount(self, vals, monomer_model, monomer_field):

        if self.period_id or 'period_id' in vals.keys():
            period_id = vals.get('period_id', False)
            period_object = self.env['account.period'].browse(period_id)
            last_period = self.env['account.period'].get_last_period(period_object)
            if last_period:
                last_period_partner = self.env[monomer_model].search([('period_id', '=', last_period.id)])
                last_ids = last_period_partner.mapped('partner_id').ids
                set_last = set(last_ids)
                partner_ids = vals.get(monomer_field, False)
                current_ids = []
                last_result = []
                for i in range(len(partner_ids)) if partner_ids else []:
                    current_ids.append(partner_ids[i][2].get('partner_id', False))
                set_current = set(current_ids)
                sub_result = set_last - set_current
                result = list(sub_result)
                update_partner = self.env[monomer_model].search([('period_id', '=', last_period.id),
                                                                 ('partner_id', 'in', result)])
                result_list = []
                for item in update_partner:
                    update_set = {
                        'partner_id': item.partner_id.id,
                        'year_amount': item.year_amount,
                        'account_id': item.account_id.id,
                        'note': item.note
                    }
                    result_list = [0, False, update_set]
                    last_result.append(result_list)
                for item in last_result:
                    vals[monomer_field].append(item)
                return vals
            else:
                return vals

    def _get_last_amount(self, vals, monomer_model, monomer_field):
        if self.period_id or 'period_id' in vals.keys():
            period_id = vals.get('period_id', False)
            period_object = self.env['account.period'].browse(period_id)
            last_period = self.env['account.period'].get_last_period(period_object)
            if last_period:
                last_period_partner = self.env[monomer_model].search([('period_id', '=', last_period.id)])
                last_ids = last_period_partner.mapped('partner_id').ids
                partner_ids = vals.get(monomer_field, False)
                partner_list = []
                last_result = []
                for i in range(len(partner_ids)) if partner_ids else []:
                    partner_list.append(partner_ids[i][1])
                current_ids = []
                for item in partner_list:
                    partner = self.env[monomer_model].browse(item)
                    current_ids.append(partner.mapped('partner_id').id)
                set_last = set(last_ids)
                set_current = set(current_ids)
                sub_result = set_last - set_current
                result = list(sub_result)
                update_partner = self.env[monomer_model].search([('period_id', '=', last_period.id),
                                                     ('partner_id', 'in', result)])
                for item in update_partner:
                    update_set = (0, 0, {
                        'partner_id': item.partner_id.id,
                        'year_amount': item.year_amount,
                        'account_id': item.account_id.id,
                        'note': item.note
                        })
                    last_result.append(update_set)
                vals.update({
                        monomer_field: last_result
                    })
                return vals
            else:
                return vals