呼叫中心工单系统

呼叫中心工单系统Ticket system又称为工单管理系统（还能够称为问题工单系统，事务工单系统，事务追踪系统issue tracking system，支持工单系统support ticket system)）,它是一种网络软件系统，根据不一样组织，部门和外部客户的需求，来由针对的管理，维护和追踪一系列的问题和请求。一个完善功能的工单系统 又能够称为帮助台系统。
网讯兆通呼叫中心工单系统通常被普遍用于客户帮助支持服务，客户售后服务，企业IT支持服务，呼叫中心等，用来建立，挂 起，解决用户，客户，合做伙伴或企业内部职员提交的事务请求。规范化，统一化和清晰化的处理和管理事务。一个完整的工单系统还须要配套拥有一个帮助文档知 识库（Knowledge base）,里面包含客户的一些常见受理问题相关信息，常见问题的处理方式，和一些其余的帮助文档等。一个工单系统就像一个问题追踪器，能很清晰的追踪， 处理和归档内外的问题事务请求，标准化服务追踪用户。
网讯工单系统处理的支持请求能够分为不少种，同时也会根据事务的不一样状况用优先级以区分不一样程度和重要性的支持请求。优先级能够分为紧急，高，中和低。事务类型能够大体分为，问题，事务，故障和任务。
不 同事务类型能够包含本身的私有属性，如故障能够包含多个事务（多个事务可能由一个故障引发的，或者说一个故障致使多个事务的产生），任务会拥有一个到期时 间（一个任务须要在到期时间前处理完成）。同时能够根据不一样企业组织的需求增长分类来对工单种类进行细分，从而有针对的分配合适的任务给合适的管理人员进 行处理。
做为服务于企业和组织的工单系统，其系统内部须要有一套完善的业务流程体系，以知足企业和组织在使用中和操做中的任务分配，事务处理，流程自动化等。
下面举个例子来明确该体系所应包含的内容以及一个工单系统流程具体的操做方式：
一、一个客户支持职员接到一个电话，或者一个事务提交请求（可能在网页上提交也多是发送电子邮件），其内容是关于一个具体的问题。一些工单系统提供自动回应和提醒。
二、一个服务职员确认该问题的真实性，并经过工单系统或电话收集该客户关于该问题的全部信息。获取该用户的一些必要信息。
三、该服务职员在工单系统中建立该问题，或由客户提交自动在系统自动建立该问题工单，并录入全部关于该问题的相关信息。
四、在处理进程中，工单会经历若干状态，直到已解决该问题，工单的内容会随着问题处理的进度而进行相应的更新。并会发送相应的提醒给请求客户。
五、当一个工单被解决后，该工单在系统中会被标记成已解决，并做为该客户用户事务的归档以便后续追踪和查阅。
从以上简单的流程能够看到，一个优秀的工单系统须要拥有完善的业务流程体系和自定义引擎来方便最终用户和管理人员进行高效的平常操做。
网讯兆通呼叫中心工单系统的标准化服务
一、一个工单系统须要有一套标准化体系，来使工单系统全部的操做，处理，管理和维护所有知足和履行该标准化的内容，避免服务拖延，服务延迟，避免下降服务质量和资源浪费。
服务目标能让工单系统的工单处理操做和相关服务知足服务目标协议，当在实际服务中，有工单处理威胁而不能知足该服务目标时，会及时作出提醒，以让系统管理人员进行及时处理。
二、协同操做，工单系统应该是一个能让多个客户服务职员协同合做处理客户支持请求工单的系统，所以是否高效的进行处理和管理成为判断一个工单系统好坏的关键。
在工单系统内须要对不一样角色的人员进行分类，一般采用组和部门（组织）的方式进行分类区分，以便经过业务流程体系来进行自动分配任务。
例如能够将处理技术的客户服务职员所有归属到一个叫作技术组的客服组中，而后经过业务流程体系功能未来源为技术的支持请求所有让该组的人进行受理。
也可让专职人员专门负责某个部门或某个组织的请求事务处理，追踪和解决。
协同操做不只限于事务的分配，还在于事务的调度和转发，例如一个客户服务职员可能在处理中能力不足，须要有更多经验的管理人员来协同处理，因此他应该能够将工单分配给另外一我的员进行处理。
网讯兆通呼叫中心工单系统的附属功能：
一个全面的工单系统应该是由多种附属功能结合而成的，从而成为一个完善，强大集中的功能应用，下面列出了部分功能是一个优秀的工单系统所能扩展的：
一、在线交谈功能：基于工单系统事务的交谈，交谈内容归档为工单内容
二、统计报告：统计工单系统内的工单处理，操做状况，便于改进和分析

三、支持渠道的扩展：多种客户支持渠道方便客户提交工单问题和支持请求

需求：

最近要实现一个自动派单功能，就是若是有任务来了，那么任务平均分配给现有的员工，若是以前取了任务的员工下次来任务时就分配给下一个，若是有新员工则将员工添加到队列的最后，若是有员工离职就将员工信息从队列里移除。

 

实现：

1.写一个定时任务，定时将任务放入任务队列中TaskQueue，并将员工放入User队列中，若是员工已存在则不添加，若是新员工则加入队列中，若是员工不存在了就从队列中移除。

2.写一个线程，从任务队列中取任务，若是任务不存在则阻塞，取到任务后，将该任务派给下一个员工，并将该员工添加到员工队列末尾，这样达到按员工次序分配任务。

3.实现一个任务队列，若是在取任务时任务不存在则阻塞。

4.实现一个员工队列，在取下一个员工后将该员工从列头移到列尾，而且能够将新员工加入到队列未尾，能够将不存在的员工从队列中移除。

 

核心代码：

 

Java代码  

1. import java.util.Collection;  
2. import java.util.concurrent.BlockingQueue;  
3. import java.util.concurrent.LinkedBlockingDeque;  
4.   
5. /** 
6.  * 任务队列 
7.  * 若是在取任务时没有任务，则阻塞 
8.  * @author dg 
9.  * 
10.  */  
11. public class TaskQueue {  
12.       
13.     private static TaskQueue instance;  
14.       
15.     private static BlockingQueue queue = null;  
16.       
17.     private TaskQueue(){  
18.         queue = new LinkedBlockingDeque();  
19.     }  
20.       
21.     public static TaskQueue getInstance(){  
22.         if(instance == null){  
23.             instance = new TaskQueue();  
24.         }  
25.         return instance;  
26.     }  
27.       
28.     /** 
29.      * 获取队列大小 
30.      * @return  
31.      */  
32.     public static int getSize(){  
33.         return queue.size();  
34.     }  
35.       
36.     /** 
37.      * 放入队列中 
38.      * @param msg 
39.      */  
40.     public void put(Object obj){  
41.         if(obj != null){  
42.             try {  
43.                 queue.put(obj);  
44.             } catch (InterruptedException e) {  
45.                 e.printStackTrace();  
46.             }  
47.         }  
48.     }  
49.       
50.     /** 
51.      * 放入队列中 
52.      * @param msg 
53.      */  
54.     public void putAll(Collection objs){  
55.         if(objs != null){  
56.             queue.addAll(objs);  
57.         }  
58.     }  
59.       
60.     /** 
61.      * 从队列中取出一个 
62.      * @return  
63.      */  
64.     public Object take(){  
65.         try {  
66.             Object obj = queue.take();    
67.             return obj;  
68.         } catch (InterruptedException e) {  
69.             e.printStackTrace();  
70.         }  
71.         return null;  
72.     }  
73.   
74. }  

 

 

 

Java代码  

1. /** 
2.  * 存放即将被派任务的员工 
3.  * 每次取出员工时不移除该员工，而是将其放到队列末尾 
4.  * 若是员工已不存在，将其移除 
5.  * @author dg 
6.  * 
7.  */  
8. public class UserQueue {  
9.       
10.     private static UserQueue instance = null;  
11.     private static BlockingQueue<User> queue = null;  
12.       
13.     private UserQueue(){  
14.         queue =  new LinkedBlockingDeque<User>();  
15.     }  
16.       
17.     public static UserQueue getInstance(){  
18.         if(instance == null){  
19.             instance = new UserQueue();  
20.         }  
21.         return instance;  
22.     }  
23.   
24.     /** 
25.      * 取下一个员工 
26.      * @return 
27.      */  
28.     public User takeNext(){  
29.         User user = null;  
30.         try {  
31.             user = queue.take();  
32.             this.put(user);  
33.         } catch (InterruptedException e) {  
34.             e.printStackTrace();  
35.         }  
36.         return user;  
37.     }  
38.       
39.     /** 
40.      * 将新员工放入队列中未尾 
41.      */  
42.     public void put(User user){  
43.         if(queue.contains(user)){  
44.             return;  
45.         }else{  
46.             try {  
47.                 queue.put(user);  
48.             } catch (InterruptedException e) {  
49.                 e.printStackTrace();  
50.             }  
51.         }  
52.     }  
53.       
54.     public void putAll(Collection<User> users){  
55.         for(User user : users){  
56.             this.put(user);  
57.         }  
58.     }  
59.       
60.     /** 
61.      * 将已不存在的员工移除 
62.      */  
63.     public void remove(User user){  
64.         if(queue.contains(user)){  
65.             queue.remove(user);  
66.         }  
67.     }  
68.       
69.     /** 
70.      * 获取目前队列中全部的user 
71.      * @return 
72.      */  
73.     public Object[] getAllUsers(){  
74.         Object[] obj = queue.toArray();  
75.         return obj;  
76.     }  
77.       
78.     /** 
79.      * @param args 
80.      */  
81.     public static void main(String[] args) {  
82.         User user1 = new User();  
83.         user1.setUid(1);  
84.         user1.setAccount("11");  
85.           
86.         User user2 = new User();  
87.         user2.setUid(1);  
88.         user2.setAccount("11");  
89.           
90.         User user3 = new User();  
91.         user3.setUid(3);  
92.         user3.setAccount("11");  
93.           
94.         User user4 = new User();  
95.         user4.setUid(4);  
96.         user4.setAccount("444");  
97.           
98.         User user5 = new User();  
99.         user5.setUid(5);  
100.         user5.setAccount("555");  
101.           
102.         UserQueue.getInstance().put(user1);  
103.         UserQueue.getInstance().put(user2);  
104.         UserQueue.getInstance().put(user3);  
105.         UserQueue.getInstance().put(user4);  
106.         UserQueue.getInstance().put(user5);  
107.           
108.         for(int i = 0 ; i < 20; i++){  
109.             System.out.println(UserQueue.getInstance().takeNext().getUid());  
110.             if(i == 5){  
111.                 UserQueue.getInstance().remove(user2);  
112.             }  
113.         }  
114.           
115.         Object[] users = UserQueue.getInstance().getAllUsers();  
116.         System.out.println("=======");  
117.         for(Object user:users){  
118.             System.out.println(((User)user).getUid());  
119.         }  
120.     }  
121.   
122. }  

 

对于要实现User对象的比较，首先要重写equals方法.如下是我重写的User的equals方法

Java代码  

1. public boolean equals(Object obj) {  
2.         if(!(obj instanceof User)){  
3.             return false;  
4.         }  
5.         User u = (User)obj;  
6.         return (u.getAccount().equals(account) && u.getUid().equals(uid));  
7.     }  

 

Java代码  

1. import java.util.List;  
2. import java.util.TimerTask;  
3.   
4. import org.apache.log4j.Logger;  
5.   
6. import com.cms.common.ServiceUtil;  
7. import com.cms.common.SysConfig;  
8. import com.cms.entity.ClientRecord;  
9. import com.cms.entity.User;  
10. import com.cms.service.ClientService;  
11.   
12. /** 
13.  * 定时将客户意向放入任务队列 
14.  * 而且从新成功员工队列  
15.  * @author dg 
16.  * 
17.  */  
18. public class GenerateTask extends TimerTask {  
19.       
20.     private static Logger logger = Logger.getLogger(GenerateTask.class);  
21.     private ClientService clientService = (ClientService)ServiceUtil.getService("clientService");  
22.   
23.     public void run() {  
24.         try {  
25.             String autoTaskRoleIds = SysConfig.getStrValue("autotask.roleid");  
26.             if(autoTaskRoleIds == null || autoTaskRoleIds.trim().equals("")   
27.                     || autoTaskRoleIds.split(",").length == 0){  
28.                 logger.error("自动派单角色未设置");  
29.                 return;  
30.             }  
31.             //取所有名单  
32.             List<User> userList = clientService.getAllAutoTaskUsers(autoTaskRoleIds.split(","));  
33.             if(userList == null || userList.size() == 0){  
34.                 logger.error("目前还未有业务员没法派单");  
35.                 return;  
36.             }  
37.             //将已不存在的用户移除  
38.             Object[] users = UserQueue.getInstance().getAllUsers();  
39.             for(Object user : users){  
40.                 if(!userList.contains(user)){  
41.                     UserQueue.getInstance().remove((User)user);  
42.                 }  
43.             }  
44.             //从新生成名单  
45.             UserQueue.getInstance().putAll(userList);  
46.             //生成任务  
47.             List<ClientRecord> recordList = clientService.getAllUnAssignRecord();  
48.             TaskQueue.getInstance().putAll(recordList);  
49.         } catch (Throwable t) {  
50.             logger.error("自动派单任务异常!" ,t);  
51.         }finally{  
52.             logger.info("这次任务执行完毕!");  
53.         }  
54.     }  
55. }  

 

Java代码  

1. import org.apache.log4j.Logger;  
2.   
3. import com.cms.common.ServiceUtil;  
4. import com.cms.entity.ClientRecord;  
5. import com.cms.entity.User;  
6. import com.cms.schedule.TaskQueue;  
7. import com.cms.schedule.UserQueue;  
8. import com.cms.service.ClientService;  
9.   
10. /** 
11.  * 从任务队列里取到任务，自动派单给业务员 
12.  * @author dg 
13.  * 
14.  */  
15. public class AutoDispatchTaskThread implements Runnable{  
16.       
17.     private static Logger logger = Logger.getLogger(AutoDispatchTaskThread.class);  
18.     private ClientService clientService = (ClientService)ServiceUtil.getService("clientService");  
19.       
20.     private boolean stop = false;  
21.   
22.     @Override  
23.     public void run() {  
24.         try{  
25.             while(!stop){  
26.                 ClientRecord record = (ClientRecord)TaskQueue.getInstance().take();  
27.                 User user = UserQueue.getInstance().takeNext();  
28.                 clientService.assginRecord(record.getRid(), user.getUid());  
29.             }  
30.         }catch(Throwable t){  
31.             logger.error(t.getMessage(),t);  
32.         }  
33.     }  
34. }