基于javaweb+mysql的ssm+maven医药进销存系统(java+ssm+jsp+layui+jquery+maven+mysql)

基于javaweb+mysql的ssm+maven医药进销存系统(java+ssm+jsp+layui+jquery+maven+mysql)

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

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

适用

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

功能说明

基于javaweb+mysql的SSM+Maven医药进销存系统(java+ssm+jsp+layui+jquery+maven+mysql)

功能介绍

医药进销存系统，主要功能包括：

公告管理：发布公告、公告列表； 生产管理：订单列表、增加生产、订单日志； 分店采购：分店审核、采购； 总店仓库：出库管理、仓库列表、入库管理； 分店管理：分店库存、分店列表、分店财务； 商品管理：原材料、药效、商品列表、药品类型； 总店采购：采购列表、采购审核； 合同管理：合同类型管理、合同列表； 会员管理：会员列表； 质检：质检； 权限管理：人员管理、模块管理、部门管理、角色管理； 审核管理：财务审核、生产审核、采购审核； 分店销售：销售统计图、订单批发审核、订单列表、分店销售； 该项目共有49张表，功能比较复杂；

其他管理：供货商管理，新增、搜索、编辑、删除；

环境需要

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项目: 是；查看源码目录中是否包含pom.xml；若包含，则为maven项目，否则为非maven项目 6.数据库：MySql 5.7版本；

技术栈

1. 后端：Spring SpringMVC MyBatis 2. 前端：JSP+Layui+jQuery

运行说明

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

2. 运行项目，输入http://localhost:8080/medicine/page/login.jsp 登录

			//消息类的消息值赋值为成功
			mes.setMes("操作成功");
			//将消息类的状态赋值为1
			mes.setState(1);
		}else{
			//消息类的消息值赋值为失败
			mes.setMes("操作失败");
			//将消息类的状态赋值为0
			mes.setState(0);
		}
		//返回消息类
		return mes;
		
		
	}
	
	/**
	 * 增加类型
	 * @param record 类型对象
	 * @return 返回信息类
	 */
	@RequestMapping("insertSelectivePact")
	@ResponseBody
	public SsmMessage insertSelectivePact(ErpPact record,HttpSession session){
		
		
		
		//给订单采购的id赋值为订单采购的id 
		record.setPurId(record.getPurId());
		//给供货商的id赋值为供货商的id
		record.setApplyId(record.getApplyId());
		//给合同类型的id赋值为合同类型的id
		record.setPatypeId(record.getPatypeId());
		//给合同的标题赋值为合同的标题
		record.setPactTitle(record.getPactTitle());
		//给合同的编号赋值为工具类中的得到订单编码格式:日期格式如:20161222211800,分别代表的是年月日时分秒+5位随机字符串
		record.setPactNumber("HT-"+Tools.getDateOrderNo());
		//初始化时间对象
		Date date=new Date();
		//将合同的时间赋值为初始化的时间
		record.setPactSigntime(date);
		//给合同内容赋值为合同的内容
		record.setPactText(record.getPactText());
		//给合同id赋值为合同id

			mes.setMes("操作成功");
			//将消息类的状态赋值为1
			mes.setState(1);
		}else{
			//消息类的消息值赋值为失败
			mes.setMes("操作失败");
			//将消息类的状态赋值为0
			mes.setState(0);
		}
		//返回mes
		return mes;
		
		
	}
	
	
	/**
	 * 根据id查询
	 * @return 返回list
	 */
	@RequestMapping("/findByID")
	@ResponseBody
	public ErpPactType findByID(String patypeId){
		//合同类型的查找单个对象方法
		ErpPactType pact=pactTypeService.selectByPrimaryKey(patypeId);
		//返回pact
		return pact;
		
	}
}
/**
 * 
 */
package com.yidu.action.ErpProlistmxsmall;

            return amount;
        }
        //传入的金额字符串代表的是一个整数
        if(-1 == amount.indexOf(".")){
            return Integer.parseInt(amount) * 100 + "";
        }
        //传入的金额字符串里面含小数点-->取小数点前面的字符串,并将之转换成单位为分的整数表示
        int money_fen = Integer.parseInt(amount.substring(0, amount.indexOf("."))) * 100;
        //取到小数点后面的字符串
        String pointBehind = (amount.substring(amount.indexOf(".") + 1));
        //amount=12.3
        if(pointBehind.length() == 1){
            return money_fen + Integer.parseInt(pointBehind)*10 + "";
        }
        //小数点后面的第一位字符串的整数表示
        int pointString_1 = Integer.parseInt(pointBehind.substring(0, 1));
        //小数点后面的第二位字符串的整数表示
        int pointString_2 = Integer.parseInt(pointBehind.substring(1, 2));
        //amount==12.03,amount=12.00,amount=12.30
        if(pointString_1 == 0){
            return money_fen + pointString_2 + "";
        }else{
            return money_fen + pointString_1*10 + pointString_2 + "";
        }
    }
    
    /**
     * 金额分转元
     * @see 注意:如果传入的参数中含小数点,则直接原样返回
     * @see 该方法返回的金额字符串格式为<code>00.00</code>,其整数位有且至少有一个,小数位有且长度固定为2
     * @param amount  金额的分进制字符串
     * @return String 金额的元进制字符串
     */
    public static String moneyFenToYuan(String amount){
        if(isEmpty(amount)){
            return amount;
        }
        if(amount.indexOf(".") > -1){
            return amount;
        }
        if(amount.length() == 1){
            return "0.0" + amount;
        }else if(amount.length() == 2){

/**
 * 分店销售订单action
 * @data 2017年11月8日08:46:24
 */
@Controller
@RequestMapping("/sctockmp")
public class SctockmpAction {
	@Resource
	AnnexService annexService;//分店表
	@Resource
	SctockmpService sctockmpService;//分店销售订单表
	
	/**
     * 查询今天的订单数量
     * @return 订单数量
	 * @dataTime 2017年12月11日16:24:53
     */
	@RequestMapping("/findToDay")
	@ResponseBody  //ajax注解
	public int findToDay(){
		return sctockmpService.findToDay();//订单：查询今天的订单数量
	}
	
	/**
	 * 审核通过，增加批发状态
	 * @param saleId 订单ID
	 * @param session HttpSession
	 * @return 影响行数
	 * @dataTime 2017年12月1日08:43:55
	 */
	@RequestMapping("/updateWholesaleStateAdd")
	@ResponseBody  //ajax注解
	public int updateWholesaleStateAdd(String saleId,HttpSession session){
		return sctockmpService.updateWholesaleStateAdd(saleId,session);//订单：审核通过，增加批发状态

		return view;
	}
	
	
	@ResponseBody
	@RequestMapping("updateIsva")
	private  SsmMessage updateIsva (String fdprolistmxId){
		SsmMessage mes = new SsmMessage();
		int rows = prolistmxsmallService.updateIsva(fdprolistmxId);
		if(rows>0){
			mes.setMes("ok");
		}
		return mes;
	}
	/**
	 * 查询单个采购的所有详情
	 * @param fdproId 采购id
	 * @return 采购详情的集合
	 */
	@ResponseBody
	@RequestMapping("selectBankNew")
	private  List<ErpProlistmxsmall> selectBankNew (String fdproId){
		List<ErpProlistmxsmall> list = prolistmxsmallService.selectBankNew(fdproId);
		return list;
	}
	
	@ResponseBody
	@RequestMapping("add")
	private  SsmMessage add (@RequestParam(value = "kinId[]") String[] kinId,String fdprolistmxCount,String kinPrice,String fdprolistmxMoney,String fdproId,HttpSession session,String zong){
		SsmMessage mes = new SsmMessage();
		ErpStaff staff = (ErpStaff) session.getAttribute("staff");
		String [] fdprolistmxCount1 = fdprolistmxCount.split(",");
		String [] fdprolistmxMoney1 = fdprolistmxMoney.split(",");
		int count = 0;
		for(int i =0;i<fdprolistmxCount1.length;i++){
			count += Integer.valueOf(fdprolistmxCount1[i]);
		}
		Date date = new Date();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		java.util.Random random=new java.util.Random();

	    //建立新的sheet对象（excel的表单）
	    HSSFSheet sheet=wb.createSheet("商品表");
	    //在sheet里创建第一行，参数为行索引(excel的行)，可以是0～65535之间的任何一个
	    HSSFRow row1=sheet.createRow(0);
	    //创建单元格（excel的单元格，参数为列索引，可以是0～255之间的任何一个
	    HSSFCell cell=row1.createCell(0);
	    //设置单元格内容
	    cell.setCellValue("商品列表");
	    //合并单元格CellRangeAddress构造参数依次表示起始行，截至行，起始列， 截至列
	    sheet.addMergedRegion(new CellRangeAddress(0,0,0,10));
	    //在sheet里创建第二行
	    HSSFRow row2=sheet.createRow(1);    
	    //创建单元格并设置单元格内容
		row2.createCell(0).setCellValue("编号");
		row2.createCell(1).setCellValue("药品名");    
		row2.createCell(2).setCellValue("类型");
		row2.createCell(3).setCellValue("药效");
		row2.createCell(4).setCellValue("条形码"); 
		row2.createCell(5).setCellValue("净含量");
		row2.createCell(6).setCellValue("保质期");
		row2.createCell(7).setCellValue("成本价");
		row2.createCell(8).setCellValue("销售价");
		row2.createCell(9).setCellValue("批发价");
		row2.createCell(10).setCellValue("备注");
		
		for(int i =0;i<list.size();i++){
			ErpKinds kind = list.get(i);
			HSSFRow row3=sheet.createRow(2+i);
			row3.createCell(0).setCellValue(kind.getKinSerial());
			row3.createCell(1).setCellValue(kind.getKinName());
			row3.createCell(2).setCellValue(kind.getTyper().getTypeName());
			row3.createCell(3).setCellValue(kind.getResName());
			row3.createCell(4).setCellValue(kind.getKinBarcode());
			row3.createCell(5).setCellValue(kind.getKinContent().doubleValue());
			row3.createCell(6).setCellValue(kind.getKinExpiration());
			row3.createCell(7).setCellValue(kind.getKinPrice().doubleValue());
			row3.createCell(8).setCellValue(kind.getKinStost().doubleValue());
			row3.createCell(9).setCellValue(kind.getKinSellinf().doubleValue());
			row3.createCell(10).setCellValue(kind.getRemark());
		}
		//输出Excel文件
	    try {
			OutputStream output=response.getOutputStream();
			response.reset();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String time =  sdf.format(new Date()).replace("-", "");
			response.setHeader("Content-disposition", "attachment; filename=kinds"+time+".xls");
		    response.setContentType("application/msexcel");   
		    wb.write(output);
		    output.flush();
		    output.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block

	
	/**
	 * 将首字母大写
	 * @param name 属性名
	 * @return 例如传入属性name,得到的结果是Name
	 */
	public static String firstUpp(String name){
		if(isEmpty(name)) return name ;
		char first = name.charAt(0) ;
		String newName = Character.toUpperCase(first)+name.substring(1) ;
		return newName ;
	}
	
	/**
	 * 将字符串编码,utf-8格式
	 * @param str
	 * @return
	 */
	public static String encode(String str){
		try {
			 return URLEncoder.encode(str, "utf-8");
		} catch (UnsupportedEncodingException e) { 
			e.printStackTrace();
		}
		return null ;
	}
	
	 /**
     * 字符解码
     * @see 该方法默认会以UTF-8解码字符串
     * @see 若想自己指定字符集,可以使用<code>decode(String chinese, String charset)</code>方法
     */
    public static String decode(String chinese){
        return decode(chinese, "UTF-8");
    }
    
    /**
     * 字符解码
     * @see 该方法通常用于对中文进行解码
     * @see 若系统不支持指定的解码字符集,则直接将<code>chinese</code>原样返回
     */
    public static String decode(String chinese, String charset){

			e.printStackTrace();
		}
		//获取Excel文档中的第一个表单
		Sheet sht0 = wb.getSheetAt(0);
		//对Sheet中的每一行进行迭代
        for (Row r : sht0) {
	        //如果当前行的行号（从0开始）未达到2（第三行）则从新循环
			if(r.getRowNum()<2){
				continue;
			}
			//当前列的数据
			ErpKinds kinds = new ErpKinds();
			if(r.getCell(0)!=null){
				r.getCell(0).setCellType(Cell.CELL_TYPE_STRING);
				kinds.setKinSerial(r.getCell(0).getStringCellValue());
			}
			if(r.getCell(4)!=null){
				r.getCell(4).setCellType(Cell.CELL_TYPE_STRING);
				if(r.getCell(4).getStringCellValue().indexOf(".")>-1){
					String barcode = r.getCell(4).getStringCellValue().split("\\.")[0];
					kinds.setKinBarcode(barcode);
				}else{
					kinds.setKinBarcode(r.getCell(4).getStringCellValue());
				}
			}
			if(r.getCell(1)!=null){
				r.getCell(1).setCellType(Cell.CELL_TYPE_STRING);
				kinds.setKinName(r.getCell(1).getStringCellValue());
			}
			if(r.getCell(5)!=null){
				r.getCell(5).setCellType(Cell.CELL_TYPE_STRING);
				kinds.setKinContent(new BigDecimal(r.getCell(5).getStringCellValue()));
			}
			if(r.getCell(6)!=null){
				r.getCell(6).setCellType(Cell.CELL_TYPE_STRING);
				kinds.setKinExpiration(r.getCell(6).getStringCellValue());
			}
			if(r.getCell(7)!=null){
				r.getCell(7).setCellType(Cell.CELL_TYPE_STRING);
				kinds.setKinPrice(new BigDecimal(r.getCell(7).getStringCellValue()));
			}
			if(r.getCell(9)!=null){
				r.getCell(9).setCellType(Cell.CELL_TYPE_STRING);
				kinds.setKinSellinf(new BigDecimal(r.getCell(9).getStringCellValue()));
			}
			if(r.getCell(8)!=null){
				r.getCell(8).setCellType(Cell.CELL_TYPE_STRING);

/**
 * 订单action
 * @da2017年11月7日
 * @version 1.0
 */
@Controller
@RequestMapping("dent")
public class ProindentAction {
	@Resource
	private ProindentService proindentService;//订单
	
	@Resource
	private ProindentDetailService ProindentDetailService;//订单明细
	
	@Resource
	private ErpWarehouseService erpWarehouseService;//仓库
	
	
	SsmMessage  mes=new SsmMessage();//消息类
	
	
	
	/**
	 * 下拉框查询所有订单
	 * @return list
	 */
	@RequestMapping("/findByxl")
	@ResponseBody
	public List<ErpProindent> findByxl(ErpProindent dent){
		List<ErpProindent> list=proindentService.findStation();
		
		return list;
		
	}
	
	
	
	
	
	/**
	 * 下拉框查询所有订单
	 * @param express
	 * @return map
	 */
	@RequestMapping("/findByshowxl")
	@ResponseBody
	public List<Map<String, Object>> findByshowxl(ErpProindent dent){
		
		List<Map<String, Object>> map=proindentService.findStationid(dent.getIndentId());//根据订单ID查询商品，下拉框 
		
		return map;
		
	}

					mes.setMes("修改成功");
					mes.setState(1);
				}else{
					mes.setMes("修改失败");
					mes.setState(0);
				}
			} catch (BackException e) {
				e.printStackTrace();
			}
		}else{
			mes.setMes("类型id无效");
			mes.setState(0);
		}
		
		return mes;
	}
	/**
	 * 模糊查询
	 * @param price 值
	 * @return 返回对象的map
	 */
	@RequestMapping("findDimRew")
	@ResponseBody
	public Map findDimRaw(String price,Integer page,Integer limit){
		Map<String,Object> map = new HashMap<String,Object>();
		Pages pa = new Pages();
		pa.setCurPage(page);
		pa.setMaxResult(limit);
		map.put("page", pa.getFirstRows());
		map.put("limit", pa.getMaxResult());
		map.put("pricer", price);
		List<ErpRaw> list = service.findDimRaw(map);
		map.put("code", "");
		map.put("msg", "");
		map.put("count", list.size());
		map.put("data", list);
		return map;
	}
	/**
	 * 查询单个对象
	 * @param rawId 原材料id
	 * @return 返回对象
	 */
	@RequestMapping("selectByPrimaryKey")
	@ResponseBody
	public List<ErpRaw> selectByPrimaryKey(String rawId){
		if(rawId==null ||rawId==""){//判断id是否为空
			return null;
		}
		List<ErpRaw> list = service.selectByPrimaryKey(rawId); //调用方法执行语句
		return list;
	}
}

	 * @param keywords
	 * @return map
	 */
	@RequestMapping("/showAll")
	@ResponseBody
	public Map<String,Object> showAll(String keywords,String page,String limit){
		Map<String,Object> mapPage = new HashMap<String,Object>();//定义Map集合
		Pages pages = new Pages();//得到分页类
		pages.setCurPage(Integer.valueOf(page));//当前页数
		pages.setMaxResult(Integer.valueOf(limit));//每页显示最大条数
		mapPage.put("pages", pages);//传入分页参数
		//判断前台传值是否为空，如不为空则进行迷糊查询
		if(keywords==null || "".equals(keywords)){
			mapPage.put("keywords", "");//为空不传值
		}else {
			mapPage.put("keywords", "%"+keywords+"%");//不为空传值模糊查询
		}
		Map<String,Object> map = new HashMap<String,Object>();//定义Map集合用于将前台的值
		List<ErpPurchase> list = erpPurchaseService.selectAll(mapPage);//查询增加原材料数据

		map.put("code", 0);
		map.put("msg", "");
		map.put("count", erpPurchaseService.purchaseFindRows(mapPage));//规定分页信息
		map.put("data", list);//传入list
		return map;//返回map
	}
	/**
	 * 显示和查询和分页（采购成品）
	 * @param purcId
	 * @param keywords
	 * @return map
	 */
	@RequestMapping("/showAlls")
	@ResponseBody
	public Map<String,Object> showAlls(String keywords,String page,String limit){
		Map<String,Object> mapPage = new HashMap<String,Object>();//定义Map集合
		Pages pages = new Pages();//得到分页类
		pages.setCurPage(Integer.valueOf(page));//当前页数
		pages.setMaxResult(Integer.valueOf(limit));//每页显示最大条数
		mapPage.put("pages", pages);//传入分页参数
		//判断前台传值是否为空，如不为空则进行迷糊查询
		if(keywords==null || "".equals(keywords)){
			mapPage.put("keywords", "");//为空不传值
		}else {
			mapPage.put("keywords", "%"+keywords+"%");//不为空传值模糊查询
		}
		Map<String,Object> map = new HashMap<String,Object>();//定义Map集合用于将前台的值
		List<ErpPurchase> list = erpPurchaseService.selectAlls(mapPage);//查询增加成品数据

		map.put("code", 0);
		map.put("msg", "");
		map.put("count", erpPurchaseService.purchaseFindRow(mapPage));//规定分页信息

	/**
	 * 根据id查询
	 * @return 返回list
	 */
	@RequestMapping("/findByID")
	@ResponseBody
	public ErpPact findByID(String pactId){
		//合同表 合同方法查找单个对象 返回合同
		ErpPact pact=erpPactService.selectByPrimaryKey(pactId);
		//返回合同
		return pact;
		
	}
	
	
	/**
	 * 根据id查询
	 * @return 返回list
	 */
	@RequestMapping("/findByshowid")
	@ResponseBody
	public Map<String, Object> findByshowid(String pactId){
		//map 合同方法根据合同id查询供货商和合同详情 返回合同
		Map<String, Object> pact=erpPactService.selectshowid(pactId);
		//返回合同
		return pact;
	}
}
/**
 * XLe1丶
 * 2017年11月3日 2017年8月1日16:02:52
 */
package com.yidu.action.ErpRole;

			ErpModel erpModel = (ErpModel) iterator.next();
			ZTree t = new ZTree();
			t.setId(erpModel.getModelId());
			t.setpId(erpModel.getErpModelId());
			t.setName(erpModel.getModelName());
			for (Iterator iterator2 = model2.iterator(); iterator2.hasNext();) {
				ErpModel erpModel2 = (ErpModel) iterator2.next();
				if(erpModel.getModelId().equals(erpModel2.getModelId())){
					t.setChecked("true");
				}
			}
			for (Iterator iterator2 = model3.iterator(); iterator2.hasNext();) {
				ErpRoleModel erpRoleModel = (ErpRoleModel) iterator2.next();
				if(erpModel.getModelId().equals(erpRoleModel.getModelId())){
					t.setChecked("true");
				}
			}
			tree.add(t);
			
		}
		return tree;
	}
	
	@RequestMapping("addModel")
	@ResponseBody
	public SsmMessage ModelAdd(String modelId,String roleId,String modelSubId){
		SsmMessage mes = new SsmMessage();
		String [] stringSplit = modelId.split(",");
		String [] stringSplit2 = modelSubId.split(",");
		System.out.println("stringSplit+++++++++++++++++++"+modelSubId+"         "+modelId);
		
		roleModelSubService.deleteByPrimaryKey(roleId);
		roleService.deleteModel(roleId);
		for(int i = 0;i<stringSplit.length;i++){
			ErpRoleModel model = new ErpRoleModel();
			model.setRoleModelId(UUID.randomUUID().toString());
			model.setRoleId(roleId);
			model.setModelId(stringSplit[i]);
			roleModelService.insertSelective(model);
		}
		
		for(int i = 0;i<stringSplit2.length;i++){
			ErpRoleModelSubordinate sub = new ErpRoleModelSubordinate();
			sub.setRoleId(roleId);
			sub.setModelId(stringSplit2[i]);

				map.put("SALE_if_wholesale",0);//map赋值-是否批发(键为数据库字段名)为0
			}else{
				map.put("SALE_if_wholesale",1);//map赋值-是否批发(键为数据库字段名)为1
				map.put("SALE_wholesale_state",saleWholesaleState);//map赋值-批发状态(键为数据库字段名)
			}
		}
		map.put("annexId", annexId);//map赋值-分店ID
		
		//查询数据
		List<Map<String,Object>> data = sctockmpService.findAll(map);//订单：查询订单列表
		int count = sctockmpService.findAllSize(map);//订单：查询订单列表数量
		
		//设置方法返回参数
		Map<String,Object> mapResult = new HashMap<String, Object>();//实例化HashMap
		//layui数据表格需要返回的参数
		map.put("count", count);//map赋值-总条数
		map.put("data", data);//map赋值-数据
		map.put("code",0);//map赋值-状态code为0
		map.put("msg", "");//map赋值-消息msg为‘’
		return map;//返回map
	}
	
	/**
	 * 查询当前登录人员需要审核的订单
	 * @param sctockData 混合数据
	 * @param saleDate 销售时间
	 * @param page 当前页数
	 * @param limit 显示行数
	 * @param session HttpSession
	 * @return 订单集合
	 * @dataTime 2017年11月27日14:18:37
	 */
	@RequestMapping("/findAllAudit")
	@ResponseBody  //ajax注解
	public Map<String,Object> findAllAudit(String sctockmpData,String saleDate,int page,int limit,HttpSession session){
		Map<String, Object> map = new HashMap<String, Object>();//实例化HashMap
		ErpStaff staff = (ErpStaff) session.getAttribute("staff");//得到Session中的员工对象
		String roleName = staff.getRoleName();//得到员工对象中的角色名称
		//权限判断
		if(!"管理员".equals(roleName)){//如果员工角色不是‘管理员’
			map.put("annexId", staff.getAnnexId());//给分店ID赋值，赋值为当前登录人的分店ID
		}
		//权限判断
		if("分店批发审核员".equals(roleName)){//如果员工角色是‘分店批发审核员’
			map.put("SALE_if_wholesale",1);//map赋值-是否批发(键为数据库字段名)为1
			map.put("SALE_wholesale_state",1);//map赋值-批发状态(键为数据库字段名)为1
		}else if("分店财务员".equals(roleName)){//如果员工角色是‘分店财务员’
			map.put("SALE_if_wholesale",1);//map赋值-是否批发(键为数据库字段名)为1
			map.put("SALE_wholesale_state",2);//map赋值-批发状态(键为数据库字段名)为2
		}else if("分店经理".equals(roleName)){//如果员工角色是‘分店经理’
			map.put("SALE_if_wholesale",1);//map赋值-是否批发(键为数据库字段名)为1
			map.put("SALE_wholesale_state",3);//map赋值-批发状态(键为数据库字段名)为3

	@RequestMapping("/auditPurchase")
	public SsmMessage auditPurchase(String purcId,String state,String feedBack,HttpSession session){
		SsmMessage mes = new SsmMessage();//定义一个消息类用于返回jsp
		Map<String,Object>map = new HashMap<String,Object>();//定义一个map集合
		if(Tools.isEmpty(feedBack)){//判断字符串是否为空
			map.put("feedBack", "暂无反馈信息");
		}else{
			map.put("feedBack", feedBack);//map集合中存入 反馈消息
		}
		map.put("purcId", purcId);//map集合中存入财务id
		map.put("state", state);//map集合中存入 审核是否通过   state=2 通过 state=0 不通过
		ErpStaff staff = (ErpStaff) session.getAttribute("staff");//得到人员session
		map.put("staff", staff);
		int rows = erpPurchaseService.auditPurchase(map);
		return mes;
	}
	/**
	 * 查询合同表
	 * @return map
	 */
	@ResponseBody
	@RequestMapping("/pact")
	public List<ErpPact> findPactText(){
		return erpPactService.findPactText();//查询合同表
	}
	/**
	 * 查询单个对象
	 * @param purcId 采购id
	 * @return 返回采购对象
	 */
	@ResponseBody
	@RequestMapping("/selectByPrimaryKey")
	public ErpPurchase selectByPrimaryKey(String purcId){
		return erpPurchaseService.selectByPrimaryKey(purcId);//根据ID查询
	}
	/**
	 * 查询采购信息（采购原材料）
	 * @param purcId
	 * @return
	 */
	@RequestMapping("/showErp")
	@ResponseBody
	public ErpPurchase updateRaw(String purcId){
		return erpPurchaseService.showErp(purcId);//查询修改信息（原材料）
	}
	/**
	 * 查询采购信息（采购成品）
	 * @param purcId

	/**
	 * 与当前时间比
	 * @param date
	 * @return 如果未超过返回true，如果已经超过返回false
	 * @throws ParseException 
	 */
	public static boolean isDateBefore(String date) throws ParseException{
		if(isEmpty(date)) return false ;
		Date exp = CommomUtils.SDF_TIME.parse(date);
		Date now = new Date();
		return now.before(exp);
	}
	
	/**
     * 获取前一天日期yyyyMMdd
     * @see 经测试，针对闰年02月份或跨年等情况，该代码仍有效。测试代码如下
     * @see calendar.set(Calendar.YEAR, 2013);
     * @see calendar.set(Calendar.MONTH, 0);
     * @see calendar.set(Calendar.DATE, 1);
     * @see 测试时，将其放到<code>calendar.add(Calendar.DATE, -1);</code>前面即可
     * @return 返回的日期格式为yyyyMMdd
     */
    public static String getYestoday(){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, -1);
        return CommomUtils.SDF_DATE.format(calendar.getTime());
    }
	
	/**
	 * 将首字母大写
	 * @param name 属性名
	 * @return 例如传入属性name,得到的结果是Name
	 */
	public static String firstUpp(String name){
		if(isEmpty(name)) return name ;
		char first = name.charAt(0) ;
		String newName = Character.toUpperCase(first)+name.substring(1) ;
		return newName ;
	}
	
	/**
	 * 将字符串编码,utf-8格式
	 * @param str
	 * @return
	 */
	public static String encode(String str){

/**
 * @da2017年11月2日
 * @version 1.0
 */
@Controller
@RequestMapping("pact")
public class PactAction {
	
	@Resource
	private ErpApplyService erpApplyService;//供货商
	
	@Resource
	private ErpPurchaseService erpPurchaseServicel;//采购订单
	
	@Resource
	private PactTypeService pactTypeService;//合同类型
	
	@Resource
	private ErpPactService erpPactService;
	
	SsmMessage mes = new SsmMessage();//消息类
	/**

		map.put("count", modelService.findRowCount(model));
		map.put("data", list);
		map.put("code",0);
		map.put("msg", "");
		return map;
	}
	
	@RequestMapping("getErpModel")
	@ResponseBody
	public String getErpModel() throws JsonProcessingException{
		ObjectMapper objectMapper = new ObjectMapper();
		List<ErpModel>list = modelService.getErpModel();
		String json = objectMapper.writeValueAsString(list);
		System.out.println("model          ："+json);
		return json;
	}
	
	@ResponseBody
	@RequestMapping("add")
	public SsmMessage add(ErpModel model){
		SsmMessage mes = new SsmMessage();
		if("".equals(model.getModelId()) || null==model.getModelId()){
			model.setModelId(UUID.randomUUID().toString());
			model.setIsva("1");
			model.setErpModelId("0");
			modelService.insertSelective(model);
			mes.setMes("add");
		}else{
			modelService.updateByPrimaryKeySelective(model);
			mes.setMes("update");
		}
		return mes;
		
	}
	
	
	@RequestMapping("deleteModel")
	@ResponseBody
	public SsmMessage deleteRole(String modelId){
		SsmMessage mes = new SsmMessage();
		int rows = modelService.deleteModel(modelId);
		if(rows>0){

/**
 * 分店销售订单action
 * @data 2017年11月8日08:46:24
 */
@Controller
@RequestMapping("/sctockmp")
public class SctockmpAction {
	@Resource
	AnnexService annexService;//分店表
	@Resource
	SctockmpService sctockmpService;//分店销售订单表
	
	/**
     * 查询今天的订单数量
     * @return 订单数量
	 * @dataTime 2017年12月11日16:24:53
     */
	@RequestMapping("/findToDay")
	@ResponseBody  //ajax注解
	public int findToDay(){
		return sctockmpService.findToDay();//订单：查询今天的订单数量
	}
	

		map.put("sctockmpData", sctockmpData);//map赋值-查询的混合数据
		if(saleDate!=null && !"".equals(saleDate)){//如果销售时间不为空
			String str[] = saleDate.split(" "+"-"+" ");//则分割销售时间字符串，根据 - 分割
			map.put("saleDate_begin", str[0]);//map赋值-开始销售时间
			map.put("saleDate_end", str[1]);//map赋值-结束销售时间
		}
		
		List<Map<String,Object>> data = sctockmpService.findAll(map);//订单：查询订单列表
		int count = sctockmpService.findAllSize(map);//订单：查询订单列表数量
		
		//设置方法返回参数
		Map<String,Object> mapResult = new HashMap<String, Object>();//实例化HashMap
		//layui数据表格需要返回的参数
		map.put("count", count);//map赋值-总条数
		map.put("data", data);//map赋值-数据
		map.put("code",0);//map赋值-状态code为0
		map.put("msg", "");//map赋值-消息msg为‘’
		return map;//返回map
	}
	
	/**
	 * 进入销售页面
	 * @param session HttpSession
	 * @param saleId 订单ID
	 * @return 分店销售页面sell.jsp(参数：times-当前时间，staName-员工姓名)
	 * @dataTime 2017年11月23日15:06:39
	 */
	@RequestMapping("/sellEntrance")
	public ModelAndView sellEntrance(String saleId,HttpSession session){
		ErpStaff staff = (ErpStaff) session.getAttribute("staff");//得到Session中的员工对象
		ModelAndView view = new ModelAndView("sell");//实例化模型视图-分店销售页面
		//当前日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//实例化时间格式化类(只需年月日)
		String times = sdf.format(new Date());//格式化当前时间
		view.addObject("times", times);//模型视图赋值-格式化后的时间
		view.addObject("staName", staff.getStaName());//模型视图赋值-员工姓名
		
		if(saleId!=null && !"".equals(saleId)){//如果订单ID不为空
			view.addObject("saleId", saleId);//模型视图赋值-订单ID
		}
		
		ErpAnnex annex = annexService.findById(staff.getAnnexId());//分店：根据分店ID查询分店
		view.addObject("annexId",staff.getAnnexId());//模型视图赋值-分店ID
		view.addObject("annexName",annex.getAnnexName());//模型视图赋值-分店名称
		return view;//返回模型视图
	}
	
	/**
	 * 增加销售订单

		audit.setAudSerial(UUID.randomUUID()+"");//审核赋值-审核编号-随机生产
		ErpStaff staff = (ErpStaff) session.getAttribute("staff");//得到Session中的员工对象
		audit.setAudName(staff.getStaName());//审核赋值-审核人-员工姓名
		audit.setAudTime(Tools.getCurDateTime());//审核赋值-审核时间-工具类：得到当前日期时间
		audit.setState(0);//审核赋值-审核状态-0
		audit.setFeedBack(feedBack);//审核赋值-反馈-打回原因
		audit.setCreatetime(Tools.getCurDateTime());//审核赋值-创建时间-工具类：得到当前日期时间
		audit.setCreater(staff.getStaId());//审核赋值-创建人-员工ID
		audit.setIsva(1);//审核赋值-是否有效-是
		auditDao.insertSelective(audit);//无返回-审核：增加(可以为空)
		//更改状态
		ErpSctockmp sctockmp = new ErpSctockmp();//实例化一个订单
		sctockmp.setSaleId(saleId);//订单赋值-订单ID
		sctockmp.setSaleWholesaleState(0);//订单赋值-批发状态-0
		return sctockmpDao.updateByPrimaryKeySelective(sctockmp);//订单：根据订单ID修改订单信息
	}

	@Override
	public int updateSctockmp(ErpSctockmp sctockmp, List<ErpSctockmpDetail> list) {
		//修改订单
		sctockmpDao.updateByPrimaryKeySelective(sctockmp);//无返回-订单：根据订单ID修改订单信息
		//删除之前的订单明细
		sctockmpDetailDao.updateIsvaBySaleId(sctockmp.getSaleId());//无返回-订单明细：根据订单ID把详细订单设为无效
		//增加订单明细
		sctockmpDetailDao.addSctockmpDetailList(list);//无返回-订单明细：批量增加销售订单明细
		//如果为零售(则需减库存，增加财务)
		if(sctockmp.getSaleIfWholesale()==0){
			//减库存
			List<Map<String, Object>> mapList = new ArrayList<Map<String, Object>>();
			for(int i =0;i<list.size();i++){//循环 明细订单集合
				Map<String, Object> map = new HashMap<String, Object>();//实例化map
				map.put("annexId",sctockmp.getAnnexId());//map赋值-分店ID-订单中分店ID
				map.put("kinId",list.get(i).getKinId());//map赋值-商品ID-第i个明细订单中的商品ID
				map.put("kmpNum",list.get(i).getKmpNum());//map赋值-商品数量-第i个明细订单中的商品数量
				mapList.add(map);//把map加入集合
			}
			int row3 = sumstockDao.updateStockSuount(mapList);//订单:批量减少库存(根据分店ID和商品ID减少)
			if(row3<1){
				return 0;
			}
			
			//增加财务(先增加分店收入明细，再增加分店表的总资产)
			/*  增加分店收入明细  */
			ErpLedgyr ledgyr = new ErpLedgyr();//实例化一个分店财务模型
			ledgyr.setGyrId(UUID.randomUUID()+"");//赋值-分店支出收入id-随机生成
			ledgyr.setSaleId(sctockmp.getSaleId());//赋值-分店销售ID-订单ID
			ledgyr.setAnnexId(sctockmp.getAnnexId());//赋值-分店ID-订单分店ID

	
		detail.setIsva("0");//赋值，订单明细是否有效改变
		detail.setIndentId(dent.getIndentId());//给订单明细，生产订单主键赋值生产订单主键
		
		dent.setIsva("0");//赋值，订单是否有效改变
		dent.setIndentId(dent.getIndentId());//给生产订单主键，赋值生产订单主键
		
		SsmMessage mes = new SsmMessage();//new出消息类
		
		int rows=0;//定义数值等于0
		
		rows = proindentService.updateByPrimaryKeySelective(dent);//订单删除方法
		rows=ProindentDetailService.updateByPrimaryKeySelective(detail);//订单明细删除方法
		
		if(rows>0){//数值大于0
			mes.setMes("操作成功");
			mes.setState(1);
		}else{
			mes.setMes("操作失败");
			mes.setState(0);
		}
		
		return mes;
	}
	
	/**
	 * 查询产品，订单，订单明细，订单生产日志，订单生产日志明细，根据订单ID查询
	 * @param express
	 * @param indentId 生产订单主键
	 * @param int 总行数
	 * @return
	 */
	@RequestMapping("/findByshow")
	@ResponseBody
	public List<Map<String, Object>> findByshow(ErpProindent dent){
		
		int num=proindentService.findcount(dent.getIndentId());//根据生产订单主键，查询订单明细总行数
		
		Map<String, Object> m=new HashMap<String,Object>();//定义map
		
		m.put("indentId", dent.getIndentId());//把生产订单主键传入map中
		m.put("int", num);//把订单明细总行数传入map中
		
		List<Map<String, Object>> map=proindentService.findByshow(m);//查询产品，订单，订单明细，订单生产日志，订单生产日志明细，根据订单ID查询和订单明细总行数查询

	 * 注入采购订单Service
	 */
	@Resource
	private ErpPurchaseService erpPurchaseService;

	/**
	 * 注入原材料Service
	 */
	@Resource
	private ErpRawService erpRawService;

	/**
	 * 注入订单详细Service
	 */
	@Resource
	private ErpPurchaseDetailsService erpPurchaseDetailsService;

	/**
	 * 注入货品表Service
	 */
	@Resource
	private ErpKindsService erpKindsService;

	/**
	 * 注入合同Service
	 */
	@Resource
	private ErpPactService erpPactService;
	/**
	 * 显示和查询和分页（采购原材料）
	 * @param purcId
	 * @param keywords
	 * @return map
	 */
	@RequestMapping("/showAll")
	@ResponseBody
	public Map<String,Object> showAll(String keywords,String page,String limit){
		Map<String,Object> mapPage = new HashMap<String,Object>();//定义Map集合
		Pages pages = new Pages();//得到分页类
		pages.setCurPage(Integer.valueOf(page));//当前页数
		pages.setMaxResult(Integer.valueOf(limit));//每页显示最大条数
		mapPage.put("pages", pages);//传入分页参数
		//判断前台传值是否为空，如不为空则进行迷糊查询
		if(keywords==null || "".equals(keywords)){
			mapPage.put("keywords", "");//为空不传值
		}else {
			mapPage.put("keywords", "%"+keywords+"%");//不为空传值模糊查询
		}
		Map<String,Object> map = new HashMap<String,Object>();//定义Map集合用于将前台的值
		List<ErpPurchase> list = erpPurchaseService.selectAll(mapPage);//查询增加原材料数据

		map.put("code", 0);
		map.put("msg", "");

	}

	/**
	 * 随机生成字符串
	 * @param size 位数
	 * @return 随机字符串
	 */
	public static String getRandomString(int size){
		String s = RandomStringUtils.random(size,char_random) ; 
		return s  ;
	}

	/**
	 * 得到随机数字
	 * @param num
	 * @return
	 */
	public static int getRandomNumber(int num){
		int n = random.nextInt(num) ;
		return n ;
	}
	/**
	 * 提供字符串判断是否为空
	 * @param input
	 * @return input为空返回true
	 */
	public static boolean isEmpty(String input){
		return null==input || 0==input.length() || 0==input.replaceAll("\\s", "").length();
	}
	/**
	 * 得到编号
	 * @param data
	 * @param type
	 * @return
	 */
	public static String getSerial(String data,String type){
		if(Tools.isEmpty(data)){
			return type+""+Tools.getDateStr(new Date())+"-001";
		}
		String ser = data.substring(data.lastIndexOf("-")+1,data.length());
		String seril ="";
		if(ser.indexOf("0")!=-1){
			seril = ser.substring(ser.lastIndexOf("0")+1,ser.length());
			System.out.println("输出一下serial+"+seril);
		}else{
			seril = ser.substring(ser.lastIndexOf("-")+1,ser.length());

/**
 * 采购订单Action
 * 2017年10月19日-下午2:01:02
 */
@Controller
@RequestMapping("Purchase")
public class ErpPurchaseAction {
	/**
	 * 注入采购订单Service
	 */
	@Resource
	private ErpPurchaseService erpPurchaseService;

	/**
	 * 注入原材料Service
	 */
	@Resource
	private ErpRawService erpRawService;

	/**
	 * 注入订单详细Service
	 */
	@Resource
	private ErpPurchaseDetailsService erpPurchaseDetailsService;

	/**
	 * 注入货品表Service
	 */
	@Resource
	private ErpKindsService erpKindsService;

	/**
	 * 注入合同Service
	 */
	@Resource
	private ErpPactService erpPactService;

	 */
	@RequestMapping("/showAlls")
	@ResponseBody
	public Map<String,Object> showAlls(String keywords,String page,String limit){
		Map<String,Object> mapPage = new HashMap<String,Object>();//定义Map集合
		Pages pages = new Pages();//得到分页类
		pages.setCurPage(Integer.valueOf(page));//当前页数
		pages.setMaxResult(Integer.valueOf(limit));//每页显示最大条数
		mapPage.put("pages", pages);//传入分页参数
		//判断前台传值是否为空，如不为空则进行迷糊查询
		if(keywords==null || "".equals(keywords)){
			mapPage.put("keywords", "");//为空不传值
		}else {
			mapPage.put("keywords", "%"+keywords+"%");//不为空传值模糊查询
		}
		Map<String,Object> map = new HashMap<String,Object>();//定义Map集合用于将前台的值
		List<ErpPurchase> list = erpPurchaseService.selectAlls(mapPage);//查询增加成品数据

		map.put("code", 0);
		map.put("msg", "");
		map.put("count", erpPurchaseService.purchaseFindRow(mapPage));//规定分页信息
		map.put("data", list);//传入list
		return map;//返回map
	}

	/**
	 * 删除（修改状态）
	 * @param state
	 * @param purcId
	 * @return eph
	 */
	@RequestMapping("/delete")
	@ResponseBody
	public ErpPurchase delete(ErpPurchase isva , String purcId){
		ErpPurchase eph = new ErpPurchase();//得到采购订单Model
		isva.setIsva(0);//得到状态值
		isva.setPurcId(purcId);//传入采购ID
		int d_purcId = erpPurchaseService.updateByPrimaryKeySelective(isva);//进行修改
		return eph;//返回eph
	}

	/**