1. 工作流审核(并审串审)

需求: 1. 并审和串审

2. 并审可以几个人审核一个工单,一个人同意,其他人则不需要审核

3. 不影响串审

4. 提交工单时系统要给审核人发送审核消息

5. 实现消息盒子功能(已读未读)

6. 用工厂实现并审串审

思路: 当用户提交工单的时候,判断当前审核人是否是并审,然后将审核人列表入库,并且给审核人发送一条审核消息,当前审核人可以从工单详情用步骤条查看当前审核的进度

7. 添加工单代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def post(self, request):
    wid = request.data.get('id')
    user_id = request.data.get('user_id')
    name = request.data.get('name', None)
    autitor = request.data.get('autitor')
    qnimg = request.data.get('qnimg')
    # 将第一个数据设置为当前审核人
    dq = autitor[0]
    worder = WorkOrder.objects.filter(id=wid).first()  # 获取工单分类名
    me_name = f'你收到了一条需要审核的{worder.name}工单'  # 消息盒子的内容
    work = WorkTem.objects.create(uid_id=user_id, wid_id=wid, info=name, autitor=str(autitor), start=1, dq=str(dq),
                                  qnimg=qnimg)

    # 将当前审核人添加到三方表
    if type(dq) == list:
        for i in dq:
            AutList.objects.create(tid_id=work.id, uid=i)
            # 添加到消息盒子
            r.hset('user%s' % i, 'message%s' % work.id,
                   str({"name": me_name, "wid": wid, "uid": i, "is_read": 0, "is_ch": 0}))
    else:
        Message.objects.create(name=me_name, wid_id=wid, uid_id=dq)
        r.hset('user%s' % dq, 'message%s' % work.id,
               str({"name": me_name, "wid": wid, "uid": dq, "is_read": 0, "is_ch": 0}))
    return Response({'msg': '提交成功', 'code': 200})

8. 工单详情展示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def get(self, request):
    user_id = request.query_params.get('user_id')
    work = WorkTem.objects.filter(uid=user_id)
    work_list = []
    for i in work:
        data = {}
        data['info'] = eval(i.info)
        data['start'] = i.start
        if type(eval(i.dq)) == list:
            dq = eval(i.autitor).index(eval(i.dq))
        else:
            dq = eval(i.autitor).index(int(i.dq))
        data['index'] = dq
        data['qnimg'] = i.qnimg
        list1 = []
        for index, j in enumerate(eval(i.autitor)):
            list2 = []
            if type(j) == list:
                for k in j:
                    user = User.objects.filter(id=k).first()
                    list2.append(user.username)
                list2 = ','.join(list2)
                list1.append(list2)
            else:
                user = User.objects.filter(id=j).first()
                list1.append(user.username)
            data['autitor'] = list1
        work_list.append(data)
    return Response(work_list)

9. 查询当前审核人

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 审核
class Audit(APIView):
    # 获取当前审核人的数据
    def get(self, request):
        uid = request.query_params.get('uid')
        autlist = AutList.objects.filter(uid=uid)
        work_list = []
        for i in autlist:
            work = WorkTem.objects.filter(id=i.tid_id).first()
            data = {}
            data['id'] = work.id
            data['info'] = eval(work.info)
            work_list.append(data)
        return Response(work_list)

10. 审核

1
2
3
4
def post(self, request):
    start = request.data.get('start')
    id = request.query_params.get('id')
    return Sim.AuditZX(start, id)  # 调用工厂

11. 工厂实现并审串审功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
class Chuan:

    def __init__(self, start, id):
        self.start = start
        self.id = id

    def zx(self, a):
        if self.start == '2':
            # 按条件清空三方表
            WorkTem.objects.filter(id=self.id).update(dq=a)
            AutList.objects.filter(tid_id=self.id).delete()
            AutList.objects.create(tid_id=self.id, uid=a)
        else:
            WorkTem.objects.filter(id=self.id).update(dq=a)
            AutList.objects.filter(tid_id=self.id).delete()
            AutList.objects.create(tid_id=self.id, uid=a)


class Bing:
    def __init__(self, start, id):
        self.start = start
        self.id = id

    def zx(self, a):
        if self.start == '2':
            # 按条件清空三方表
            WorkTem.objects.filter(id=self.id).update(dq=a)
            AutList.objects.filter(tid_id=self.id).delete()
            for i in a:
                AutList.objects.create(tid_id=self.id, uid=i)
        else:
            WorkTem.objects.filter(id=self.id).update(dq=a)
            AutList.objects.filter(tid_id=self.id).delete()
            for i in a:
                AutList.objects.create(tid_id=self.id, uid=i)


class Sim:
    @staticmethod
    def AuditZX(start, id):
        work = WorkTem.objects.filter(id=id).first()
        if start == '2':
            index = eval(work.autitor).index(eval(work.dq))
            if len(eval(work.autitor)) == index + 1:
                WorkTem.objects.filter(id=id).update(start=2)
                AutList.objects.filter(tid_id=id).delete()
            else:
                a = eval(work.autitor)[index + 1]
                if type(a) == list:
                    b = Bing(start, id)
                    b.zx(a)
                    #  并审的消息盒子一个人审完 另一个人不显示
                    Message.objects.filter(wid_id=work.id).update(is_read=1)
                else:
                    c = Chuan(start, id)
                    c.zx(a)
            return Response({'msg': '审核通过', 'code': 200})
        else:
            index = eval(work.autitor).index(eval(work.dq))
            if index == 0:
                WorkTem.objects.filter(id=id).update(start=3)
                AutList.objects.filter(tid_id=id).delete()
            else:
                a = eval(work.autitor)[index - 1]
                if type(a) == list:
                    b = Bing(start, id)
                    b.zx(a)
                else:
                    c = Chuan(start, id)
                    c.zx(a)
            return Response({'msg': '审核未通过', 'code': 400})

12.消息盒子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 消息盒子
class MessageView(APIView):
    def get(self, request):
        user_id = request.query_params.get('id')
        c = r.hgetall('user%s' % user_id)
        list1 = []
        length = 0
        for key, values in c.items():
            print(key)
            i = eval(values)
            list1.append(i)
            if i['is_read'] == 0:
                length += 1
        return Response({'message': list1, 'count': length})
        # uid = request.query_params.get('id')
        # count = Message.objects.filter(uid_id=uid, is_read=0).count()
        # message = Message.objects.filter(uid_id=uid).order_by('is_read', '-id')
        # return Response({'message': MessageSerializer(message, many=True).data, 'count': count})

    def put(self, request):
        wid = request.query_params.get('id')
        uid = request.data.get('uid')
        c = r.hgetall('user%s' % uid)
        print(c)
        for key, values in c.items():
            print(key)
            i = eval(values)
            print(i)
            if wid == i['wid']:
                r.hset('user%s' % uid, key, str({"name": i['name'], "wid": wid, "uid": uid, "is_read": 1, "is_ch": 0}))
        return Response({})