Bladeren bron

新增工单申请及审批接口

konghl 4 jaren geleden
bovenliggende
commit
190e8a2ec0

+ 33 - 55
security-protection-service/src/main/java/com/ai/bss/security/protection/controller/WorkOrderManagementController.java

4
import java.util.List;
4
import java.util.List;
5
import java.util.Map;
5
import java.util.Map;
6
6
7
import com.ai.bss.security.protection.utils.EbcConstant;
8
import org.apache.commons.lang.StringUtils;
7
import org.apache.commons.lang.StringUtils;
9
import org.slf4j.Logger;
8
import org.slf4j.Logger;
10
import org.slf4j.LoggerFactory;
9
import org.slf4j.LoggerFactory;
11
import org.springframework.beans.factory.annotation.Autowired;
10
import org.springframework.beans.factory.annotation.Autowired;
12
import org.springframework.stereotype.Controller;
11
import org.springframework.stereotype.Controller;
12
import org.springframework.web.bind.annotation.RequestBody;
13
import org.springframework.web.bind.annotation.RequestMapping;
13
import org.springframework.web.bind.annotation.RequestMapping;
14
import org.springframework.web.bind.annotation.RequestParam;
14
import org.springframework.web.bind.annotation.RequestParam;
15
import org.springframework.web.bind.annotation.ResponseBody;
15
import org.springframework.web.bind.annotation.ResponseBody;
16
import org.springframework.web.multipart.MultipartFile;
16
17
17
import com.ai.abc.api.model.CommonResponse;
18
import com.ai.abc.api.model.CommonResponse;
18
import com.ai.bss.components.common.model.PageBean;
19
import com.ai.bss.components.common.model.PageBean;
19
import com.ai.bss.security.protection.service.interfaces.WorkOrderManagementService;
20
import com.ai.bss.security.protection.service.interfaces.WorkOrderManagementService;
20
import org.springframework.web.multipart.MultipartFile;
21
import com.ai.bss.security.protection.utils.EbcConstant;
22
import com.ai.bss.work.task.model.common.WorkEvent;
21
23
22
/**
24
/**
23
 * 工单管理
25
 * 工单管理
35
	 * @param pageNumber  当前页数
37
	 * @param pageNumber  当前页数
36
	 * @param pageSize 每页条数
38
	 * @param pageSize 每页条数
37
	 * @param status 工作状态(默认END)  RUN:待审批, END:完成
39
	 * @param status 工作状态(默认END)  RUN:待审批, END:完成
38
	 * @param appovalSubType 工单类型  小类
40
	 * @param approvalType 工单类型  小类
39
	 * @param startTime 开始时间
41
	 * @param startTime 开始时间
40
	 * @param endTime 结束时间
42
	 * @param endTime 结束时间
41
	 * @return
43
	 * @return
45
	@RequestMapping("/queryPageWorkOrder")
47
	@RequestMapping("/queryPageWorkOrder")
46
	public CommonResponse<PageBean<Map<String, Object>>> queryPageWorkOrder(
48
	public CommonResponse<PageBean<Map<String, Object>>> queryPageWorkOrder(
47
			@RequestParam(required = false) int pageNumber, @RequestParam(required = false) int pageSize,
49
			@RequestParam(required = false) int pageNumber, @RequestParam(required = false) int pageSize,
48
			@RequestParam(defaultValue = "END") String status, @RequestParam(required = false) String appovalSubType,
50
			@RequestParam(defaultValue = "END") String status, @RequestParam(required = false) String approvalType,
49
			@RequestParam(required = false) String startTime, @RequestParam(required = false) String endTime)
51
			@RequestParam(required = false) String startTime, @RequestParam(required = false) String endTime)
50
			throws Exception {
52
			throws Exception {
51
53
54
56
55
		Map<String, String> params = new HashMap<String, String>();
57
		Map<String, String> params = new HashMap<String, String>();
56
		params.put("status", status);
58
		params.put("status", status);
57
		params.put("appovalSubType", appovalSubType);
59
		params.put("appovalSubType", approvalType);
58
		params.put("startTime", startTime);
60
		params.put("startTime", startTime);
59
		params.put("endTime", endTime);
61
		params.put("endTime", endTime);
60
62
68
	 */
70
	 */
69
	@ResponseBody
71
	@ResponseBody
70
	@RequestMapping("/queryWorkOrderTypeList")
72
	@RequestMapping("/queryWorkOrderTypeList")
71
	public  CommonResponse<Map<String, List<Map<String, String>>>> queryWorkOrderTypeList() {
73
	public CommonResponse<Map<String, List<Map<String, String>>>> queryWorkOrderTypeList() {
72
		return workOrderManagementService.queryWorkOrderTypeList();
74
		return workOrderManagementService.queryWorkOrderTypeList();
73
	}
75
	}
74
76
81
	 */
83
	 */
82
	@ResponseBody
84
	@ResponseBody
83
	@RequestMapping("/queryOneWorkOrder")
85
	@RequestMapping("/queryOneWorkOrder")
84
	public CommonResponse<Map<String, Object>> queryOneWorkOrder(@RequestParam String workOrderId)
85
			throws Exception {
86
	public CommonResponse<Map<String, Object>> queryOneWorkOrder(@RequestParam String workOrderId) throws Exception {
86
		if (StringUtils.isEmpty(workOrderId)) {
87
		if (StringUtils.isEmpty(workOrderId)) {
87
			return CommonResponse.fail("500", "操作失败");
88
			return CommonResponse.fail("500", "操作失败");
88
		}
89
		}
89
90
90
		Map<String,String> params = new HashMap<String, String>();
91
		Map<String, String> params = new HashMap<String, String>();
91
		params.put("workOrderId", workOrderId);
92
		params.put("workOrderId", workOrderId);
92
		
93
93
		return workOrderManagementService.queryOneWorkOrder(params);
94
		return workOrderManagementService.queryOneWorkOrder(params);
94
	}
95
	}
95
96
96
	
97
	
98
	
99
	
100
	
101
	
102
	
103
	
104
	
105
	
106
	
107
	
108
	
109
	
110
	
111
	/**
97
	/**
112
	 * 工单申请
98
	 * 工单申请
113
	 *
99
	 *
114
	 * @param mapTagInfoDto
100
	 * @param params
115
	 * @return
101
	 * @return
116
	 * @throws Exception
102
	 * @throws Exception
117
	 */
103
	 */
118
	/*@ResponseBody
119
	@RequestMapping("/addAlppyVacationInfo")
120
	public CommonResponse<Void> addAlppyVacationInfo(@RequestBody WorkEvent mapTagInfoDto) throws Exception {
121
		Map<String, Object> result = new HashMap<String, Object>();
122
123
		*//*if (mapTagInfoDto == null || mapTagInfoDto.getMapAreaName() == null
124
				|| mapTagInfoDto.getMapAreaContent() == null) {
125
			return CommonResponse.fail("500", "添加失败");
104
	@ResponseBody
105
	@RequestMapping("/addWorkOrder")
106
	public CommonResponse<Void> addWorkOrder(@RequestBody Map<String, String> params) throws Throwable {
107
		if (params == null || StringUtils.isEmpty(params.get("approvalType"))|| StringUtils.isEmpty(params.get("beginTime"))) {
108
			return CommonResponse.fail("500", "未指定工单类型,申请失败");
126
		}
109
		}
127
		
128
		mapTagInfoDto.setMapAreaSetId(0L); // TODO 固定值 所属地图工单集合标识
129
		mapTagInfoDto.setPriority("10"); // 优先级
130
		mapTagInfoDto.setMapType(MapArea.MAP_TYPE_GEOMETRY);*//* // 工单形状,GEO多边形, RAD 圆形
131
110
132
		return workOrderManagementService.addAlppyVacationInfo(mapTagInfoDto);
133
	}*/
111
		WorkEvent workEvent=new WorkEvent();
112
		//TODO 申请人ID和部门
113
		workEvent.setWorkEmployeeRoleId(EbcConstant.USPA_USER_STAFF_ID);
114
		workEvent.setWorkOrgRoleId(EbcConstant.USPA_USER_ORG_ID);
115
		workEvent.setEventSpecId("APPROVAL_REQUEST");
116
		
117
		return workOrderManagementService.addWorkOrder(workEvent,params);
118
	}
134
119
135
	/**
120
	/**
136
	 * 工单审核
121
	 * 工单审核
137
	 *
122
	 *
138
	 * @param mapTagInfoDto
123
	 * @param params
139
	 * @return
124
	 * @return
140
	 * @throws Exception
125
	 * @throws Exception
141
	 */
126
	 */
142
	/*@ResponseBody
143
	@RequestMapping("/checkAlppyVacationInfo")
144
	public CommonResponse<Void> checkAlppyVacationInfo(@RequestBody MapTagInfoDto mapTagInfoDto) throws Exception {
145
		Map<String, Object> result = new HashMap<String, Object>();
146
147
		*//*if (mapTagInfoDto == null || mapTagInfoDto.getMapAreaName() == null || mapTagInfoDto.getMapAreaId() == null
148
				|| mapTagInfoDto.getMapAreaContent() == null) {
149
			return CommonResponse.fail("500", "修改失败");
127
	@ResponseBody
128
	@RequestMapping("/checkWorkOrder")
129
	public CommonResponse<Void> checkWorkOrder(@RequestBody Map<String, String> params) throws Throwable {
130
		if (params == null || StringUtils.isEmpty(params.get("orderId"))|| StringUtils.isEmpty(params.get("result"))) {
131
			return CommonResponse.fail("500", "审核失败");
150
		}
132
		}
151
		
152
		mapTagInfoDto.setMapAreaSetId(0L); // TODO 固定值 所属地图工单集合标识
153
		mapTagInfoDto.setPriority("10"); // 优先级
154
		mapTagInfoDto.setMapType(MapArea.MAP_TYPE_GEOMETRY);*//* // 工单形状,GEO多边形, RAD 圆形
155
133
156
		return workOrderManagementService.checkAlppyVacationInfo(mapTagInfoDto);
157
	}*/
134
		return workOrderManagementService.checkWorkOrder(params);
135
	}
158
136
159
137
160
	@RequestMapping("/importAskLeaveOrder")
138
	@RequestMapping("/importAskLeaveOrder")

+ 208 - 93
security-protection-service/src/main/java/com/ai/bss/security/protection/service/impl/WorkOrderManagementServiceImpl.java

1
package com.ai.bss.security.protection.service.impl;
1
package com.ai.bss.security.protection.service.impl;
2
2
3
import java.io.BufferedReader;
4
import java.io.IOException;
5
import java.util.ArrayList;
6
import java.util.HashMap;
7
import java.util.List;
8
import java.util.Map;
9
10
import org.springframework.beans.factory.annotation.Autowired;
11
import org.springframework.stereotype.Service;
12
import org.springframework.util.CollectionUtils;
13
import org.springframework.web.multipart.MultipartFile;
14
3
import com.ai.abc.api.model.CommonRequest;
15
import com.ai.abc.api.model.CommonRequest;
4
import com.ai.abc.api.model.CommonResponse;
16
import com.ai.abc.api.model.CommonResponse;
5
import com.ai.abc.exception.BaseException;
6
import com.ai.bss.characteristic.spec.model.CharacteristicSpecValue;
17
import com.ai.bss.characteristic.spec.model.CharacteristicSpecValue;
7
import com.ai.bss.components.common.model.PageBean;
18
import com.ai.bss.components.common.model.PageBean;
8
import com.ai.bss.security.protection.service.interfaces.CharSpecService;
19
import com.ai.bss.security.protection.service.interfaces.CharSpecService;
10
import com.ai.bss.security.protection.utils.EbcConstant;
21
import com.ai.bss.security.protection.utils.EbcConstant;
11
import com.ai.bss.security.protection.utils.ExcelException;
22
import com.ai.bss.security.protection.utils.ExcelException;
12
import com.ai.bss.security.protection.utils.ExcelUtil;
23
import com.ai.bss.security.protection.utils.ExcelUtil;
24
import com.ai.bss.user.service.api.UserDtoQuery;
25
import com.ai.bss.work.attendance.model.AttendanceTaskSpec;
13
import com.ai.bss.work.attendance.service.api.ApprovalTaskQuery;
26
import com.ai.bss.work.attendance.service.api.ApprovalTaskQuery;
27
import com.ai.bss.work.service.api.EventHandleCommand;
28
import com.ai.bss.work.service.api.WorkOrderCommand;
29
import com.ai.bss.work.task.model.common.WorkEvent;
30
import com.ai.bss.work.task.model.common.WorkOrder;
31
import com.ai.bss.work.task.model.common.WorkTask;
32
import com.alibaba.fastjson.JSON;
14
import com.alibaba.fastjson.JSONObject;
33
import com.alibaba.fastjson.JSONObject;
15
34
16
import lombok.extern.slf4j.Slf4j;
35
import lombok.extern.slf4j.Slf4j;
17
import org.springframework.beans.factory.annotation.Autowired;
18
import org.springframework.stereotype.Service;
19
import org.springframework.util.CollectionUtils;
20
import org.springframework.web.multipart.MultipartFile;
21
22
import java.io.BufferedReader;
23
import java.io.IOException;
24
import java.io.InputStreamReader;
25
import java.util.ArrayList;
26
import java.util.HashMap;
27
import java.util.List;
28
import java.util.Map;
29
36
30
@Slf4j
37
@Slf4j
31
@Service
38
@Service
32
public class WorkOrderManagementServiceImpl implements WorkOrderManagementService {
39
public class WorkOrderManagementServiceImpl implements WorkOrderManagementService {
33
40
34
    @Autowired
35
    private ApprovalTaskQuery approvalTaskQuery;
41
	@Autowired
42
	private ApprovalTaskQuery approvalTaskQuery;
36
43
37
    @Autowired
38
    private CharSpecService charSpecService;
44
	@Autowired
45
	private CharSpecService charSpecService;
39
46
40
    @Override
41
    public CommonResponse<PageBean<Map<String, Object>>> queryPageWorkOrder(Map<String, String> params, int pageNumber,
42
                                                                            int pageSize) throws Exception {
43
        CommonRequest<Map<String, String>> request = new CommonRequest<Map<String, String>>(params, pageNumber,
44
                pageSize);
45
        CommonResponse<PageBean<Map<String, Object>>> response = approvalTaskQuery.queryApprovalTaskByConditions(request);
46
47
        List<Map<String, Object>> list = response.getData().getData();
48
        if (CollectionUtils.isEmpty(list)) {
49
            return response;
50
        }
51
52
        for (Map<String, Object> map : list) {
53
            JSONObject charValueJsonObj = JSONObject.parseObject(map.get("charValueSet").toString());
54
            map.put("applyBeginTime", charValueJsonObj.getString("beginTime"));
55
            map.put("applyEndTime", charValueJsonObj.getString("endTime"));
56
            map.put("applyDuration", charValueJsonObj.getString("duration"));
57
            map.put("charValueSet", null);
58
        }
59
60
        return response;
61
    }
47
	@Autowired
48
	private EventHandleCommand eventHandleCommand;
62
49
63
    @Override
64
    public CommonResponse<Map<String, List<Map<String, String>>>> queryWorkOrderTypeList() {
65
        Map<String, List<Map<String, String>>> resultMap = new HashMap<String, List<Map<String, String>>>();
66
67
        List<CharacteristicSpecValue> allList = charSpecService
68
                .getCharSpecList(EbcConstant.BUSINESS_SPEC_WORK_ORDER_TYPE);
69
70
        List<Map<String, String>> allType = new ArrayList<Map<String, String>>(); // 所有工单小类
71
        List<Map<String, String>> askLeaveType = new ArrayList<Map<String, String>>(); // 请假
72
        List<Map<String, String>> fieldWorkType = new ArrayList<Map<String, String>>(); // 外勤
73
        List<Map<String, String>> recloType = new ArrayList<Map<String, String>>(); // 补卡
74
        List<Map<String, String>> overtimeType = new ArrayList<Map<String, String>>(); // 加班
75
76
        for (CharacteristicSpecValue charValue : allList) {
77
            Map<String, String> map = new HashMap<String, String>();
78
            String code = charValue.getCode();
79
            map.put("approvalType", code);
80
            map.put("approvalTypeName", charValue.getValue());
81
            allType.add(map);
82
83
            if (code.startsWith(EbcConstant.WORK_ORDER_TYPE_ASK_LEAVE)) {
84
                askLeaveType.add(map);
85
            } else if (code.startsWith(EbcConstant.WORK_ORDER_TYPE_FIELD_WORK)) {
86
                fieldWorkType.add(map);
87
            } else if (code.startsWith(EbcConstant.WORK_ORDER_TYPE_RECLOCK)) {
88
                recloType.add(map);
89
            } else if (code.startsWith(EbcConstant.WORK_ORDER_TYPE_OVERTIME)) {
90
                overtimeType.add(map);
91
            }
92
        }
93
94
        resultMap.put("allType", allType);
95
        resultMap.put("askLeaveType", askLeaveType);
96
        resultMap.put("fieldWorkType", fieldWorkType);
97
        resultMap.put("recloType", recloType);
98
        resultMap.put("overtimeType", overtimeType);
99
100
        return CommonResponse.ok(resultMap);
101
    }
50
	@Autowired
51
	private UserDtoQuery userDtoQuery;
102
52
103
    @Override
104
    public CommonResponse<Map<String, Object>> queryOneWorkOrder(Map<String, String> params) throws Exception {
105
        CommonRequest<Map<String, String>> conditionMapRequest = CommonRequest.<Map<String, String>>builder().data(params).build();
106
        CommonResponse<Map<String, Object>> response = approvalTaskQuery.queryApprovalTaskByWorkOrderId(conditionMapRequest);
53
	@Autowired
54
	private WorkOrderCommand workOrderCommand;
107
55
56
	@Override
57
	public CommonResponse<PageBean<Map<String, Object>>> queryPageWorkOrder(Map<String, String> params, int pageNumber,
58
			int pageSize) throws Exception {
59
		CommonRequest<Map<String, String>> request = new CommonRequest<Map<String, String>>(params, pageNumber,
60
				pageSize);
61
		CommonResponse<PageBean<Map<String, Object>>> response = approvalTaskQuery
62
				.queryApprovalTaskByConditions(request);
108
63
109
        Map<String, Object> map = response.getData();
110
        if (CollectionUtils.isEmpty(map)) {
111
            return response;
112
        }
64
		List<Map<String, Object>> list = response.getData().getData();
65
		if (CollectionUtils.isEmpty(list)) {
66
			return response;
67
		}
113
68
114
        JSONObject charValueJsonObj = JSONObject.parseObject(map.get("charValueSet").toString());
115
        map.put("applyBeginTime", charValueJsonObj.getString("beginTime"));
116
        map.put("applyEndTime", charValueJsonObj.getString("endTime"));
117
        map.put("applyDuration", charValueJsonObj.getString("duration"));
118
        map.put("charValueSet", null);
69
		Map<String, String> allTypeMap = charSpecService.getCharSpecMap(EbcConstant.BUSINESS_SPEC_WORK_ORDER_TYPE);
119
70
120
        return response;
121
    }
71
		for (Map<String, Object> map : list) {
72
			map.put("approvalTypeName", allTypeMap.get(map.get("appovalSubType").toString()));
73
74
			JSONObject charValueJsonObj = JSONObject.parseObject(map.get("charValueSet").toString());
75
			map.put("reclockingTime", charValueJsonObj.getString("reclockingTime"));
76
			map.put("applyBeginTime", charValueJsonObj.getString("beginTime"));
77
			map.put("applyEndTime", charValueJsonObj.getString("endTime"));
78
			map.put("applyDuration", charValueJsonObj.getString("duration"));
79
			map.put("charValueSet", null);
80
		}
81
82
		return response;
83
	}
84
85
	@Override
86
	public CommonResponse<Map<String, List<Map<String, String>>>> queryWorkOrderTypeList() {
87
		Map<String, List<Map<String, String>>> resultMap = new HashMap<String, List<Map<String, String>>>();
88
89
		List<CharacteristicSpecValue> allTypeList = charSpecService
90
				.getCharSpecList(EbcConstant.BUSINESS_SPEC_WORK_ORDER_TYPE);
91
92
		List<Map<String, String>> allType = new ArrayList<Map<String, String>>(); // 所有工单小类
93
		List<Map<String, String>> askLeaveType = new ArrayList<Map<String, String>>(); // 请假
94
		List<Map<String, String>> fieldWorkType = new ArrayList<Map<String, String>>(); // 外勤
95
		List<Map<String, String>> recloType = new ArrayList<Map<String, String>>(); // 补卡
96
		List<Map<String, String>> overtimeType = new ArrayList<Map<String, String>>(); // 加班
97
98
		for (CharacteristicSpecValue charValue : allTypeList) {
99
			Map<String, String> map = new HashMap<String, String>();
100
			String code = charValue.getCode();
101
			map.put("approvalType", code);
102
			map.put("approvalTypeName", charValue.getValue());
103
			allType.add(map);
104
105
			if (code.startsWith(AttendanceTaskSpec.ASK_FOR_LEAVE_REQUEST_TYPE)) {
106
				askLeaveType.add(map);
107
			} else if (code.startsWith(AttendanceTaskSpec.FIELD_WORK_REQUEST_TYPE)) {
108
				fieldWorkType.add(map);
109
			} else if (code.startsWith(AttendanceTaskSpec.OVERTIME_REQUEST_TYPE)) {
110
				overtimeType.add(map);
111
			} else if (code.equals(AttendanceTaskSpec.GO_TO_WORK_RE_CLOCKING_REQUEST_TYPE)
112
					|| code.equals(AttendanceTaskSpec.GO_OFF_WORK_RE_CLOCKING_REQUEST_TYPE)) {
113
				recloType.add(map);
114
			}
115
		}
116
117
		resultMap.put("allType", allType);
118
		resultMap.put("askLeaveType", askLeaveType);
119
		resultMap.put("fieldWorkType", fieldWorkType);
120
		resultMap.put("recloType", recloType);
121
		resultMap.put("overtimeType", overtimeType);
122
123
		return CommonResponse.ok(resultMap);
124
	}
125
126
	@Override
127
	public CommonResponse<Map<String, Object>> queryOneWorkOrder(Map<String, String> params) throws Exception {
128
		CommonRequest<Map<String, String>> conditionMapRequest = CommonRequest.<Map<String, String>>builder()
129
				.data(params).build();
130
		CommonResponse<Map<String, Object>> response = approvalTaskQuery
131
				.queryApprovalTaskByWorkOrderId(conditionMapRequest);
132
133
		Map<String, Object> map = response.getData();
134
		if (CollectionUtils.isEmpty(map)) {
135
			return response;
136
		}
137
138
		List<CharacteristicSpecValue> allTypeList = charSpecService
139
				.getCharSpecList(EbcConstant.BUSINESS_SPEC_WORK_ORDER_TYPE);
140
		for (CharacteristicSpecValue characteristicSpecValue : allTypeList) {
141
			if (characteristicSpecValue.getCode().equals(map.get("appovalSubType").toString())) {
142
				map.put("approvalTypeName", characteristicSpecValue.getValue());
143
				break;
144
			}
145
		}
146
147
		JSONObject charValueJsonObj = JSONObject.parseObject(map.get("charValueSet").toString());
148
		map.put("reclockingTime", charValueJsonObj.getString("reclockingTime"));
149
		map.put("applyBeginTime", charValueJsonObj.getString("beginTime"));
150
		map.put("applyEndTime", charValueJsonObj.getString("endTime"));
151
		map.put("applyDuration", charValueJsonObj.getString("duration"));
152
		map.put("charValueSet", null);
153
154
		return response;
155
	}
156
157
	@Override
158
	public CommonResponse<Void> addWorkOrder(WorkEvent workEvent, Map<String, String> params) throws Throwable {
159
		// 获取审批人ID
160
		Map<String, String> checkEmployeeRequestMap = new HashMap<String, String>();
161
		checkEmployeeRequestMap.put("orgId", workEvent.getWorkOrgRoleId());
162
		checkEmployeeRequestMap.put("roleCode", EbcConstant.WORK_ORDER_CHECK_ROLE_CODE);
163
		CommonRequest<Map<String, String>> checkEmployeeRequest = CommonRequest.<Map<String, String>>builder()
164
				.data(checkEmployeeRequestMap).build();
165
		CommonResponse<List<Map<String, Object>>> checkEmployeeResponse = userDtoQuery
166
				.queryApproveUserList(checkEmployeeRequest);
167
168
		if (!checkEmployeeResponse.isSuccess() || CollectionUtils.isEmpty(checkEmployeeResponse.getData())) {
169
			return CommonResponse.fail("502", "部门未指定审批人,申请失败");
170
		} else {
171
			params.put("approvalEmployeeRoleId", checkEmployeeResponse.getData().get(0).get("staffId").toString());
172
		}
173
174
		// 工单类型
175
		String approvalType = params.get("approvalType");
176
		if (approvalType.equals(AttendanceTaskSpec.GO_TO_WORK_RE_CLOCKING_REQUEST_TYPE)
177
				|| approvalType.equals(AttendanceTaskSpec.GO_OFF_WORK_RE_CLOCKING_REQUEST_TYPE)) {
178
			// 补卡
179
			params.put("approvalType", approvalType);
180
			params.put("approvalSubType", approvalType);
181
			params.put("reclockingTime", params.get("beginTime")); //补卡时间
182
183
		} else if (approvalType.startsWith(AttendanceTaskSpec.ASK_FOR_LEAVE_REQUEST_TYPE)) {
184
			// 请假
185
			params.put("approvalType", AttendanceTaskSpec.ASK_FOR_LEAVE_REQUEST_TYPE);
186
			params.put("approvalSubType", approvalType);
187
			params.put("leaveType", approvalType.substring(AttendanceTaskSpec.ASK_FOR_LEAVE_REQUEST_TYPE.length()+1));
188
189
		} else if (approvalType.startsWith(AttendanceTaskSpec.FIELD_WORK_REQUEST_TYPE)) {
190
			// 外勤
191
			params.put("approvalType", AttendanceTaskSpec.FIELD_WORK_REQUEST_TYPE);
192
			params.put("approvalSubType", approvalType);
193
194
		} else if (approvalType.startsWith(AttendanceTaskSpec.OVERTIME_REQUEST_TYPE)) {
195
			// 加班
196
			params.put("approvalType", AttendanceTaskSpec.OVERTIME_REQUEST_TYPE);
197
			params.put("approvalSubType", approvalType);
198
199
		} else {
200
			return CommonResponse.fail("503", "工单类型无效,申请失败");
201
		}
202
203
		workEvent.setCharValueSet(JSON.toJSONString(params));
204
205
		CommonRequest<WorkEvent> eventRequest = new CommonRequest<WorkEvent>(workEvent);
206
		CommonResponse response = eventHandleCommand.handleEvent(eventRequest);
207
		// ApprovalTask approvalTaskGoOffWork = (ApprovalTask) response.getData();
208
209
		if (response.isSuccess()) {
210
			return CommonResponse.ok(null);
211
		} else {
212
			return CommonResponse.fail(response.getFail());
213
		}
214
	}
215
216
	@Override
217
	public CommonResponse<Void> checkWorkOrder(Map<String, String> params) throws Throwable {
218
		WorkOrder workOrder = new WorkOrder();
219
		workOrder.setWorkOrderId(params.get("orderId"));
220
		workOrder.setProcessResult(WorkOrder.SUCCESS_RESULT);
221
		workOrder.setStatus(WorkOrder.END_STATUS);
222
223
		Map<String, String> charValueMap = new HashMap<String, String>();
224
		charValueMap.put("approvalResult", params.get("result"));
225
		charValueMap.put("approvalComment", params.get("comments"));
226
227
		workOrder.setCharValueSet(JSON.toJSONString(charValueMap));
228
229
		CommonRequest<WorkOrder> workOrderRequest = new CommonRequest<WorkOrder>(workOrder);
230
		CommonResponse<WorkTask> response = workOrderCommand.reportWorkOrderResult(workOrderRequest);
122
231
232
		if (response.isSuccess()) {
233
			return CommonResponse.ok(null);
234
		} else {
235
			return CommonResponse.fail(response.getFail());
236
		}
237
	}
123
238
124
    @Override
239
    @Override
125
    public CommonResponse importAskLeaveOrder(MultipartFile file)  {
240
    public CommonResponse importAskLeaveOrder(MultipartFile file)  {

+ 14 - 26
security-protection-service/src/main/java/com/ai/bss/security/protection/service/interfaces/WorkOrderManagementService.java

2
2
3
import com.ai.abc.api.model.CommonResponse;
3
import com.ai.abc.api.model.CommonResponse;
4
import com.ai.bss.components.common.model.PageBean;
4
import com.ai.bss.components.common.model.PageBean;
5
import com.ai.bss.work.task.model.common.WorkEvent;
6
5
import org.springframework.web.multipart.MultipartFile;
7
import org.springframework.web.multipart.MultipartFile;
6
8
7
import java.util.List;
9
import java.util.List;
17
	 * @return
19
	 * @return
18
	 * @throws Exception
20
	 * @throws Exception
19
	 */
21
	 */
20
	CommonResponse<PageBean<Map<String, Object>>> queryPageWorkOrder(Map<String, String> params, int pageNumber, int pageSize) throws Exception;
22
	CommonResponse<PageBean<Map<String, Object>>> queryPageWorkOrder(Map<String, String> params, int pageNumber,
23
			int pageSize) throws Exception;
21
24
22
	/**
25
	/**
23
	 * 获取所有工单类型
26
	 * 获取所有工单类型
24
	 * 
27
	 * 
25
	 * @return
28
	 * @return
26
	 */
29
	 */
27
	 CommonResponse<Map<String, List<Map<String, String>>>> queryWorkOrderTypeList();
28
	
30
	CommonResponse<Map<String, List<Map<String, String>>>> queryWorkOrderTypeList();
31
29
	/**
32
	/**
30
	 * 获取单个工单信息
33
	 * 获取单个工单信息
31
	 * @param params
34
	 * @param params
32
	 * @return
35
	 * @return
33
	 * @throws Exception
36
	 * @throws Exception
34
	 */
37
	 */
35
	 CommonResponse<Map<String, Object>> queryOneWorkOrder(Map<String,String> params) throws Exception;
36
37
38
	 CommonResponse importAskLeaveOrder(MultipartFile file) ;
38
	CommonResponse<Map<String, Object>> queryOneWorkOrder(Map<String, String> params) throws Exception;
39
39
40
	
41
42
	
43
	
44
	
45
	
46
	
47
	
48
	
49
	
50
	
51
	
52
	
53
	
54
	
55
	/**
40
	/**
56
	 * 工单申请
41
	 * 工单申请
57
	 * @param mapTagInfoDto
42
	 * @param workEvent
43
	 * @param params
58
	 * @return
44
	 * @return
59
	 * @throws Exception
45
	 * @throws Exception
60
	 */
46
	 */
61
	//CommonResponse<Void> addAlppyVacationInfo(WorkEvent mapTagInfoDto) throws Throwable;
47
	CommonResponse<Void> addWorkOrder(WorkEvent workEvent,Map<String, String> params) throws Throwable;
62
48
63
	/**
49
	/**
64
	 * 工单审核
50
	 * 工单审核
65
	 * @param mapTagInfoDto
51
	 * @param params
66
	 * @return
52
	 * @return
67
	 * @throws Exception
53
	 * @throws Exception
68
	 */
54
	 */
69
	//CommonResponse<Void> checkAlppyVacationInfo(WorkEvent mapTagInfoDto) throws Exception;
55
	CommonResponse<Void> checkWorkOrder(Map<String, String> params) throws Throwable;
56
57
	 CommonResponse importAskLeaveOrder(MultipartFile file) ;
70
58
71
}
59
}

+ 15 - 17
security-protection-service/src/main/java/com/ai/bss/security/protection/utils/EbcConstant.java

12
	// 每页默认查询条数
12
	// 每页默认查询条数
13
	public static final int DEFAULT_PAGE_SIZE = 20;
13
	public static final int DEFAULT_PAGE_SIZE = 20;
14
14
15
16
	// 异常考勤查询常量异常取值 abnormal,
15
	// 异常考勤查询常量异常取值 abnormal,
17
	public static final String ATTENDANCE_STATUSTYPE_ABNORMAL = "ABNORMAL";
16
	public static final String ATTENDANCE_STATUSTYPE_ABNORMAL = "ABNORMAL";
18
17
22
	// 轨迹回放单次查询条数
21
	// 轨迹回放单次查询条数
23
	public static final int TRACK_PLAYBACK_SIZE = 100;
22
	public static final int TRACK_PLAYBACK_SIZE = 100;
24
23
25
	
26
	// 考勤查询:日
24
	// 考勤查询:日
27
	public static final String AREA_IN_OUT_RECORD_DAY = "day";
25
	public static final String AREA_IN_OUT_RECORD_DAY = "day";
28
26
32
	// 考勤查询:月
30
	// 考勤查询:月
33
	public static final String AREA_IN_OUT_RECORD_MONTH = "month";
31
	public static final String AREA_IN_OUT_RECORD_MONTH = "month";
34
32
33
	// 静态常量: 工单类型
34
	public static final String BUSINESS_SPEC_WORK_ORDER_TYPE = "WORK_ORDER_TYPE";
35
36
	// 工单审批的角色CODE
37
	public static final String WORK_ORDER_CHECK_ROLE_CODE = "approval";
38
35
	
39
	
36
	//静态常量: 工单类型
37
	public static final String BUSINESS_SPEC_WORK_ORDER_TYPE="WORK_ORDER_TYPE";
38
	
39
	//工单类型:请假
40
	public static final String WORK_ORDER_TYPE_ASK_LEAVE="ASK_LEAVE";
41
	
42
	//工单类型:外勤
43
	public static final String WORK_ORDER_TYPE_FIELD_WORK="FIELD_WORK";
44
	
45
	//工单类型:补卡
46
	public static final String WORK_ORDER_TYPE_RECLOCK="RECLO";
47
	
48
	//工单类型:加班
49
	public static final String WORK_ORDER_TYPE_OVERTIME="OVERTIME";
50
	
40
	// 当前登录者的STAFF_ID
41
	public static String USPA_USER_STAFF_ID = "201613310867";
42
	// 当前登录者ID
43
	public static String USPA_USER_CODE = "wh";
44
	// 当前登录者部门
45
	public static String USPA_USER_ORG_ID = "1";
46
	// 当前登录者部门
47
	public static String USPA_USER_ORG_CODE = "0000";
48
51
}
49
}