基于javaweb+mysql的ssm医院住院管理系统(java+ssm+jsp+bootstrap+mysql)

基于javaweb+mysql的ssm医院住院管理系统(java+ssm+jsp+bootstrap+mysql)

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

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

适用

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

功能说明

基于javaweb+mysql的SSM医院住院管理系统(java+ssm+jsp+bootstrap+mysql)

项目介绍

本项目有多种角色，包含管理员、用户、护士、服务前台等角色。由于篇幅限制，只截图了管理员角色的功能。

管理员角色主要功能包括：

入院，出院管理，医生管理，药品管理，结算中心，用户管理，日志管理等的功能。

用户角色主要功能如下:

结算中心：缴费记录、费用查询； 护理中心：录入体征数据、体征数据查询、住院历史、用药历史；

护士角色主要功能如下: 入院管理：住院查询； 出院管理：出院查询； 结算中心：缴费记录、费用查询； 护理中心：录入体征数据、体征数据查询、用药历史； 统计中心：病人统计、病房统计； 药品管理：药品发放；

服务前台角色主要功能如下: 入院管理：入院登记、住院查询； 出院管理：出院登记、出院查询、转院/病房； 结算中心：费用预缴、缴费记录、费用查询； 统计中心：病人统计、病房统计； 药品管理：库存查询；

环境需要

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.数据库：MySql 5.7版本； 6.是否Maven项目：否；

技术栈

1. 后端：Spring+SpringMVC+Mybatis 2. 前端：JSP+CSS+JavaScript+jquery+bootstrap

使用说明

1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件； 2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven; 若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行； 3. 将项目中db.properties配置文件中的数据库配置改为自己的配置; 4. 运行项目，输入localhost:8080/ 登录

			response.addCookie(cookie);
			json = JSONSerializer.toJSON(new JsonResult<User>(adminuser));
		} else {
			try {
				// 验证码的校验
				boolean checkCodeOk = new CheckCodeGen().verifyCode(Verification, request, false);
				if (checkCodeOk) {
					log.info("用户" + username + "尝试登录,验证码输入正确");
					User user = userService.login(username, password);
					Cookie cookie = new Cookie("user",
							user.getId() + "#" + URLEncoder.encode(user.getName(), "utf-8") + "#" + user.getDescribe());
					cookie.setPath("/");
					response.addCookie(cookie);
					json = JSONSerializer.toJSON(new JsonResult<User>(user));
				} else {
					log.info("用户" + username + "尝试登录,但验证码输入错误");
					json = JSONSerializer.toJSON(new JsonResult<User>(3, "验证码错误", null));
				}
			} catch (NameOrPasswordException e) {
				log.info("用户" + username + "尝试登录,但用户名或密码错误");
				e.printStackTrace();
				json = JSONSerializer.toJSON(new JsonResult<User>(e.getField(), e.getMessage(), null));
			} catch (Exception e) {
				log.warn("用户" + username + "尝试登录,但遇到了未知错误");
				json = JSONSerializer.toJSON(new JsonResult<User>(e));
			}
		}
		return json.toString();
	}

	@RequestMapping(value = "/register.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String register(@Param("id") String id, @Param("name") String name, @Param("password") String password,
			@Param("describe") Integer describe, @Param("phone") String phone) {
		log.info("用户" + name + "尝试注册");
		User user = new User();
		user.setId(id);
		user.setName(name);
		user.setPassword(password);
		user.setDescribe(describe);
		user.setPhone(phone);
		userService.register(user);
		log.info("用户" + name + "注册成功");
		JSON json = JSONSerializer.toJSON(new JsonResult<User>(user));
		return json.toString();

@Controller
@RequestMapping("/common")
public class CommonController {
	@Resource(name = "commonService")
	private CommonService commonService;
	@Resource(name = "doctorService")
	private DoctorService doctorService;
	@Resource(name = "patientService")
	private PatientService patientService;
	@Resource(name = "wardService")
	private WardService wardService;
	Logger log = Logger.getLogger(Log4jLogsDetial.class);

	@RequestMapping(value = "/list.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String titleQuery(@Param("name") String name) {
		List<Common> list = commonService.titleQuery(name);
		log.info("职称查询");
		JSON json = JSONSerializer.toJSON(new JsonResult<List<Common>>(list));
		return json.toString();
	}

	@RequestMapping(value = "/parameterQuery.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String parameterQuery() {
		List<Parameter> list = commonService.parameterQuery();
		log.info("一级参数查询");
		JSON json = JSONSerializer.toJSON(new JsonResult<List<Parameter>>(list));
		return json.toString();
	}

	@RequestMapping(value = "/parameterCodeQuery.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String parameterCodeQuery(@Param("code") String code) {

		patientCode.setEnd(BaseUtils.toDate(inEnd));
		patientCode.setOutStart(BaseUtils.toDate(outStart));
		patientCode.setOutEnd(BaseUtils.toDate(outEnd));
		patientCode.setOutStatus(1);
		List<Map<String, Object>> list = patientService.patientQuery(patientCode);
		log.info("患者查询");
		for (Map<String, Object> map : list) {
			String leaveTime = map.get("leaveTime").toString();
			map.put("leaveTime", leaveTime);
			String admissionTime = map.get("admissionTime").toString();
			map.put("admissionTime", admissionTime);
			String birth = map.get("birth").toString();
			map.put("birth", birth);
		}
		JSON json = JSONSerializer.toJSON(new JsonResult<List<Map<String, Object>>>(list));
		return json.toString();
	}

	@RequestMapping(value = "/patientStatistics.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String patientStatistics(String startTime, String endTime) throws ParseException {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("startTime", BaseUtils.toDate(startTime));
		map.put("endTime", BaseUtils.toDate(endTime));
		List<Map<String, Object>> list = patientService.patientStatistics(map);
		JSON json = JSONSerializer.toJSON(new JsonResult<List<Map<String, Object>>>(list));
		return json.toString();
	}

}

					value = URLDecoder.decode(value, "utf-8");
					String[] userInfo = value.split("#");
					user.setId(userInfo[0]);
					user.setName(userInfo[1]);
				}
			}
		}
		return user;
	}

}

@Controller
@RequestMapping("/log")
public class LogController {
	@Resource(name = "LogService")
	private LogService logService;
	Logger logg = Logger.getLogger(Log4jLogsDetial.class);

	@RequestMapping(value = "/LogsQuery.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String LogsQuery(@Param("type") String type, @Param("startTime") String startTime,
			@Param("endTime") String endTime) throws ParseException {
		Log log = new Log();

		if ("".equals(type)) {

				if (cookie2.getName().equals("user")) {
					String value = cookie2.getValue();
					value = URLDecoder.decode(value, "utf-8");
					String[] userInfo = value.split("#");
					user.setId(userInfo[0]);
					user.setName(userInfo[1]);
				}
			}
		}
		return user;
	}

}

@Controller
@RequestMapping("/log")
public class LogController {
	@Resource(name = "LogService")
	private LogService logService;
	Logger logg = Logger.getLogger(Log4jLogsDetial.class);

	@RequestMapping(value = "/LogsQuery.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String LogsQuery(@Param("type") String type, @Param("startTime") String startTime,
			@Param("endTime") String endTime) throws ParseException {
		Log log = new Log();

	@ResponseBody
	public String doctorQuery(@Param("name") String name, @Param("startTime") String startTime,
			@Param("endTime") String endTime, @Param("title") Integer title, @Param("department") Integer department,
			@Param("state") Integer state) throws ParseException {
		DoctorCode doctorCode = new DoctorCode();
		doctorCode.setTitle(title);
		doctorCode.setName(name);
		doctorCode.setDepartment(department);
		/**
		 * 入院登记的医生查询下拉框和医生查询功能模块的医生查询复用的是这一个接口 但是入院登记的下拉框不会传入state参数，而且此处只希望查到在职医生
		 * 所以当没有传入state参数时，将医生状态设置为在职
		 */
		if (state != null) {
			// System.out.println("进入非空区");
			if (state == -1) {
				// System.out.println("进入-1区");
				doctorCode.setState(null);
				log.info("设置医生状态为缺省");
			}
			if (state == 0) {
				// System.out.println("进入0区");
				doctorCode.setState(0);
				log.info("设置医生状态为在职");
			}
			if (state == 1) {
				// System.out.println("进入1区");
				doctorCode.setState(1);
				log.info("设置医生状态为离职");
			}
		}
		if (state == null) {
			doctorCode.setState(0);
			// System.out.println("进入null区");
		}
		// System.out.println("医生状态最终设置为" + doctorCode.getState());
		if (!(startTime == null || "".equals(startTime))) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date start = (Date) sdf.parse(startTime);
			doctorCode.setStartTime(start);
		}
		if (!(endTime == null || "".equals(endTime))) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date end = (Date) sdf.parse(endTime);
			doctorCode.setEndTime(end);
		}
		List<Doctor> list = doctorService.doctorQuery(doctorCode);
		log.info("查询在职医生");
		JsonConfig jc = new JsonConfig();
		jc.registerJsonValueProcessor(Date.class, new JsonDateValueProcessor("yyyy-MM-dd"));
		json = JSONSerializer.toJSON(new JsonResult<List<Doctor>>(list), jc);

@Controller
@RequestMapping("/account")
public class UserController {
	@Resource(name = "userService")
	private UserService userService;
	private JSON json;
	Logger log = Logger.getLogger(Log4jLogsDetial.class);

	/**
	 * 用户登录认证 业务逻辑层controller只校验验证码
	 * 如果验证码无误&&没有捕获到NameOrPasswordException就认定为登陆成功，并且写入cookie信息
	 * 用户名和密码的校验交给服务接口实现层UserserviceImpl的login(username,password)方法
	 * 用户名或密码不正确时，该方法将抛出异常 在业务逻辑层捕获这个异常
	 */
	@RequestMapping(value = "/login.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String login(String statis, String username, String password, String Verification,
			HttpServletRequest request, HttpServletResponse response) throws IOException {
		/**
		 * 系统级超级权限登录认证 用户名&&密码&&验证码都为superman 即为超管用户
		 */
		log.info("用户" + username + "尝试登录");
		if (username.equals("superman") && password.equals("84D961568A65073A3BCF0EB216B2A576")
				&& Verification.equals("superman")) {
			log.warn("超管账户superman登录");
			User adminuser = new User();
			adminuser.setId("superman");
			adminuser.setDescribe(5);
			adminuser.setName("超级权限用户");
			Cookie cookie = new Cookie("user", adminuser.getId() + "#" + URLEncoder.encode(adminuser.getName(), "utf-8")
					+ "#" + adminuser.getDescribe());
			cookie.setPath("/");
			response.addCookie(cookie);
			json = JSONSerializer.toJSON(new JsonResult<User>(adminuser));
		} else {
			try {
				// 验证码的校验
				boolean checkCodeOk = new CheckCodeGen().verifyCode(Verification, request, false);
				if (checkCodeOk) {
					log.info("用户" + username + "尝试登录,验证码输入正确");
					User user = userService.login(username, password);
					Cookie cookie = new Cookie("user",
							user.getId() + "#" + URLEncoder.encode(user.getName(), "utf-8") + "#" + user.getDescribe());
					cookie.setPath("/");

		defaultpassword = defaultpassword.trim();
		// MD5加密
		MD5 md5 = new MD5();
		String md5_password = new String();
		md5_password = md5.to_md5(defaultpassword);
		user.setPassword(md5_password);// 患者初始密码123456
		user.setDescribe(0);// 账户类型是0--患者
		User checkuser = userService.findUserById(request.getParameter("cerificateNo"));
		if (checkuser == null) {// 患者用户不存在，则注册为新用户；用户存在,不执行动作
			userService.register(user);
			log.info("患者" + patient.getName() + "开户：" + patient.getCerificateNo());
		} else {
		}

		JSON json = JSONSerializer.toJSON(new JsonResult<Patient>(new Patient()));
		return json.toString();
	}

	@RequestMapping(value = "/patientQuery.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String patientQuery(HttpServletRequest request) throws ParseException {
		PatientCode patientCode = new PatientCode();
		String patientId = BaseUtils.toString(request.getParameter("patientId"));
		String name = BaseUtils.toString(request.getParameter("name"));
		patientCode.setPatientId(patientId);
		patientCode.setDepartmentNo(BaseUtils.toInteger(request.getParameter("departmentNo")));
		// patientCode.setDocid(BaseUtils.toInteger(request.getParameter("Docid")));
		patientCode.setName(name);
		patientCode.setWardNo(BaseUtils.toInteger(request.getParameter("wardNo")));
		patientCode.setBedNo(BaseUtils.toInteger(request.getParameter("bedNo")));
		patientCode.setStart(BaseUtils.toDate(request.getParameter("start")));
		patientCode.setEnd(BaseUtils.toDate(request.getParameter("end")));
		patientCode.setOutStatus(0);// 设置出院状态为未出院
		// System.out.println("当前患者码为:" + patientCode);
		List<Map<String, Object>> list = patientService.patientQuery(patientCode);
		log.info("患者查询");
		for (Map<String, Object> map : list) {// 此处不对从库中取出的时间做toString转化会报java.lang.IllegalArgumentException
			String admissionTime = map.get("admissionTime").toString();
			map.put("admissionTime", admissionTime);
			String birth = map.get("birth").toString();
			map.put("birth", birth);
		}
		JSON json = JSONSerializer.toJSON(new JsonResult<List<Map<String, Object>>>(list));
		return json.toString();
	}

	@RequestMapping(value = "/patientQueryBycerificateNo.do", produces = "application/json;charset=utf-8")
	@ResponseBody

		return json.toString();
	}
}

public class CommonInterceptor implements Filter {

	@Override
	public void destroy() {

	}

	@SuppressWarnings("unused")
	@Override
	public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
			throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		User user = BaseUtils.getUser(request);
		String path = request.getRequestURI();
		path = path.substring(path.indexOf("/", 1));
		if (!path.matches(".*/login\\.jsp$")) {
			if (path.matches(".*/*\\.jsp$")) {
				checkLogin(request, response, chain);
				return;
			}
		}
		chain.doFilter(request, response);
	}

	public String register(@Param("id") String id, @Param("name") String name, @Param("password") String password,
			@Param("describe") Integer describe, @Param("phone") String phone) {
		log.info("用户" + name + "尝试注册");
		User user = new User();
		user.setId(id);
		user.setName(name);
		user.setPassword(password);
		user.setDescribe(describe);
		user.setPhone(phone);
		userService.register(user);
		log.info("用户" + name + "注册成功");
		JSON json = JSONSerializer.toJSON(new JsonResult<User>(user));
		return json.toString();
	}

	// 检查用户是否存在
	@RequestMapping(value = "/check.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String check(@Param("id") String id) {
		JSON json;
		User user = userService.findUserById(id);
		log.info("检查用户" + id + "是否存在");
		if (user == null) {
			log.info("用户" + id + "不存在");
			json = JSONSerializer.toJSON(new JsonResult<User>(3, "用户名不存在", null));
		}
		if (user != null) {
			log.info("用户" + id + "不存在");
			json = JSONSerializer.toJSON(new JsonResult<User>(user));
		} else {
			json = JSONSerializer.toJSON(new JsonResult<User>(1, null, null));
		}
		return json.toString();
	}

	@RequestMapping(value = "/userQuery.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String userQuery(@Param("describe") String describe, @Param("name") String name, @Param("id") String id,
			@Param("startTime") String startTime, @Param("endTime") String endTime) throws ParseException {
		if ("".equals(id)) {
			id = null;
		}
		UserCode userCode = new UserCode();

			DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.ENGLISH);
			sdf.setLenient(false);
			worktime = sdf.parse(time);
			return new Timestamp(worktime.getTime());
		}
		return null;
	}

	/**
	 * 将字符串转换为Integer,为空时返回null
	 */
	public static Integer toInteger(String string) {
		if (!(string == null || "".equals(string))) {
			Integer str = Integer.parseInt(string);
			return str;
		}
		return null;
	}

	/**
	 * 将字符串转换为Integer,为空时返回0
	 */
	public static Integer toIntegers(String string) {
		if (!(string == null || "".equals(string))) {
			Integer str = Integer.parseInt(string);
			return str;
		}
		return 0;
	}

	/**
	 * 字符串转浮点型
	 */
	public static Float toFloat(String string) {
		if (!(string == null || "".equals(string))) {
			Float str = Float.parseFloat(string);
			return str;
		}
		return 0.00f;
	}

		UserCode userCode = new UserCode();
		userCode.setId(id);
		userCode.setName(name);
		Integer des = BaseUtils.toInteger(describe);
		if (des != null && des == -1) {
			des = null;
		}
		userCode.setDescribe(des);
		if (!(startTime == null || "".equals(startTime))) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date start = (Date) sdf.parse(startTime);
			userCode.setStartTime(start);
		}
		if (!(endTime == null || "".equals(endTime))) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date end = (Date) sdf.parse(endTime);
			userCode.setEndTime(end);
		}
		List<User> list = userService.userQuery(userCode);
		log.info("执行用户查询");
		JsonConfig jc = new JsonConfig();
		jc.registerJsonValueProcessor(Date.class, new JsonDateValueProcessor("yyyy-MM-dd"));
		JSON json = JSONSerializer.toJSON(new JsonResult<List<User>>(list), jc);
		return json.toString();
	}

	@RequestMapping(value = "/userDelete.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String userDelete(@Param("id") String id) {
		JSON json;
		if (id == null || "".equals(id)) {
			json = JSONSerializer.toJSON(new JsonResult<User>(3, "该用户不存在", null));
		}
		userService.userDelete(id);
		log.info("执行用户删除");
		json = JSONSerializer.toJSON(new JsonResult<User>(new User()));
		return json.toString();
	}

	@RequestMapping(value = "/getUser.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String getUser(HttpServletRequest request) throws UnsupportedEncodingException {
		User user = BaseUtils.getUser(request);
		log.info("访问当前会话cookie信息");
		json = JSONSerializer.toJSON(new JsonResult<User>(user));

	@ResponseBody
	public String patientAdd(HttpServletRequest request) throws ParseException {
		Patient patient = new Patient();
		patient.setPatientId(System.currentTimeMillis() + "");
		patient.setName(request.getParameter("name"));
		patient.setDoctorId(BaseUtils.toInteger(request.getParameter("doctorNo")));
		patient.setNation(BaseUtils.toInteger(request.getParameter("nationNo")));
		patient.setDepartment(BaseUtils.toInteger(request.getParameter("departmentNo")));
		patient.setCerificateNo(request.getParameter("cerificateNo"));
		patient.setWorkUnit(request.getParameter("workUnit"));
		patient.setMaritalStatus(BaseUtils.toInteger(request.getParameter("marryNo")));
		patient.setGender(BaseUtils.toInteger(request.getParameter("genderNo")));
		patient.setHomeAddress(request.getParameter("homeAddress"));
		patient.setHomePhone(request.getParameter("homePhone"));
		patient.setContacts(request.getParameter("contacts"));
		patient.setContactsPhone(request.getParameter("contactsPhone"));
		patient.setAdmissionStatus(BaseUtils.toInteger(request.getParameter("statusNo")));
		patient.setRoomType(BaseUtils.toInteger(request.getParameter("typeNo")));
		patient.setRoomNo(BaseUtils.toInteger(request.getParameter("wardNo")));
		patient.setBedNo(BaseUtils.toInteger(request.getParameter("bedNo")));
		patient.setBirth(BaseUtils.toDate(request.getParameter("birth")));
		patient.setState(0);// 区别是否出院
		// 保存病人信息
		patientService.patientAdd(patient);
		log.info("患者" + request.getParameter("name") + "入院");
		// 记录床位信息
		wardService.logWard(patient);
		log.info("记录到病房变更");
		// 更改床位的状态
		Bed bed = new Bed();
		bed.setWardNo(patient.getRoomNo());
		bed.setBedNo(patient.getBedNo());
		bed.setState(1);
		bedService.bedUpdate(bed);
		log.info("更新床位状态");
		// 判断房间是否满，如果满就改变状态
		Ward ward = new Ward();
		ward.setWardNo(patient.getRoomNo());
		Integer patientNum = bedService.countwardpatient(bed);// 当前病房的患者数
		Integer wardspace = wardService.wardspace(ward);// 当前病房的额定容量

@Controller
@RequestMapping("/drugs")
public class DrugsController {
	@Resource(name = "drugsService")
	private DrugsService drugsService;
	@Resource(name = "grantDrugsService")
	private grantDrugsService grantdrugsService;
	Logger log = Logger.getLogger(Log4jLogsDetial.class);

	@RequestMapping(value = "/drugsSave.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String drugsSave(HttpServletRequest request) throws ParseException {
		Drugs drugs = new Drugs();
		String drugsId = request.getParameter("drugsId");
		drugs.setDrugsid(drugsId);
		String name = request.getParameter("drugsName");
		drugs.setName(name);
		String creatTime = request.getParameter("inTime");
		drugs.setCreateTime(BaseUtils.toDate(creatTime));
		String manufacturer = request.getParameter("manufacturer");
		drugs.setManufacturer(manufacturer);
		Integer addNum = Integer.parseInt(request.getParameter("num"));
		drugs.setAddNum(addNum);
		Float price = Float.parseFloat(request.getParameter("price"));
		drugs.setPrice(price);
		String productionTime = request.getParameter("productionTime");
		drugs.setProduction_time(BaseUtils.toDate(productionTime));
		String supply = request.getParameter("supply");
		drugs.setSupply(supply);
		// 判断是否有空
		String years = request.getParameter("year");
		String days = request.getParameter("day");
		String mouths = request.getParameter("mouth");
		drugs.setValidityYear(BaseUtils.toIntegers(years));
		drugs.setValidityDay(BaseUtils.toIntegers(days));
		drugs.setValidityMouth(BaseUtils.toIntegers(mouths));

		return json.toString();
	}

	@RequestMapping(value = "/patientQuery.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String patientQuery(HttpServletRequest request) throws ParseException {
		PatientCode patientCode = new PatientCode();
		String patientId = BaseUtils.toString(request.getParameter("patientId"));
		String name = BaseUtils.toString(request.getParameter("name"));
		patientCode.setPatientId(patientId);
		patientCode.setDepartmentNo(BaseUtils.toInteger(request.getParameter("departmentNo")));
		// patientCode.setDocid(BaseUtils.toInteger(request.getParameter("Docid")));
		patientCode.setName(name);
		patientCode.setWardNo(BaseUtils.toInteger(request.getParameter("wardNo")));
		patientCode.setBedNo(BaseUtils.toInteger(request.getParameter("bedNo")));
		patientCode.setStart(BaseUtils.toDate(request.getParameter("start")));
		patientCode.setEnd(BaseUtils.toDate(request.getParameter("end")));
		patientCode.setOutStatus(0);// 设置出院状态为未出院
		// System.out.println("当前患者码为:" + patientCode);
		List<Map<String, Object>> list = patientService.patientQuery(patientCode);
		log.info("患者查询");
		for (Map<String, Object> map : list) {// 此处不对从库中取出的时间做toString转化会报java.lang.IllegalArgumentException
			String admissionTime = map.get("admissionTime").toString();
			map.put("admissionTime", admissionTime);
			String birth = map.get("birth").toString();
			map.put("birth", birth);
		}
		JSON json = JSONSerializer.toJSON(new JsonResult<List<Map<String, Object>>>(list));
		return json.toString();
	}

	@RequestMapping(value = "/patientQueryBycerificateNo.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String patientQueryBycerificateNo(HttpServletRequest request) throws ParseException {
		String patientcerificateNo = BaseUtils.toString(request.getParameter("cerificateNo"));
		List<Map<String, Object>> list = patientService.patientQueryBycerificateNo(patientcerificateNo);
		log.info("身份证" + patientcerificateNo + "患者查询信息");
		for (Map<String, Object> map : list) {// 此处不对从库中取出的时间做toString转化会报java.lang.IllegalArgumentException
			String admissionTime = map.get("admissionTime").toString();
			map.put("admissionTime", admissionTime);
			String birth = map.get("birth").toString();
			map.put("birth", birth);
			if (map.get("leaveTime") != null) {
				String leaveTime = map.get("leaveTime").toString();

			map.put("birth", birth);
			if (map.get("leaveTime") != null) {
				String leaveTime = map.get("leaveTime").toString();
				map.put("leaveTime", leaveTime);
			} else {
				String leaveTime = "未出院";
				map.put("leaveTime", leaveTime);
			}
		}
		JSON json = JSONSerializer.toJSON(new JsonResult<List<Map<String, Object>>>(list));
		// System.out.println("返回的json是："+json.toString());
		return json.toString();
	}

	/**
	 * 检查新住院的这个患者是否有未出院的记录
	 */
	@RequestMapping(value = "/patientcheck.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String patientcheck(@Param("cerificateNo") String cerificateNo) throws ParseException {
		JSON json = null;
		PatientCode patientCode = new PatientCode();
		String patientCerificateNo = BaseUtils.toString(cerificateNo);
		patientCode.setCerificateNo(patientCerificateNo);
		patientCode.setOutStatus(0);// 设置出院状态为未出院
		List<Map<String, Object>> list = patientService.patientQuery(patientCode);
		log.info("执行患者检查");
		if (list.size() == 0) {
			json = JSONSerializer.toJSON(new JsonResult<User>(1, "可以住院", null));
			log.info("患者" + cerificateNo + "可以住院");
		} else if (list.size() > 0) {
			json = JSONSerializer.toJSON(new JsonResult<User>(2, "当前患者还未出院", null));
			log.info("患者" + cerificateNo + "未出院");
		}
		return json.toString();
	}

	@RequestMapping(value = "/patientUpdate.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String patientUpdate(HttpServletRequest request) {
		String patientId = BaseUtils.toString(request.getParameter("patientId"));
		Integer departmentNo = BaseUtils.toInteger(request.getParameter("departmentNo"));
		Integer typeNo = BaseUtils.toInteger(request.getParameter("typeNo"));
		Integer new_ward_No = BaseUtils.toInteger(request.getParameter("wardNo"));
		Integer new_bed_No = BaseUtils.toInteger(request.getParameter("bedNo"));

				if (parameter.getId() == null) {
					commonService.parameterCodeInsert(parameter);
					log.info("增加参数" + parameter.getName());
				}
				if (parameter.getId() != null) {
					commonService.parameterCodeUpdate(parameter);
					log.info("更新参数" + parameter.getName());
				}
				json = JSONSerializer.toJSON(new JsonResult<Parameter>(0, "添加成功", null));
			} else {
				json = JSONSerializer.toJSON(new JsonResult<Parameter>(6, "请求码异常", null));
			}
		}
		return json.toString();
	}

	/*
	 * 删除科室/医生头衔， 满足以下两点： ①删除头衔以前，确保头衔里面没有医生 ②删除科室以前，确保科室里面没有医生 ③删除科室以前，确保科室里面没有患者
	 * ④删除科室以前，确保科室里面没有病房 ⑤删除病房类型前，确保病房类型里面没有病房 ⑥删除病房前，确保病房里面没有患者
	 */
	@RequestMapping(value = "/parameterCodeDelete.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String parameterCodeDelete(@Param("id") Integer id, @Param("value") Integer value,
			@Param("code") String code) {
		/**
		 * 如果传入的code码是001，表明是要修改/删除科室，此时要保证②③④成立才能执行
		 * 如果传入的code码是002，表明要修改/删除头衔，此时要保证①成立才能执行
		 * 如果传入的code码是003，表明要修改/删除病房类型，此时要保证⑤成立才能执行
		 * 如果传入的code码是004,表明要修改/删除病房，此时要保证⑥成立才能执行 如果传入其他code码，请求异常
		 */
		JSON json = null;
		if (code.equals("001")) {
			// 查询科室下的医生
			DoctorCode doctorcode = new DoctorCode();
			doctorcode.setDepartment(value);
			doctorcode.setState(0);// 在职的医生
			List<Doctor> list1 = doctorService.doctorQuery(doctorcode);
			log.info("查询医生");
			// 查询科室下的患者
			PatientCode patientcode = new PatientCode();

@Controller
@RequestMapping("/patient")
public class PatientController {
	@Resource(name = "patientService")
	private PatientService patientService;
	@Resource(name = "bedService")
	private BedService bedService;
	@Resource(name = "wardService")
	private WardService wardService;
	@Resource(name = "userService")
	private UserService userService;
	Logger log = Logger.getLogger(Log4jLogsDetial.class);

	@RequestMapping(value = "/patientAdd.do", produces = "application/json;charset=utf-8")
	@ResponseBody
	public String patientAdd(HttpServletRequest request) throws ParseException {
		Patient patient = new Patient();
		patient.setPatientId(System.currentTimeMillis() + "");
		patient.setName(request.getParameter("name"));
		patient.setDoctorId(BaseUtils.toInteger(request.getParameter("doctorNo")));
		patient.setNation(BaseUtils.toInteger(request.getParameter("nationNo")));
		patient.setDepartment(BaseUtils.toInteger(request.getParameter("departmentNo")));

		if (fc > 255)
			fc = 255;
		if (bc > 255)
			bc = 255;
		int r = fc + random.nextInt(bc - fc - 16);
		int g = fc + random.nextInt(bc - fc - 14);
		int b = fc + random.nextInt(bc - fc - 18);
		return new Color(r, g, b);
	}

	public boolean verifyCode(String codeStr, HttpServletRequest request, boolean clear) {
		if (StringUtils.isBlank(codeStr)) {
			return false;
		}
		HttpSession session = request.getSession();
		CheckCode code = (CheckCode) session.getAttribute(RANDOMCODEKEY);
		if (clear) // 清除验证
			cleanCode(session);
		if (code == null || !code.enable || StringUtils.isBlank(code.code)
				|| !code.code.equalsIgnoreCase(codeStr.trim())) {
			return false;
		}
		// 有效
		if ((System.currentTimeMillis() - code.createTime) > NumberUtils.toInt("10", 10) * 60 * 1000) {
			code.enable = false;
			return false;
		}
		return true;
	}

	/**
	 * 生成随机图片
	 */
	public String buildRandcode(HttpServletRequest request, OutputStream outStream) {
		HttpSession session = request.getSession();
		BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
		g.fillRect(0, 0, width, height);
		g.setFont(new Font("Times New Roman", Font.ROMAN_BASELINE, 25));
		g.setColor(getRandColor(110, 133));
		// 绘制干扰
		for (int i = 0; i <= lineSize; i++) {
			drowLine(g);
		}
		// 绘制随机字符
		String randomString = "";
		for (int i = 1; i <= stringNum; i++) {
			randomString = drowString(g, randomString, i);
		}
		cleanCode(session);