openerp学习笔记 跟踪状态，记录日志，发送消息

跟踪状态基础数据：

kl_qingjd/kl_qingjd_data.xml

<?xml version="1.0"?>
<openerp>
    <data
noupdate="1">

<!-- kl_qingjd-related subtypes
for messaging / Chatter -->
       
<record id="mt_qingjd_confirm"
model="mail.message.subtype">
           
<field
name="name">已提交</field>
           
<field
name="res_model">kl.qingjd</field>
           
<field
name="description">请假申请已提交</field>
       
</record>
        <record
id="mt_qingjd_validate"
model="mail.message.subtype">
           
<field
name="name">已批准</field>
           
<field
name="res_model">kl.qingjd</field>
           
<field
name="description">请假申请已批准</field>
       
</record>
        <record
id="mt_qingjd_refuse"
model="mail.message.subtype">
           
<field
name="name">已拒绝</field>
           
<field
name="res_model">kl.qingjd</field>
           
<field name="default" eval="True"/> <!-- 订阅时，默认激活 -->

            <field
name="description">请假申请已拒绝</field>
       
</record>

</data>
</openerp>

跟踪状态，记录日志，发送消息后台代码：

kl_qingjd/kl_qingjd.py

# -*- encoding: utf-8 -*-
import pooler
import logging
import
netsvc
import tools
logger = netsvc.Logger()
import datetime
import
time
import math
from osv import fields,osv
from
openerp.tools.translate import _  #用于翻译代码中的静态字符串

#假期类型对象
class kl_qingjd_type(osv.osv):
    _name =
"kl.qingjd.type"
    _description =
u"假期类型"
    _order = "num asc, id asc"
   

    #对象字段
    _columns =
{
        'num':
fields.integer(u'序号'),
        'name':
fields.char(u'假期类型', size=64, required=True,
translate=True),
        'notes':
fields.char(u'说明', size=200),
    }
   

    #数据库约束
    _sql_constraints =
[
        ('name_check', "unique(name)",
u"假期类型已经存在且不允许重复."),
    ]
   

kl_qingjd_type()#对象定义结束

#请假单对象
class kl_qingjd(osv.osv):
    _name =
'kl.qingjd'
    _description = u'kl 请假单'
   
_order = "date_from asc, type_id asc"
    _inherit =
['mail.thread'] #继承消息模块，用于发消息
    _track =
{
        'state':
{
           
'kl_qingjd.mt_qingjd_validate': lambda self, cr, uid, obj, ctx=None:
obj['state'] ==
'validate',
           
'kl_qingjd.mt_qingjd_refuse': lambda self, cr, uid, obj, ctx=None: obj['state']
==
'refuse',
           
'kl_qingjd.mt_qingjd_confirm': lambda self, cr, uid, obj, ctx=None: obj['state']
== 'confirm',
        },
#自动发送系统消息，可用于记录日志或在邮件中显示，在邮件中显示时需要定义消息的子类型(kl_qingjd_data.xml)和指定消息相关用户(self.message_subscribe_users)
   
}
   
   
#获取当前用户所属的员工
    def _employee_get(self, cr, uid,
context=None):
        ids =
self.pool.get('hr.employee').search(cr, uid, [('user_id', '=', uid)],
context=context)
        if
ids:
           
return ids[0]
        return
False
   
   
#获取当前用户所属部门的id和名称
    def _get_user_department(self, cr, uid,
context={}):
        obj =
self.pool.get('hr.employee')
        ids
= obj.search(cr, uid, [('user_id','=',uid)])

        res = obj.read(cr, uid, ids,
['id','department_id'], context)
       
return res and res[0]['department_id'] or 0
   

    #检测同一时间段内是否存在相同的请假单，False 是存在，不允许创建
   
def _check_date(self, cr, uid,
ids):
        for rec in self.browse(cr,
uid, ids):
           
search_ids = self.search(cr, uid, [('date_from', '<=', rec.date_to),
('date_to', '>=', rec.date_from), ('employee_id', '=', rec.employee_id.id),
('id', '<>',
rec.id)])
           
if
search_ids:
               
return False
        return
True
   
    # TODO: can be improved using
resource calendar method
   
#计算日期间隔对应的天数
    def _get_number_of_days(self, date_from,
date_to):
        """Returns a float
equals to the timedelta between two dates given as string."""

DATETIME_FORMAT = "%Y-%m-%d
%H:%M:%S"
        from_dt =
datetime.datetime.strptime(date_from,
DATETIME_FORMAT)
        to_dt =
datetime.datetime.strptime(date_to,
DATETIME_FORMAT)
        timedelta = to_dt
- from_dt
        diff_day =
timedelta.days + float(timedelta.seconds) /
86400
        return
diff_day
   
   
#对象字段
    _columns =
{
           
'employee_id': fields.many2one('hr.employee', u"申请人",required=True, select=True,
invisible=False, readonly=True,
states={'draft':[('readonly',False)]}),
           
'department_id':fields.many2one('hr.department', u'申请部门', invisible=False,
readonly=True, states={'draft':[('readonly',False)]}),
#修改职员所属部门后显示原部门
           
#'department_id':fields.related('employee_id', 'department_id', string=u'申请部门',
type='many2one', relation='hr.department', readonly=True, store=True),
#修改职员所属部门后显示新部门
           
'type_id': fields.many2one("kl.qingjd.type", u"假期类型",
required=True,readonly=True,
states={'draft':[('readonly',False)]}),
           
'date_from': fields.datetime(u'起始日期',required=True, readonly=True,
states={'draft':[('readonly',False)]},
select=True),
           
'date_to': fields.datetime(u'结束日期', readonly=True,
states={'draft':[('readonly',False)]}),
           
'days': fields.float(u'天数', digits=(8, 2), readonly=True,
states={'draft':[('readonly',False)]}),
           
'notes': fields.text(u'请假原因',readonly=True,
states={'draft':[('readonly',False)]}),
           
'manager_id': fields.many2one('hr.employee', u'审批人', invisible=False,
readonly=True,
help=u'审批和拒绝时自动记录审批人'),
           
'refuse_notes': fields.char(u'拒绝原因', size=200, invisible=False, readonly=True,
states={'confirm':[('readonly',False)],
'validate':[('readonly',False)]}),
           
'state': fields.selection([('draft', u'草稿'), ('cancel', u'已作废'),('confirm',
u'待审批'), ('refuse', u'已拒绝'), ('validate', u'已审批')], u'状态', readonly=True,
track_visibility='onchange'),
           
'create_uid': fields.many2one('res.users', u"创建用户", invisible=False,
readonly=True),
#需要在记录中读取该字段或者在视图、打印中显示该字段时，对象中必须包含
           
'create_date': fields.datetime(u"创建日期", invisible=True, readonly=True),
#需要在记录中读取该字段或者在视图、打印中显示该字段时，对象中必须包含
         
}
   
   
#字段默认值     
    _defaults = {

                
'state':
'draft',
                
'employee_id':
_employee_get,
                
'department_id': lambda self,cr,uid,context:
self._get_user_department(cr,uid,context),

                
}
  
    #对象约束
   
_constraints =
[
                   
(_check_date, u'您在相同的时间段内不允许创建多张请假单!',
[u'起始日期',u'结束日期']),
                   
]
   
    #数据库约束
   
_sql_constraints = [
       
('date_check', "CHECK (date_from <= date_to)",
u"开始日期必须小于结束日期."),
        ('days_check',
"CHECK (days > 0 )", u"请假天数必须大于 0 ."),
   
]
   
   
#创建，此处取消自动记录创建
    def create(self, cr, uid, values,
context=None):
        """ Override to
avoid automatic logging of creation
"""
        if context is
None:
           
context = {}
        context =
dict(context,
mail_create_nolog=True)
       
return super(kl_qingjd, self).create(cr, uid, values, context=context)

#复制（未知用途）
    def copy(self, cr, uid,
id, default=None, context=None):
       
#if default is None:
       
#    default = {}
       
#if context is None:
       
#    context = {}
       
#default = default.copy()
       
#default['date_from'] = False
       
#default['date_to'] = False
        raise
osv.except_osv(_(u'警告!'),_(u'请假单暂不支持复制功能.'))
       
return super(kl_qingjd, self).copy(cr, uid, id, default,
context=context)
   
   
#写入，可用于校验写入和更改数据的合法性
    def write(self, cr, uid, ids, vals,
context=None):
        return
super(kl_qingjd, self).write(cr, uid, ids, vals,
context=context)
   
   
#删除当前请假单，需要验证请假单的状态
    def unlink(self, cr, uid, ids,
context=None):
        for rec in
self.browse(cr, uid, ids,
context=context):
           
if rec.state not in ['draft', 'cancel', 'confirm',
'refuse']:
               
raise osv.except_osv(_(u'警告!'),_(u'您不能删除以下状态的请假单 %s
.')%(rec.state))
           
#当请假单不是自己创建的时，不能删除
           
if  (rec.create_uid.id != uid):
#此处需要读取创建者ID时，必须在对象中包含create_uid列
               
raise
osv.except_osv(_(u'警告!'),_(u'您只能删除自己创建的单据.'))
       
return super(kl_qingjd, self).unlink(cr, uid, ids,
context)
   
   
#更换员工时自动修改员工所属的部门
    def onchange_employee(self, cr, uid,
ids, employee_id):
        result =
{'value': {'department_id':
False}}
        if
employee_id:
           
employee = self.pool.get('hr.employee').browse(cr, uid,
employee_id)
           
result['value'] = {'department_id':
employee.department_id.id}
        return
result
   
   
#更改起始日期，自动计算请假天数
    def onchange_date_from(self, cr, uid,
ids, date_to, date_from):
       
"""
        If there are no date set for
date_to, automatically set one 8 hours later
than
        the
date_from.
        Also update the
number_of_days.
       
"""
        # date_to has to be greater
than date_from
        if (date_from and
date_to) and (date_from >
date_to):
           
raise osv.except_osv(_(u'警告!'),_(u'开始日期必须小于结束日期.'))

result = {'value': {}}

# No date_to set so far:
automatically compute one 8 hours
later
        if date_from and not
date_to:
           
date_to_with_delta = datetime.datetime.strptime(date_from,
tools.DEFAULT_SERVER_DATETIME_FORMAT) +
datetime.timedelta(hours=8)
           
result['value']['date_to'] = str(date_to_with_delta)

# Compute and update the number of
days
        if (date_to and date_from)
and (date_from <=
date_to):
           
diff_day = self._get_number_of_days(date_from,
date_to)
           
result['value']['days'] =
round(math.floor(diff_day))+1
       
else:
           
result['value']['days'] = 0

return
result
   
   
#更改结束日期，自动计算请假天数
    def onchange_date_to(self, cr, uid, ids,
date_to, date_from):
       
"""
        Update the
number_of_days.
       
"""
        # date_to has to be greater
than date_from
        if (date_from and
date_to) and (date_from >
date_to):
           
raise osv.except_osv(_(u'警告!'),_(u'开始日期必须小于结束日期.'))

result = {'value': {}}

# Compute and update the number of
days
        if (date_to and date_from)
and (date_from <=
date_to):
           
diff_day = self._get_number_of_days(date_from,
date_to)
           
result['value']['days'] =
round(math.floor(diff_day))+1
       
else:
           
result['value']['days'] = 0

return
result
   
   
#设置为草稿状态，需要重新初始化工作流
    def set_to_draft(self, cr, uid, ids,
context=None):
        for rec in
self.browse(cr, uid, ids,
context=context):
           
#当请假单不是自己创建的时，不能设置为草稿
           
if  rec.create_uid.id !=
uid:
               
raise
osv.except_osv(_(u'警告!'),_(u'您不能设置他人创建的单据为草稿状态.'))
           

        self.write(cr, uid, ids,
{
            'state':
'draft',
           
'manager_id':
False,
           
'refuse_notes':False
       
})
       
#重新初始化工作流
        wf_service =
netsvc.LocalService("workflow")
       
for id in
ids:
           
wf_service.trg_delete(uid, 'kl.qingjd', id, cr)
#传入对象名称
           
wf_service.trg_create(uid, 'kl.qingjd', id,
cr)
        return
True
   
   
#审批请假单，自动记录审批人
    def set_to_validate(self, cr, uid, ids,
context=None):
       
#审批时，此处可以增加审批权限的校验
        for rec in
self.browse(cr, uid, ids,
context=context):
           
#当请假单的主管不是自己时，不能审批
           
if  rec.employee_id and rec.employee_id.parent_id and
rec.employee_id.parent_id.user_id:
               
if rec.employee_id.parent_id.user_id.id !=
uid:
                   
raise
osv.except_osv(_(u'警告!'),_(u'您不能审批当前单据，应由申请人的主管审批.'))
           
else:
               
raise
osv.except_osv(_(u'警告!'),_(u'您不能审批当前单据，应由申请人的主管审批.'))
       

        obj_emp =
self.pool.get('hr.employee')
        ids2
= obj_emp.search(cr, uid, [('user_id', '=',
uid)])
        manager = ids2 and ids2[0]
or False
       
#self.send_validate_notificate(cr, uid, ids, context=context)
#批准时发送消息给自己，跟系统自动发送的消息重复
       
return self.write(cr, uid, ids, {'state':'validate', 'manager_id':
manager})
   
   
#发送消息给自己，已批准
    #def send_validate_notificate(self, cr, uid,
ids, context=None):
    #    for obj in
self.browse(cr, uid, ids, context=context):
   
#        self.message_post(cr, uid, [obj.id],
body=_(u'您的请假申请已批准！'), context=context)
   

    #提交请假单，发送消息给主管
    def
set_to_confirm(self, cr, uid, ids,
context=None):
       
#发送消息给主管
        for rec in
self.browse(cr, uid, ids,
context=context):
           
#当请假单不是自己创建的时，不能提交
           
if  rec.create_uid.id !=
uid:
               
raise
osv.except_osv(_(u'警告!'),_(u'您不能提交他人创建的单据.'))
           
#提交请假单时发送系统消息，指定消息相关的用户(发送消息给主管和自己)，消息的起始点，如果接收人只有自己则消息不在邮件中显示
           
if rec.employee_id and rec.employee_id.parent_id and
rec.employee_id.parent_id.user_id:
               
self.message_subscribe_users(cr, uid, [rec.id],
user_ids=[rec.employee_id.parent_id.user_id.id],
context=context)
        return
self.write(cr, uid, ids, {'state': 'confirm'})
   

    #拒绝请假单，自动记录审批人
    def
set_to_refuse(self, cr, uid, ids,
context=None):
       

        for rec in self.browse(cr, uid,
ids,
context=context):
           
#当请假单的主管不是自己时，不能拒绝
           
if  rec.employee_id and rec.employee_id.parent_id and
rec.employee_id.parent_id.user_id:
               
if rec.employee_id.parent_id.user_id.id !=
uid:
                   
raise
osv.except_osv(_(u'警告!'),_(u'您不能拒绝当前单据，应由申请人的主管拒绝.'))
           
else:
               
raise
osv.except_osv(_(u'警告!'),_(u'您不能拒绝当前单据，应由申请人的主管拒绝.'))
           
#拒绝时验证决绝原因不能为空
           
if (rec.refuse_notes == False) or (rec.refuse_notes.strip() ==
''):
               
raise
osv.except_osv(_(u'警告!'),_(u'拒绝原因不能为空，请编辑并填写.'))
           

        obj_emp =
self.pool.get('hr.employee')
        ids2
= obj_emp.search(cr, uid, [('user_id', '=',
uid)])
        manager = ids2 and ids2[0]
or False
       
#self.send_refuse_notificate(cr, uid, ids, context=context)
#拒绝时发送消息给自己，跟系统自动发送的消息重复
       
return self.write(cr, uid, ids, {'state':'refuse', 'manager_id':
manager})
   
   
#发送消息给自己，已拒绝
    #def send_refuse_notificate(self, cr, uid,
ids, context=None):
    #    for obj in
self.browse(cr, uid, ids, context=context):
   
#        self.message_post(cr, uid, [obj.id],
body=_(u'您的请假申请已拒绝！'), context=context)

kl_qingjd()#对象定义结束