基于javaweb+mysql的ssm+maven汽车维修管理系统(java+ssm+jsp+bootstrap+layui+mysql)

基于javaweb+mysql的ssm+maven汽车维修管理系统(java+ssm+jsp+bootstrap+layui+mysql)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb的SSM+Maven汽车维修管理系统(java+ssm+jsp+bootstrap+layui+mysql)

项目介绍

源码描述：

一、源码介绍

汽车维修管理系统源码使用ssm框架，maven，bootsrap,mysql实现，带数据库。

二、主要功能

分为2个角色，管理员和顾客； 顾客登录后，操作我的车辆，预约订单，历史订单； 管理员登录后，操作订单管理，员工管理，机位管理，用户管理，零件管理。

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。 2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA; 3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可 4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS； 5.是否Maven项目: 是； 6.数据库：MySql 5.7/8.0等版本均可；

技术栈

1. 后端：Spring springmvc mybatis 2. 前端：JSP+css+javascript+jQuery+bootstrap+layui

使用说明 1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件； 2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven; 若为maven项目，导入成功后请执行maven clean;maven install命令，配置tomcat 3. 将项目中jdbc.properties配置文件中的数据库配置改为自己的配置，然后运行； 4. 运行成功后，在浏览器中输入：http://localhost:8080/ 管理员账号密码：admin/admin 用户账号密码：user/123456

	        String extName = oriName.substring(oriName.lastIndexOf("."));  
	        // 3.生成自定义的新文件名，这里以UUID.jpg|png|xxx作为格式（可选操作，也可以不自定义新文件名）  
	        String uuid = UUID.randomUUID().toString();  
	        String newName = uuid + extName;  
	        // 4.获取要保存的路径文件夹  
	        String realPath = request.getRealPath("static/images/car");  
	        // 5.保存图片  
	        desFilePath = realPath + "\\" + newName;  
	        File desFile = new File(desFilePath);  
	        file.transferTo(desFile);  
	        // 6.返回保存结果信息  
	        dataMap.put("src","static/images/car/" + newName);
	        dataMap.put("code", 0);
	        dataMap.put("msg","上传成功！");  
	    } catch (IllegalStateException e) {  
	    	 dataMap.put("code", 1);
	        System.out.println(desFilePath + "图片保存失败");  
	    } catch (IOException e) {  
	    	 dataMap.put("code", 1);
	        System.out.println(desFilePath + "图片保存失败--IO异常");  
	    }  
	    return dataMap;  
	}  
	
}

public class CommonInterceptor extends HandlerInterceptorAdapter {

	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws ServletException, Exception {
		
        HttpSession session = request.getSession();  
        User user= (User)session.getAttribute("user");
	        if(user == null ){
	        	session.setAttribute("msg", "您还没有登录或登录已超时，请重新登录，然后再刷新本功能！");
//	        	request.setAttribute("msg", "您还没有登录或登录已超时，请重新登录，然后再刷新本功能！");
	        	response.sendRedirect(request.getContextPath());
//	        	request.getRequestDispatcher("/").forward(request, response);
	            return false;  
	        }

		Map<String, Object> paramMap=new HashMap<String, Object>();
		paramMap.put("orderId", orderId);
		//通过id查出只能是一条数据
 		List<Map<String, Object>> order = orderService.selectOrderByAttr(paramMap);
 		String[] imgurls = order.get(0).get("imgUrls").toString().split(",");
 		//查询机床
    	SStation station = stationService.selectByPrimaryKey(Integer.parseInt(order.get(0).get("s_id").toString()));
 		//查询工人 0在忙 1 空闲
 		List<Map<String, Object>> selWorkers = orderWorkerService.selectByOrderId(order.get(0).get("o_id").toString());
 		//查询所有零件
 		List<Map<String, Object>> selParts = orderPartService.selectByOrderId(order.get(0).get("o_id").toString());
 		
 		//查询所有待使用的机床
 		List<SStation> stations=stationService.selectAll(new HashMap<String, Object>(){{put("s_state", "完好待使用");}});
 		//查询所有空闲的工人 state=1空闲 2在忙 0离职
 		List<Worker> workers = workerService.selectWorkersByAttr(new Worker(){{setwState(1);}});
 		//查询所有可使用零件
 		List<Part> parts = partService.selectAll();
 		
 		request.setAttribute("imgurls",imgurls);
 		request.setAttribute("dealOrder",order.get(0));
 		request.setAttribute("stations",stations);
 		request.setAttribute("workers",workers);
 		request.setAttribute("parts",parts);
 		request.setAttribute("station",station);//已选中station
 		request.setAttribute("selWorkers",selWorkers);
 		request.setAttribute("selParts",selParts);
 		request.setAttribute("readonly", 0);//非只读
 		return "order/orderDetail";
	}
	
	/** 订单详情*/
	@RequestMapping("/detail")
	public String detail(HttpServletRequest request,String orderId){
		Map<String, Object> paramMap=new HashMap<String, Object>();
		paramMap.put("orderId", orderId);
		//通过id查出只能是一条数据
 		List<Map<String, Object>> order = orderService.selectOrderByAttr(paramMap);
 		Map<String, Object> orderMap = order.get(0);
 		String[] imgurls = orderMap.get("imgUrls").toString().split(",");
 		if (orderMap.get("s_id")==null) {
 			request.setAttribute("station",null);
 			request.setAttribute("selWorkers",null);
 			request.setAttribute("selParts",null);
 		}else{
 			//查询机床
 			SStation station = stationService.selectByPrimaryKey(Integer.parseInt(orderMap.get("s_id").toString()));
 			//查询工人 0在忙 1 空闲
 			List<Map<String, Object>> workers = orderWorkerService.selectByOrderId(orderMap.get("o_id").toString());
 			//查询所有零件

@Controller
@RequestMapping("/worker")
public class WorkerController extends BaseController {
	
	@Resource
	private WorkerService workerService;
	/**页面跳转*/
	@RequestMapping("/list")
	public String workList(HttpServletRequest request,HttpSession session,Worker worker){
		return "worker/worker_list";
	}
	/**数据获取*/
	@RequestMapping("/getData")
	@ResponseBody
	public String getData(HttpServletResponse response,HttpServletRequest request){
		Integer offset = Integer.parseInt(request.getParameter("offset"));//开始条数
		Integer limit = Integer.parseInt(request.getParameter("limit"));//每页条数
		Worker worker=new Worker();
		String workerName=request.getParameter("workerName");
		worker.setwName(workerName);
		List<Worker> wList = workerService.selectWorkersByAttr(worker);
		return TableData.getJson2Table(wList, offset, limit);

				parts.remove(i);
			}
		}
		request.setAttribute("parts", parts);
		return "home";
	}
	/**  */
	@RequestMapping("/reject")
	@ResponseBody
	public String rejectOrder(HttpServletRequest request,String orderId,String remark) {
		String success="1";
		//获取订单id 机床id 员工id集合 零件id num集合
		//修改订单状态 修改机床状态 更新order-worker order-part表
		try {
				
				Order order = orderService.selectByPrimaryKey(orderId);
				order.setoState("2");//3拒绝
				order.setRemark(remark);
				order.setEndtime(new Date());
				orderService.updateByPrimaryKeySelective(order);//更新order
				Car car = carService.selectByPrimaryKey(order.getCarId());
				car.setCarState(0);
				carService.updateByPrimaryKeySelective(car);
		} catch (Exception e) {
			success="0";
		}
		return success;
	}

}

	/** 订单*/
	@RequestMapping("/home")
	public String homePage(HttpServletRequest request,HttpSession sessions){
		List<Map<String, Object>> list= orderService.selectOrderByAttr(new HashMap<String, Object>(){{put("state", 0);}});
		request.setAttribute("count", list.size());
		List<String> yearMonths = DateUtils.getYearMonths(6);//获取半年日期
		request.setAttribute("yearMonths", yearMonths);
		
		List<Part> parts = partService.selectAll();
		for (int i = 0; i < parts.size(); i++) {
			if(parts.get(i).getPartNum()>parts.get(i).getWarning()){
				parts.remove(i);
			}
		}
		request.setAttribute("parts", parts);
		return "home";
	}
	/**  */
	@RequestMapping("/reject")
	@ResponseBody
	public String rejectOrder(HttpServletRequest request,String orderId,String remark) {
		String success="1";
		//获取订单id 机床id 员工id集合 零件id num集合
		//修改订单状态 修改机床状态 更新order-worker order-part表
		try {
				
				Order order = orderService.selectByPrimaryKey(orderId);
				order.setoState("2");//3拒绝
				order.setRemark(remark);
				order.setEndtime(new Date());
				orderService.updateByPrimaryKeySelective(order);//更新order
				Car car = carService.selectByPrimaryKey(order.getCarId());
				car.setCarState(0);
				carService.updateByPrimaryKeySelective(car);
		} catch (Exception e) {
			success="0";
		}
		return success;
	}

}

	}
}

/**
 */
public class BaseController {
	
	/**
	 * 将字符串以输出流的形式输出到浏览器的流中。
	 * 
	 * @param str
	 * @param response
	 */
	private void outString(String str, HttpServletResponse response) {
		try {
			response.setHeader("Content-type", "application/json;charset=UTF-8");
			response.getWriter().print(str);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void outJsonStr(String str,HttpServletResponse response){
		outString(str, response);
	}
	
	public void outObj2Json(Object obj,HttpServletResponse response){
		outString(JSON.toJSONString(obj), response);
	}
}

@Controller

		Car car = (Car) session.getAttribute("preCar");
		car.setCarState(1);
		int updateCar = carService.updateByPrimaryKeySelective(car);
		Order order = new Order();
		order.setOrderId(StringUtil.getStringId());
		order.setCarId(car.getCarId());
		order.setoDescribe(desc);
		// 0 预约中 1预约成功 2正在执行 3完成 4拒绝
		order.setoState("0");
		order.setArriveTime(arrDate);
		order.setOrdertime(new Date());
		order.setImgUrls(imgurls);
		int updateOrder = orderService.insertSelective(order);
		return updateOrder+updateCar;
	}

	/** 订单操作 */
	@RequestMapping("/manage")
	public String manageOrder(HttpServletRequest request, HttpSession session,String orderId) {
		Map<String, Object> paramMap=new HashMap<String, Object>();
		paramMap.put("orderId", orderId);
		//通过id查出只能是一条数据
 		List<Map<String, Object>> order = orderService.selectOrderByAttr(paramMap);
 		String[] imgurls = order.get(0).get("imgUrls").toString().split(",");
 		//查询所有待使用的机床
 		List<SStation> stations=stationService.selectAll(new HashMap<String, Object>(){{put("s_state", "完好待使用");}});
 		//查询所有空闲的工人 state=1空闲 2在忙 0离职
 		List<Worker> workers = workerService.selectWorkersByAttr(new Worker(){{setwState(1);}});
 		//查询所有可使用零件
 		List<Part> parts = partService.selectAll();
 		request.setAttribute("imgurls",imgurls);
 		request.setAttribute("dealOrder",order.get(0));
 		request.setAttribute("stations",stations);
 		request.setAttribute("workers",workers);
 		request.setAttribute("parts",parts);
 		return "order/manageOrder";
	}
	
	/** 页面跳转 */
	@RequestMapping("/list")

		String ids = request.getParameter("id");
		if(StringUtil.isNotEmpty(ids)){
			String[] wIds = ids.split(",");
			for (String wId : wIds) {
				workerService.deleteByPrimaryKey(wId);
			}
			return 1;
		}else{
			return 0;
		}
	}
	
	@RequestMapping("/getWorkData")
	@ResponseBody
	public List<Map<String,Object>> getWorkData(HttpServletRequest request,String month){
		Map<String,Object> param =new  HashMap<String, Object>();
		if (StringUtil.isEmpty(month)) {
			month=DateUtils.getYearMonths(1).get(0);
		}
		param.put("date", month);
		List<Map<String,Object>> selectWork = workerService.selectWork(param);
		request.setAttribute("selMonth", month);
		return selectWork;
	}
}

 			SStation station = stationService.selectByPrimaryKey(Integer.parseInt(orderMap.get("s_id").toString()));
 			//查询工人 0在忙 1 空闲
 			List<Map<String, Object>> workers = orderWorkerService.selectByOrderId(orderMap.get("o_id").toString());
 			//查询所有零件
 			List<Map<String, Object>> parts = orderPartService.selectByOrderId(orderMap.get("o_id").toString());
 			request.setAttribute("station",station);
 			request.setAttribute("selWorkers",workers);
 			request.setAttribute("selParts",parts);
 		}
 		request.setAttribute("imgurls",imgurls);
 		request.setAttribute("dealOrder",order.get(0));
 		request.setAttribute("readonly", 1);//只读
		return "order/orderDetail";
	}
	/** 订单*/
	@RequestMapping("/userOrder")
	public String userOrder(HttpServletRequest request,HttpSession sessions){
		User user= (User)sessions.getAttribute("userOn");
		Map<String,Object> paramMap=new HashMap<String, Object>();
		paramMap.put("userId", user.getuId());
		List<Map<String, Object>> orders = orderService.selectOrderByAttr(paramMap);//返回用户的多个订单
		request.setAttribute("orders", orders);
		return "order/userOrder";
	}
	@RequestMapping("/done")
	@ResponseBody
	public String doneOrder(HttpServletResponse response,HttpServletRequest request,String orderId) {
		String msg="1";
		//更新  1订单状态 2更新机床 3更新员工状态 4更新车辆状态
		List<Map<String,Object>> ws = orderWorkerService.selectByOrderId(orderId);
		Order order = orderService.selectByPrimaryKey(orderId);
		try {
			//1
			order.setEndtime(new Date());
			order.setoState("2");//2完成
			orderService.updateByPrimaryKeySelective(order);
			//2
			SStation station = stationService.selectByPrimaryKey(order.getStationId());
			station.setsState("完好待使用");
			stationService.updateByPrimaryKeySelective(station);
			//4
			Car car = carService.selectByPrimaryKey(order.getCarId());
			car.setCarState(0);
			carService.updateByPrimaryKeySelective(car);
			//3
			for (Map<String, Object> map : ws) {
				String wId= (String)map.get("w_id");
				Worker worker = workerService.selectByPrimaryKey(wId);
				worker.setwState(1);//1空闲
				workerService.updateByPrimaryKeySelective(worker);
			}

		int record=0;
		User user=(User)request.getSession().getAttribute("userOn");
		if( StringUtil.isEmpty(car.getCarId())){
			/*设置关联用户id*/
			car.setUserId(user.getuId());
			car.setCarId(StringUtil.getStringId());
			record= carService.insertSelective(car);
		}else{
			record= carService.updateByPrimaryKeySelective(car);
		}
		return record;
	}
	/**删除机床*/
	@RequestMapping("/delById")
	@ResponseBody
	public Integer deleteWorker(HttpServletRequest request){
		String ids = request.getParameter("id");
		if(StringUtil.isNotEmpty(ids)){
			String[] sIds = ids.split(",");
			for (String sId : sIds) {
				carService.deleteByPrimaryKey(sId);
			}
			return 1;
		}else{
			return 0;
		}
	}
	
	@RequestMapping("/selectCar")
	@ResponseBody
	public Integer selectCar(HttpServletRequest request,HttpSession session,String carId){
		if(!StringUtil.isEmpty(carId)){
			Car preCar = carService.selectByPrimaryKey(carId);
			session.setAttribute("preCar", preCar);
		}
		return 1;
	}
	
	
	@RequestMapping("/getCarTypeData")
	@ResponseBody
	public List<Map<String,Object>> getCarTypeData(HttpServletRequest request,String month){
		if(StringUtil.isEmpty(month)){
			month=DateUtils.getYearMonths(1).get(0);
		}
		Map<String,Object> map=new HashMap<String, Object>();
		map.put("date",month);
		List<Map<String,Object>> list = carService.selectCarTypeData(map);
		return list;
	}
}

@Controller
@RequestMapping("/user")
public class UserController extends BaseController {
	
	@Resource
	private UserService userService;
	
	@RequestMapping("/list")
	public String login(HttpServletRequest request,HttpSession session,User user){
		return "user/user_list";
	}
	/**
	 * 跳转至注册页面
	 * @return
	 */
	@RequestMapping("/toPage")
	public String toPage(){
		return "user/signUp";
	}

	/**
	 * 用户注册 uLevel默认为0 用户模式
	 * @param user
	 * @return 提示信息
	 */
	@RequestMapping("/signUp")
	@ResponseBody
	public int signUp(User user){
		int signUp =0;
		if(user!=null){
			signUp= userService.insertSelective(user);
		}
		return  signUp>0?0:1;
	}
	/**
	 * 验证登陆 成功跳转至管理页面 失败返回登录
	 * @param user
	 * @param session
	 * @return
	 */
	@RequestMapping("/login")
	public String login(User user,HttpSession session,Model model){
		String uri="";
		List<User> checkUserLogin = userService.checkUserLogin(user);
			if (checkUserLogin!=null && checkUserLogin.size()>0) {
				User user2 = checkUserLogin.get(0);
				session.setAttribute("userOn",user2 );
				session.setAttribute("msg", null);
				uri="index";
			}else{
				session.setAttribute("msg", "用户名或者密码错误");

		} catch (Exception e) {
			e.printStackTrace();
		}
		return "part/part_edit";
	}
	/**添加机床*/
	@RequestMapping("/add")
	@ResponseBody
	public Integer addWorker(HttpServletRequest request,Part part){
		int record=0;
		//设置最后编辑时间
		part.setLastbuydate(new Date());
		//获取工作人员Id
		if( StringUtil.isEmpty(part.getPartId())){
			/*设置id*/
			part.setPartId(StringUtil.getStringId());
			record= partService.insertSelective(part);
		}else{
			record= partService.updateByPrimaryKeySelective(part);
		}
		return record;
	}
	/**删除机床*/
	@RequestMapping("/delById")
	@ResponseBody
	public Integer deleteWorker(HttpServletRequest request){
		String ids = request.getParameter("id");
		if(StringUtil.isNotEmpty(ids)){
			String[] sIds = ids.split(",");
			for (String sId : sIds) {
				partService.deleteByPrimaryKey(sId);
			}
			return 1;
		}else{
			return 0;
		}
	}
}

@Controller
@RequestMapping("/order")
public class OrderController extends BaseController {

	private final Integer WARNING_COUNT=20;
	
	@Resource
	private CarService carService;

	@Resource
	private StationService stationService;

	@Resource
	private PartService partService;
	@Resource
	private OrderPartService orderPartService;
	
	@Resource
	private OrderWorkerService orderWorkerService;

	@Resource
	private WorkerService workerService;

	@Resource
	private OrderService orderService;

	/** 页面跳转 预定页面 */
	@RequestMapping("/toPreOrder")
	public String toPreOrder(HttpServletRequest request, HttpSession session,

		try {
			//1
			order.setEndtime(new Date());
			order.setoState("2");//2完成
			orderService.updateByPrimaryKeySelective(order);
			//2
			SStation station = stationService.selectByPrimaryKey(order.getStationId());
			station.setsState("完好待使用");
			stationService.updateByPrimaryKeySelective(station);
			//4
			Car car = carService.selectByPrimaryKey(order.getCarId());
			car.setCarState(0);
			carService.updateByPrimaryKeySelective(car);
			//3
			for (Map<String, Object> map : ws) {
				String wId= (String)map.get("w_id");
				Worker worker = workerService.selectByPrimaryKey(wId);
				worker.setwState(1);//1空闲
				workerService.updateByPrimaryKeySelective(worker);
			}
		} catch (Exception e) {
			msg="0";
		}
		return msg;
	}
	
	/** 订单*/
	@RequestMapping("/home")
	public String homePage(HttpServletRequest request,HttpSession sessions){
		List<Map<String, Object>> list= orderService.selectOrderByAttr(new HashMap<String, Object>(){{put("state", 0);}});
		request.setAttribute("count", list.size());
		List<String> yearMonths = DateUtils.getYearMonths(6);//获取半年日期
		request.setAttribute("yearMonths", yearMonths);
		
		List<Part> parts = partService.selectAll();
		for (int i = 0; i < parts.size(); i++) {
			if(parts.get(i).getPartNum()>parts.get(i).getWarning()){
				parts.remove(i);
			}
		}
		request.setAttribute("parts", parts);
		return "home";
	}
	/**  */
	@RequestMapping("/reject")

		Map<String, Object> paramMap=new HashMap<String, Object>();
		paramMap.put("orderId", orderId);
		//通过id查出只能是一条数据
 		List<Map<String, Object>> order = orderService.selectOrderByAttr(paramMap);
 		Map<String, Object> orderMap = order.get(0);
 		String[] imgurls = orderMap.get("imgUrls").toString().split(",");
 		if (orderMap.get("s_id")==null) {
 			request.setAttribute("station",null);
 			request.setAttribute("selWorkers",null);
 			request.setAttribute("selParts",null);
 		}else{
 			//查询机床
 			SStation station = stationService.selectByPrimaryKey(Integer.parseInt(orderMap.get("s_id").toString()));
 			//查询工人 0在忙 1 空闲
 			List<Map<String, Object>> workers = orderWorkerService.selectByOrderId(orderMap.get("o_id").toString());
 			//查询所有零件
 			List<Map<String, Object>> parts = orderPartService.selectByOrderId(orderMap.get("o_id").toString());
 			request.setAttribute("station",station);
 			request.setAttribute("selWorkers",workers);
 			request.setAttribute("selParts",parts);
 		}
 		request.setAttribute("imgurls",imgurls);
 		request.setAttribute("dealOrder",order.get(0));
 		request.setAttribute("readonly", 1);//只读
		return "order/orderDetail";
	}
	/** 订单*/
	@RequestMapping("/userOrder")
	public String userOrder(HttpServletRequest request,HttpSession sessions){
		User user= (User)sessions.getAttribute("userOn");
		Map<String,Object> paramMap=new HashMap<String, Object>();
		paramMap.put("userId", user.getuId());
		List<Map<String, Object>> orders = orderService.selectOrderByAttr(paramMap);//返回用户的多个订单
		request.setAttribute("orders", orders);
		return "order/userOrder";
	}
	@RequestMapping("/done")
	@ResponseBody
	public String doneOrder(HttpServletResponse response,HttpServletRequest request,String orderId) {
		String msg="1";
		//更新  1订单状态 2更新机床 3更新员工状态 4更新车辆状态
		List<Map<String,Object>> ws = orderWorkerService.selectByOrderId(orderId);
		Order order = orderService.selectByPrimaryKey(orderId);
		try {
			//1
			order.setEndtime(new Date());
			order.setoState("2");//2完成
			orderService.updateByPrimaryKeySelective(order);
			//2

@Controller
@RequestMapping("/worker")
public class WorkerController extends BaseController {
	
	@Resource
	private WorkerService workerService;
	/**页面跳转*/
	@RequestMapping("/list")
	public String workList(HttpServletRequest request,HttpSession session,Worker worker){
		return "worker/worker_list";
	}
	/**数据获取*/
	@RequestMapping("/getData")
	@ResponseBody
	public String getData(HttpServletResponse response,HttpServletRequest request){
		Integer offset = Integer.parseInt(request.getParameter("offset"));//开始条数
		Integer limit = Integer.parseInt(request.getParameter("limit"));//每页条数
		Worker worker=new Worker();
		String workerName=request.getParameter("workerName");
		worker.setwName(workerName);
		List<Worker> wList = workerService.selectWorkersByAttr(worker);
		return TableData.getJson2Table(wList, offset, limit);
	}
	/**编辑员工信息 */
	@RequestMapping("/edit")
	public String addWork(HttpServletRequest request,Model model){
		try {
			String id = request.getParameter("id");
			Worker worker = null;
			if(StringUtil.isEmpty(id)){
				worker = new Worker();
			}else{
				worker = workerService.selectByPrimaryKey(id);
			}
			model.addAttribute("worker", worker);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "worker/worker_edit";
	}
	/**添加员工*/
	@RequestMapping("/add")
	@ResponseBody
	public Integer addWorker(HttpServletRequest request,Worker worker){
		int record;

				Worker worker = workerService.selectByPrimaryKey(wId);
				worker.setwState(1);//1空闲
				workerService.updateByPrimaryKeySelective(worker);
			}
		} catch (Exception e) {
			msg="0";
		}
		return msg;
	}
	
	/** 订单*/
	@RequestMapping("/home")
	public String homePage(HttpServletRequest request,HttpSession sessions){
		List<Map<String, Object>> list= orderService.selectOrderByAttr(new HashMap<String, Object>(){{put("state", 0);}});
		request.setAttribute("count", list.size());
		List<String> yearMonths = DateUtils.getYearMonths(6);//获取半年日期
		request.setAttribute("yearMonths", yearMonths);
		
		List<Part> parts = partService.selectAll();
		for (int i = 0; i < parts.size(); i++) {
			if(parts.get(i).getPartNum()>parts.get(i).getWarning()){
				parts.remove(i);
			}
		}
		request.setAttribute("parts", parts);
		return "home";
	}
	/**  */
	@RequestMapping("/reject")
	@ResponseBody
	public String rejectOrder(HttpServletRequest request,String orderId,String remark) {
		String success="1";
		//获取订单id 机床id 员工id集合 零件id num集合
		//修改订单状态 修改机床状态 更新order-worker order-part表
		try {
				
				Order order = orderService.selectByPrimaryKey(orderId);
				order.setoState("2");//3拒绝
				order.setRemark(remark);
				order.setEndtime(new Date());
				orderService.updateByPrimaryKeySelective(order);//更新order
				Car car = carService.selectByPrimaryKey(order.getCarId());
				car.setCarState(0);
				carService.updateByPrimaryKeySelective(car);
		} catch (Exception e) {
			success="0";
		}
		return success;
	}

 		List<Worker> workers = workerService.selectWorkersByAttr(new Worker(){{setwState(1);}});
 		//查询所有可使用零件
 		List<Part> parts = partService.selectAll();
 		request.setAttribute("imgurls",imgurls);
 		request.setAttribute("dealOrder",order.get(0));
 		request.setAttribute("stations",stations);
 		request.setAttribute("workers",workers);
 		request.setAttribute("parts",parts);
 		return "order/manageOrder";
	}
	
	/** 页面跳转 */
	@RequestMapping("/list")
	public String workList(HttpServletRequest request, HttpSession session,String state) {
		Map<String, Object> paramMap=new HashMap<String, Object>();
		paramMap.put("state", state);
 		List<Map<String, Object>> order = orderService.selectOrderByAttr(paramMap);
 		session.setAttribute("order", order);
 		request.setAttribute("state", state);
		return "order/order_list";
	}

	/**  */
	@RequestMapping("/accept")
	@ResponseBody
	public String acceptOrder(HttpServletResponse response,HttpServletRequest request,String orderId,
			String remark,String stationId) {
		String success="1";
		//获取订单id 机床id 员工id集合 零件id num集合
		String selectedWorker=request.getParameter("selectedWorker");
		String[] workers = selectedWorker.split(",");
		String selParts=request.getParameter("parts");
		JSONArray parts=JSONArray.parseArray(selParts);
		//修改订单状态 修改机床状态 更新order-worker order-part表
		try {
				
				Order order = orderService.selectByPrimaryKey(orderId);
				order.setStationId(Integer.parseInt(stationId));
				order.setoState("1");//1进行中
				order.setRemark(remark);
				order.setBegintime(new Date());
				orderService.updateByPrimaryKeySelective(order);//更新order
				
				SStation station = stationService.selectByPrimaryKey(Integer.parseInt(stationId));
				station.setsState("完好在使用");