Java项目:摄影跟拍预定管理系统(java+SpringBoot+Vue+Layui+ElementUI+Mysql)

于 2023-11-13 10:20:48 发布
阅读量677 收藏 2
点赞数 18
分类专栏： Java毕业设计项目实战篇 文章标签： java spring boot vue.js layui mysql elementui
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66863468/article/details/134371452
版权

源码获取：俺的博客首页 "资源" 里下载！ 

项目介绍

基于SpringBoot Vue的摄影跟拍预定管理系统

角色：管理员、用户、摄像师

管理员；管理员使用本系统涉到的功能主要有：首页、个人中心、用户管理、摄影师管理、摄影跟拍管理、类别管理、周边商品管理、商品类型管理、跟拍预约管理、跟拍流程管理、成品信息管理、商品订单管理、系统管理等功能。

用户:主要包括首页、个人中心、跟拍预约管理、跟拍流程管理、成品信息管理、商品订单管理、评论信息管理、我的收藏管理等功能。

摄影师；摄影师使用本系统涉到的功能主要有：首页、个人中心、跟拍预约管理、跟拍流程管理、成品信息管理、商品订单管理等功能。


环境需要

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


技术栈

后端：SpringBoot+Mybaits
前端：layui+Vue+ELementUI 

使用说明

项目运行：
1. 使用Navicat或者其它工具，在mysql中创建对应sql文件名称的数据库，并导入项目的sql文件；
2. 使用IDEA/Eclipse/MyEclipse导入项目，导入成功后请执行maven clean;maven install命令，然后运行；
3. 将项目中application.yml配置文件中的数据库配置改为自己的配置;
4. 运行项目，控制台提示运行成功后再去运行前端项目；
5. 管理员用户名密码：admin/admin
普通用户名密码：user/123456

文档介绍（背景以及意义、国内外研究概况、研究的内容、关键技术的研究、B/S架构、java技术介绍、mysql数据库介绍、Springboot框架、系统分析、系统设计目标、系统可行性分析、系统功能分析和描述、系统UML用例分析、管理员用例、前台首页、系统流程分析、台南佳信息流程、操作流程、删除信息流程、系统设计、系统体系结构）


 摄影预定管理系统-首页：

 摄影跟拍详情：

公告信息详情： 

周边商品详情列表： 

登录页面详情展示： 

后台管理摄影跟拍列表：

摄影师管理详情：

周边商品管理详情：

 用户管理控制层：

@Controller
@RequestMapping("/user")
@Scope("prototype")
public class UserController {

	private static final Logger logger = LoggerFactory.getLogger(UserController.class);
	private ReturnResult returnResult = new ReturnResult();

	@Resource(name = "userService")
	private IUserService userService;

	/**
	 * 登录
	 * @param user
	 * @param session
	 * @return
	 */
	@RequestMapping(value = "login")
	@ResponseBody
	public ReturnResult login(TUser user, HttpSession session) {
		returnResult.setStatus(ReturnCodeType.FAILURE);

		try {
			user = userService.login(user);
			if (user != null) {
				user.setPassword(null);
				session.setAttribute("user", user);
				returnResult.setStatus(ReturnCodeType.SUCCESS);

			}
		} catch (Exception e) {
			logger.error("登录失败" + e);

		}
		return returnResult;

	}

	/**
	 * 从session中获取用户信息
	 * @param session
	 * @return
	 */
	@RequestMapping("getUserInfo")
	@ResponseBody
	public ReturnResult getUserInfo(HttpSession session) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		TUser user = (TUser) session.getAttribute("user");
		if (user != null) {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(user);
		} else {
			logger.info("获取用户信息失败：用户未登录");
		}
		return returnResult;
	}

	/**
	 * 注册用户
	 * @param user
	 * @return
	 */
	@RequestMapping(value = "register")
	@ResponseBody
	public ReturnResult register(TUser user) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			if (userService.checkUserByName(user.getName())) {
				if (userService.register(user) >= 0) {
					returnResult.setStatus(ReturnCodeType.SUCCESS);
				}
			}

		} catch (Exception e) {
			logger.error("注册失败" + e);
		}

		return returnResult;

	}

	/**
	 * 检测用户名是否存在
	 * @param name
	 * @return
	 */
	@RequestMapping(value = "checkUserName")
	@ResponseBody
	public ReturnResult checkUserName(String name) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			if (userService.checkUserByName(name)) {
				returnResult.setStatus(ReturnCodeType.SUCCESS);
			}

		} catch (Exception e) {
			logger.error("检测用户名是否存在失败：" + e);
		}

		return returnResult;

	}

	/**
	 * 管理员查看所有的用户信息
	 * @param session
	 * @return
	 */
	@RequestMapping("getAllUserInfo")
	@ResponseBody
	public ReturnResult getAllUserInfo(HttpSession session,PageVO page,String name) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			if (session.getAttribute("admin") != null) {
				Map<String, Object> resultMap = new HashMap<String, Object>();
				StringBuffer sql = new StringBuffer("SELECT DISTINCT * FROM t_user WHERE 1=1");
				if(StringUtils.isNotBlank(name)){
					sql.append(" AND name="+name);
				}
				
				List<Map<String, Object>> results = userService.selectPageBySQL(sql.toString(), page.getPage() - 1,
						page.getRows());
				if (!results.isEmpty() && results != null) {
					int total = userService.selectCount(new TUser());
					int rows = page.getRows();
					rows = rows == 0 ? 10 : rows;
					resultMap.put("total", (total % rows != 0 ? (total / rows + 1) : (total / rows)));
					resultMap.put("page", page.getPage());
					resultMap.put("records", total);
					resultMap.put("rows", results);
					returnResult.setStatus(ReturnCodeType.SUCCESS).setData(resultMap);
				}
			} else {
				logger.info("获取所有的用户信息失败：管理员未登录");
			}
		} catch (Exception e) {
			logger.error("获取所有的用户信息失败：" + e);

		}
		return returnResult;
	}

	/**
	 * 退出
	 * @param session
	 * @return
	 */
	@RequestMapping("logout")
	@ResponseBody
	public ReturnResult logout(HttpSession session) {
		session.invalidate();
		return returnResult.setStatus(ReturnCodeType.SUCCESS);
	}

	/**
	 * 修改密码
	 * @param oldPassword
	 * @param password
	 * @param session
	 * @return
	 */
	@RequestMapping("updatePassword")
	@ResponseBody
	public ReturnResult updatePassword(TUser user) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
				if (userService.updatePassword(user) > 0) {
					returnResult.setStatus(ReturnCodeType.SUCCESS);
				}
		} catch (Exception e) {
			logger.error("修改密码失败：" + e);
		}
		return returnResult;
	}
	
}

拍摄景点管理控制层：

@Controller
@Scope("prototype")
public class SpotsController {

	private static final Logger logger = LoggerFactory.getLogger(SpotsController.class);
	private ReturnResult returnResult = new ReturnResult();

	@Resource(name = "spotsService")
	private ISpotsService spotsService;

	/**
	 * 添加拍摄景点
	 * 
	 * @param spots
	 * @param HttpServletRequest
	 * @return
	 */
	@RequestMapping(value = "addSpots", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult addSpots(TSpots spots, HttpServletRequest request) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {

			Map<String, String> map = OperationFileUtil.multiFileUpload(request,
					request.getServletContext().getRealPath("/") + "uploads\\spots\\");
			String filePath = "";
			for (Map.Entry<String, String> entry : map.entrySet()) {
				filePath = entry.getValue();
			}
			filePath = filePath.replace(request.getServletContext().getRealPath("/"), "/");
			spots.setPath(filePath);
			spots.setCreatetime(new Date());
			spotsService.insert(spots);
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("新增spots失败" + e);
		}
		return returnResult;

	}

	
	/**
	 * 修改spots
	 * @param spots
	 * @return
	 */
	@RequestMapping(value = "updateSpots", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult updateSpots(TSpots spots) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			spotsService.updateBySQL("UPDATE t_spots SET name='" + spots.getName() + "',content='"+spots.getContent()+"', status="+spots.getStatus()+" WHERE id=" + spots.getId());
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("修改spots失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 分页获取spots
	 * @return
	 */
	@RequestMapping(value = "getSpotsListByPage", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getSpotsListByPage(PageVO page) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT DISTINCT * FROM t_spots WHERE 1=1");
		
			
			List<Map<String, Object>> results = spotsService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = spotsService.selectCount(new TSpots());
				int rows = page.getRows();
				rows = rows == 0 ? 10 : rows;
				resultMap.put("total", (total % rows != 0 ? (total / rows + 1) : (total / rows)));
				resultMap.put("page", page.getPage());
				resultMap.put("records", total);
				resultMap.put("rows", results);
				returnResult.setStatus(ReturnCodeType.SUCCESS).setData(resultMap);
			}
		}catch (Exception e) {
			logger.error("分页获取spots失败" + e);
		}
		return returnResult;
	}
	/**
	 * 根据获取id spots
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "getSpotsById", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getSpotsById(Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
				returnResult.setStatus(ReturnCodeType.SUCCESS).setData(spotsService.selectByPrimaryKey(id));
		}catch (Exception e) {
			logger.error("根据获取spots失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 获取所有启用的spots
	 * @return
	 */
	@RequestMapping(value = "getAllSpots", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getAllSpots() {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(spotsService.getAllSpots());
		} catch (Exception e) {
			logger.error("获取所有启用spots失败" + e);
		}
		return returnResult;
	}
	/**
	 * 获取所有5条启用的spots
	 * @return
	 */
	@RequestMapping(value = "getFiveSpots", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getFiveSpots() {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(spotsService.selectBySQL("select * from t_spots  ORDER BY id DESC limit 0,5"));
		} catch (Exception e) {
			logger.error("获取所有5条启用的spots失败" + e);
		}
		return returnResult;
	}

}

标签管理控制层： 

@Controller
@Scope("prototype")
public class LabelController {

	private static final Logger logger = LoggerFactory.getLogger(LabelController.class);
	private ReturnResult returnResult = new ReturnResult();

	@Resource(name = "labelService")
	private ILabelService labelService;

	/**
	 * 添加标签
	 * 
	 * @param Label
	 * @return
	 */
	@RequestMapping(value = "addLabel", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult addLabel(TLabel label) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {

			label.setCreatetime(new Date());
			label.setStatus("0");
			labelService.insert(label);
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("新增label失败" + e);
		}
		return returnResult;

	}

	
	
	
	/**
	 * 修改label
	 * @param label
	 * @return
	 */
	@RequestMapping(value = "updateLabel", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult updateLabel(TLabel label) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			labelService.updateBySQL("UPDATE t_label SET name='" + label.getName() + "', status="+label.getStatus()+" WHERE id=" + label.getId());
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("修改label失败" + e);
		}
		return returnResult;
	}
	
	
	/**
	 * 根据id获取label
	 * @param label
	 * @return
	 */
	@RequestMapping(value = "getLabelById", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getLabelById(Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(labelService.selectByPrimaryKey(id));
		} catch (Exception e) {
			logger.error("根据id获取label失败" + e);
		}
		return returnResult;
	}
	/**
	 * 分页获取label
	 * @return
	 */
	@RequestMapping(value = "getLabelListByPage", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getLabelListByPage(PageVO page,String Status) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT * FROM t_label WHERE 1=1");
			StringBuffer countSql = new StringBuffer("SELECT COUNT(*) AS total FROM t_label WHERE 1=1");
			
		    if(StringUtils.isNotBlank(Status)){
		    	sql.append(" AND status="+Status);
		    	countSql.append(" AND status="+Status);
		    }
		   
			
			List<Map<String, Object>> results = labelService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total =Integer.valueOf(labelService.selectBySQL(countSql.toString()).get(0).get("total").toString());
				int rows = page.getRows();
				rows = rows == 0 ? 10 : rows;
				resultMap.put("total", (total % rows != 0 ? (total / rows + 1) : (total / rows)));
				resultMap.put("page", page.getPage());
				resultMap.put("records", total);
				resultMap.put("rows", results);
				returnResult.setStatus(ReturnCodeType.SUCCESS).setData(resultMap);
			}
		}catch (Exception e) {
			logger.error("分页获取label失败" + e);
		}
		return returnResult;
	}
	/**
	 * 获取所有启用的label
	 * @param label
	 * @return
	 */
	@RequestMapping(value = "getAllLabel", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getAllLabel(){
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(labelService.getAllLabel());
		} catch (Exception e) {
			logger.error("获取所有启用的label" + e);
		}
		return returnResult;
	}
}

 级别管理控制层：

@Controller
@Scope("prototype")
public class LevelController {

	private static final Logger logger = LoggerFactory.getLogger(LevelController.class);
	private ReturnResult returnResult = new ReturnResult();

	@Resource(name = "levelService")
	private ILevelService levelService;

	/**
	 * 添加级别
	 * 
	 * @param level
	 * @return
	 */
	@RequestMapping(value = "addLevel", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult addLevel(TLevel level) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {

			level.setCreatetime(new Date());
			level.setStatus("0");
			levelService.insert(level);
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("新增level失败" + e);
		}
		return returnResult;

	}

	/**
	 * 修改level状态
	 * @param level
	 * @return
	 */
	@RequestMapping(value = "updatelevelStatus", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult updatelevelStatus(TLevel level) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			levelService.updateBySQL("UPDATE t_level SET status=" + level.getStatus() + " WHERE id=" + level.getId());
			
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("更新level状态失败" + e);
		}
		return returnResult;
	}
	
	
	/**
	 * 修改level的name
	 * @param level
	 * @return
	 */
	@RequestMapping(value = "updateLevel", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult updateLevel(TLevel level) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			levelService.updateBySQL("UPDATE t_level SET name='" + level.getName() + "', status="+level.getStatus()+" WHERE id=" + level.getId());
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("修改level失败" + e);
		}
		return returnResult;
	}
	/**
	 * 根据id获取level
	 * @param level
	 * @return
	 */
	@RequestMapping(value = "getLevelById", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getLevelById(Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(levelService.selectByPrimaryKey(id));
		} catch (Exception e) {
			logger.error("根据id获取level失败" + e);
		}
		return returnResult;
	}
	/**
	 * 分页获取level
	 * @return
	 */
	@RequestMapping(value = "getLevelListByPage", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getLevelListByPage(PageVO page,String Status) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT * FROM t_level WHERE 1=1");
			StringBuffer countSql = new StringBuffer("SELECT COUNT(*) AS total FROM t_level WHERE 1=1");
			
		    if(StringUtils.isNotBlank(Status)){
		    	sql.append(" AND status="+Status);
		    	countSql.append(" AND status="+Status);
		    }
		   
			
			List<Map<String, Object>> results = levelService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = Integer.valueOf(levelService.selectBySQL(countSql.toString()).get(0).get("total").toString());
				int rows = page.getRows();
				rows = rows == 0 ? 10 : rows;
				resultMap.put("total", (total % rows != 0 ? (total / rows + 1) : (total / rows)));
				resultMap.put("page", page.getPage());
				resultMap.put("records", total);
				resultMap.put("rows", results);
				returnResult.setStatus(ReturnCodeType.SUCCESS).setData(resultMap);
			}
		}catch (Exception e) {
			logger.error("分页获取level失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 获取所有启用的level
	 * @param level
	 * @return
	 */
	@RequestMapping(value = "getAllLevel", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getAllLevel(){
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(levelService.getAllLevel());
		} catch (Exception e) {
			logger.error("获取所有启用的level" + e);
		}
		return returnResult;
	}
}

 预约管理控制层：

@Controller
@Scope("prototype")
public class ScheduleController {

	private static final Logger logger = LoggerFactory.getLogger(ScheduleController.class);
	private ReturnResult returnResult = new ReturnResult();

	@Resource(name = "scheduleService")
	private IScheduleService scheduleService;

	/**
	 * 添加预约
	 * 
	 * @param schedule
	 * @param session
	 * @return
	 */
	@RequestMapping(value = "addSchedule", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult addSchedule(TSchedule schedule, HttpSession session,String startdate,String enddate) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			schedule.setStart(DateFormater.stringToDate(startdate));
			schedule.setEnd(DateFormater.stringToDate(enddate));
			schedule.setCreatetime(new Date());
			TUser user = (TUser)session.getAttribute("user");
			schedule.setUserid(user.getId());
			if(scheduleService.insert(schedule)>0){
				returnResult.setStatus(ReturnCodeType.SUCCESS);
			}
		} catch (Exception e) {
			logger.error("新增schedule失败" + e);
		}
		return returnResult;

	}

	/**
	 * 修改schedule状态
	 * @param schedule
	 * @return
	 */
	@RequestMapping(value = "updateScheduleStatus", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult updateScheduleStatus(TSchedule schedule,HttpSession session) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			session.getAttribute("admin");
			scheduleService.updateBySQL("UPDATE t_schedule SET status=" + schedule.getStatus() + " WHERE id=" + schedule.getId());
			
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("更新schedule状态失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 设置摄影师无档期或有预约
	 * @param schedule
	 * @return
	 */
	@RequestMapping(value = "setSchedule", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult setSchedule(Integer photographerId,String createTimeRange,HttpSession session,String status) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			if(photographerId!=null&&StringUtils.isNotBlank(createTimeRange)){
				String start = createTimeRange.split(" - ")[0];
				String end = createTimeRange.split(" - ")[1];
				session.getAttribute("admin");
				TSchedule schedule = new TSchedule();
				schedule.setUserid(1);
				schedule.setCreatetime(new Date());
				schedule.setStatus(status);
				schedule.setStart(DateFormater.stringToDate("yyyy/MM/dd",start));
				schedule.setEnd(DateFormater.stringToDate("yyyy/MM/dd",end));
				schedule.setPhotographerid(photographerId);
				scheduleService.insert(schedule);
				returnResult.setStatus(ReturnCodeType.SUCCESS);
			}
			
		} catch (Exception e) {
			logger.error("更新schedule状态失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 根据id获取schedule
	 * @param schedule
	 * @return
	 */
	@RequestMapping(value = "getScheduleById", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getScheduleById(Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(scheduleService.selectByPrimaryKey(id));
		} catch (Exception e) {
			logger.error("根据id获取schedule失败" + e);
		}
		return returnResult;
	}
	/**
	 * 根据摄影师id获取schedule
	 * @param schedule
	 * @return
	 */
	@RequestMapping(value = "getScheduleByPhotographerId", method = RequestMethod.GET)
	@ResponseBody
	public ScheduleVO getScheduleByPhotographerId(Integer photoer_id,String year,String month) {
		
		return scheduleService.getScheduleByPhotographerId( photoer_id, year, month);
	}
	
	/**
	 * 分页获取schedule
	 * @return
	 */
	@RequestMapping(value = "getScheduleListByPage", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getScheduleListByPage(PageVO page,String photographerId,String start,String end) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT a.createTime,a.`status`,a.id,a.`start`,a.`end`,b.`name`,b.tel,c.`name` AS photographer FROM t_schedule a, t_user b ,t_photographer c WHERE a.userId = b.id AND a.photographerId =c.id");
			if(StringUtils.isNotBlank(photographerId)){
				sql.append(" AND a.photographerId="+photographerId);
			}
			if(StringUtils.isNotBlank(start)&&StringUtils.isNotBlank(end)){
				sql.append(" AND a.`start` BETWEEN '"+start+"' AND '"+end+"' OR a.`end` BETWEEN '"+start+"' AND '"+end+"'");
			}
			sql.append(" GROUP BY a.id ORDER BY a.createTime DESC");
			List<Map<String, Object>> results = scheduleService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = scheduleService.selectCount(new TSchedule());
				int rows = page.getRows();
				rows = rows == 0 ? 10 : rows;
				resultMap.put("total", (total % rows != 0 ? (total / rows + 1) : (total / rows)));
				resultMap.put("page", page.getPage());
				resultMap.put("records", total);
				resultMap.put("rows", results);
				returnResult.setStatus(ReturnCodeType.SUCCESS).setData(resultMap);
			}
		}catch (Exception e) {
			logger.error("分页获取schedule失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 根据用户获取schedule
	 * @param schedule
	 * @return
	 */
	@RequestMapping(value = "getSchedule", method = RequestMethod.GET)
	@ResponseBody
	public ReturnResult getSchedule(HttpSession session) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		TUser user = (TUser) session.getAttribute("user");
		return returnResult.setStatus(ReturnCodeType.SUCCESS).setData(scheduleService.selectBySQL("SELECT DATE_FORMAT(a.`start`,'%Y-%m-%d') AS start,DATE_FORMAT(a.`end`,'%Y-%m-%d') AS end,b.name,a.`status`,a.id,a.photographerId FROM t_schedule a,t_photographer b WHERE a.photographerId = b.id AND a.userId="+user.getId()));
	}
	/**
	 *删除
	 * @param schedule
	 * @return
	 */
	@RequestMapping(value = "deleteSchedule", method = RequestMethod.GET)
	@ResponseBody
	public ReturnResult deleteSchedule(HttpSession session,Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			 session.getAttribute("user");
			return returnResult.setStatus(ReturnCodeType.SUCCESS).setData(scheduleService.deleteByPrimaryKey(id));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return returnResult;
	}
}

源码获取：俺的博客首页 "资源" 里下载！

qq1334611189
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq1334611189

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值