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()#对象定义结束