基于javaweb+mysql的springboot婚纱影楼摄影预约网站设计和实现(javaweb+ssm+springboot)

最新推荐文章于 2024-02-16 19:17:07 发布
最新推荐文章于 2024-02-16 19:17:07 发布
阅读量192 收藏 1
点赞数 1
文章标签： java mysql spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71327920/article/details/132113412
版权

基于javaweb+mysql的springboot婚纱影楼摄影预约网站设计和实现(javaweb+ssm+springboot)

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

基于javaweb+mysql的SpringBoot婚纱影楼摄影预约网站设计和实现(javaweb+ssm+springboot)

主要功能设计： 运行环境: java jdk 1.8 环境：IDEA tomcat环境： Tomcat 7.x、8

主要功能说明： 管理员角色包含以下功能：管理员登录,订单管理,摄影师管理,级别管理,标签管理,摄影地点管理,客片管理,轮播图管理,资讯管理等功能。

客户角色包含以下功能：客户首页,客片欣赏,预约摄影师,会员登录,填写预约摄影师信息,查看活动,订单查看等功能。

技术框架： HTML+CSS+JavaScript+jsp+mysql+Spring+SpringMVC+mybatis+Spring boot 数据库： Mysql数据库

		}
		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);


/**
 */
@Controller
@Scope("prototype")
public class PhotographerController {

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

    @Resource(name = "photographerService")
    private IPhotographerService photographerService;
    @Resource(name = "photographerLabelService")
    IPhotographerLabelService photographerLabelService;
    @Resource(name = "photographerLevelService")
    IPhotographerLevelService photographerLevelService;
    @Resource(name = "photographerSpotsService")
    IPhotographerSpotsService photographerSpotsService;

    /**
     * 添加摄影师
     *
     * @param photographer
     * @param HttpServletRequest
     * @return
     */
    @RequestMapping(value = "addPhotographer", method = RequestMethod.POST)
    @ResponseBody
    public ReturnResult addPhotographer(TPhotographer photographer, HttpServletRequest request, Integer labelId,
                                        Integer levelId, Integer spotsId) {
        returnResult.setStatus(ReturnCodeType.FAILURE);


/**
 * 
 *
 */
@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;

	}

	/**

			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);
				}
			}

	/**
	 * 根据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

			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;
	}
	/**

	 * @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) {


/**
 * 
 *
 */
@Controller
@Scope("prototype")
public class BannerController {

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

	@Resource(name = "bannerService")
	private IBannerService bannerService;

	/**
	 * 添加banner图
	 * 
	 * @param banner
	 * @param HttpServletRequest
	 * @return
	 */
	@RequestMapping(value = "addBanner", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult addBanner(TBanner banner, HttpServletRequest request) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {

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

	}

	/**

	 * @return
	 */
	@RequestMapping(value = "getBannerById", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getBannerById(Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(bannerService.selectByPrimaryKey(id));
		} catch (Exception e) {
			logger.error("根据id获取banner失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 获取所有的banner
	 * @return
	 */
	@RequestMapping(value = "getAllBanner")
	@ResponseBody
	public ReturnResult getAllBanner(PageVO page) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT DISTINCT * FROM t_banner WHERE 1=1");
		
			
			List<Map<String, Object>> results = bannerService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = bannerService.selectCount(new TBanner());
				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("分页获取banner失败" + e);
		}

	}
	
	/**
	 * 修改banner的title
	 * @param banner
	 * @return
	 */
	@RequestMapping(value = "updateBanner", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult updateBanner(TBanner banner) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			bannerService.updateBySQL("UPDATE t_banner SET title='" + banner.getTitle() + "' WHERE id=" + banner.getId());
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("修改banner失败" + e);
		}
		return returnResult;
	}
	/**
	 * 根据id获取banner
	 * @param banner
	 * @return
	 */
	@RequestMapping(value = "getBannerById", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getBannerById(Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(bannerService.selectByPrimaryKey(id));
		} catch (Exception e) {
			logger.error("根据id获取banner失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 获取所有的banner
	 * @return
	 */
	@RequestMapping(value = "getAllBanner")
	@ResponseBody
	public ReturnResult getAllBanner(PageVO page) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {

			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT a.*,b.`name` AS photographer,c.`name` AS spots FROM t_works a,t_photographer b,t_spots c WHERE a.photographerId=b.id AND a.spotsId=c.id");
			StringBuffer countSql = new StringBuffer("SELECT COUNT(*) AS total FROM t_works a,t_photographer b,t_spots c WHERE a.photographerId=b.id AND a.spotsId=c.id");
			if(StringUtils.isNotBlank(photographerId)){
				sql.append(" AND b.id="+photographerId);
				countSql.append(" AND b.id="+photographerId);
			}
			if(StringUtils.isNotBlank(spotsId)){
				sql.append(" AND c.id="+spotsId);
				countSql.append(" AND c.id="+spotsId);
			}
			if(StringUtils.isNotBlank(status)){
				sql.append(" AND a.status="+status);
				countSql.append(" AND a.status="+status);
			}
			List<Map<String, Object>> results = worksService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = Integer.valueOf(worksService.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("分页获取works失败" + e);
		}
		return returnResult;
	}
	/**
	 * 分页获取启用的works
	 * @return
	 */
	@RequestMapping(value = "getWorksListByPageStatus", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getWorksListByPageStatus(String sord,String spotsId) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			String sql = "SELECT * FROM t_works WHERE status=0";
			if(StringUtils.isNotBlank(sord)){

				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);

	/**
	 * 修改info的title和content
	 * @param info
	 * @return
	 */
	@RequestMapping(value = "updateInfo", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult updateInfo(TInfomation info) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			infoService.updateBySQL("UPDATE t_infomation SET title='" + info.getTitle() + "', content='"+info.getContent()+"', status="+info.getStatus()+" WHERE id=" + info.getId());
			returnResult.setStatus(ReturnCodeType.SUCCESS);
		} catch (Exception e) {
			logger.error("修改info失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 分页获取info
	 * @return
	 */
	@RequestMapping(value = "getInfoListByPage", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getInfoListByPage(PageVO page) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT DISTINCT * FROM t_infomation WHERE 1=1");
		
			
			List<Map<String, Object>> results = infoService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = infoService.selectCount(new TInfomation());
				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);

        return returnResult;
    }

    /**
     * 分页获取启用的photographer
     *
     * @return
     */
    @RequestMapping(value = "getPhotographerListByPageStatus", method = RequestMethod.POST)
    @ResponseBody
    public ReturnResult getPhotographerListByPageStatus(PageVO page, String labelId, String levelId, String spotsId,
                                                        String start, String end) {
        returnResult.setStatus(ReturnCodeType.FAILURE);
        try {
            Map<String, Object> resultMap = new HashMap<String, Object>();
            StringBuffer sql = new StringBuffer(
                    "SELECT a.*,f.`name` AS label,g.`name` AS level,h.`name` AS spots FROM t_photographer a,t_photographer_label b,t_photographer_level c ,t_photographer_spots d,t_label f,t_level g,t_spots h WHERE a.id=b.photographerId AND a.id = c.photographer AND a.id = d.photographerId AND f.id=b.labelId AND g.id=c.levelId AND h.id= d.spotsId AND a.status=0");

            StringBuffer countSql = new StringBuffer("SELECT COUNT(*) AS total FROM t_photographer a,t_photographer_label b,t_photographer_level c ,t_photographer_spots d,t_label f,t_level g,t_spots h WHERE a.id=b.photographerId AND a.id = c.photographer AND a.id = d.photographerId AND f.id=b.labelId AND g.id=c.levelId AND h.id= d.spotsId AND a.status=0");
            if (StringUtils.isNotBlank(start) && StringUtils.isNotBlank(end)) {
                List<String> list = photographerService.selectByStartEnd(start, end);
                for (String id : list) {
                    sql.append(" AND a.id!=" + id);
                    countSql.append(" AND a.id!=" + id);
                }
            }
            if (StringUtils.isNotBlank(labelId)) {
                sql.append(" AND b.labelId=" + labelId);
                sql.append(" AND f.id=" + labelId);
                countSql.append(" AND b.labelId=" + labelId);
                countSql.append(" AND f.id=" + labelId);
            }
            if (StringUtils.isNotBlank(levelId)) {
                sql.append(" AND c.levelId=" + levelId);
                sql.append(" AND g.id=" + levelId);
                countSql.append(" AND c.levelId=" + levelId);
                countSql.append(" AND g.id=" + levelId);
            }
            if (StringUtils.isNotBlank(spotsId)) {
                sql.append(" AND d.spotsId=" + spotsId);

		}
		filePath = filePath.replace(request.getServletContext().getRealPath("/"), "/");
		filePath = filePath.replaceAll("\\\\", "/");
		Map<String, Object> result = new HashMap<String,Object>();
		result.put("data", filePath);
		result.put("status", 0);
		return result;
	}

}

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

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

	@Resource(name = "spotsService")

 * @Description 操作文件工具类
 * @Version v1.0
 */
public final class OperationFileUtil {
    private static final String ENCODING = "utf-8";

    /**
     * 文件下载
     * 
     * @param filePath
     *            文件路径
     * @return
     * @throws UnsupportedEncodingException
     * @throws IOException
     */
    public static ResponseEntity<byte[]> download(String filePath) throws UnsupportedEncodingException, IOException {
        String fileName = FilenameUtils.getName(filePath);
        return downloadAssist(filePath, fileName);
    }

    /**
     * 文件下载
     * 
     * @param filePath
     *            文件路径
     * @param fileName
     *            文件名
     * @return
     * @throws UnsupportedEncodingException
     * @throws IOException
     */
    public static ResponseEntity<byte[]> download(String filePath, String fileName) throws UnsupportedEncodingException, IOException {
        return downloadAssist(filePath, fileName);
    }

    /**
     * 文件下载辅助
     * 
     * @param filePath
     *            文件路径
     * @param fileName
     *            文件名
     * @return
     * @throws UnsupportedEncodingException

	public ReturnResult getWorksListByPage(PageVO page,String photographerId,String spotsId,String status) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT a.*,b.`name` AS photographer,c.`name` AS spots FROM t_works a,t_photographer b,t_spots c WHERE a.photographerId=b.id AND a.spotsId=c.id");
			StringBuffer countSql = new StringBuffer("SELECT COUNT(*) AS total FROM t_works a,t_photographer b,t_spots c WHERE a.photographerId=b.id AND a.spotsId=c.id");
			if(StringUtils.isNotBlank(photographerId)){
				sql.append(" AND b.id="+photographerId);
				countSql.append(" AND b.id="+photographerId);
			}
			if(StringUtils.isNotBlank(spotsId)){
				sql.append(" AND c.id="+spotsId);
				countSql.append(" AND c.id="+spotsId);
			}
			if(StringUtils.isNotBlank(status)){
				sql.append(" AND a.status="+status);
				countSql.append(" AND a.status="+status);
			}
			List<Map<String, Object>> results = worksService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = Integer.valueOf(worksService.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("分页获取works失败" + e);
		}
		return returnResult;
	}
	/**
	 * 分页获取启用的works
	 * @return
	 */
	@RequestMapping(value = "getWorksListByPageStatus", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getWorksListByPageStatus(String sord,String spotsId) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			String sql = "SELECT * FROM t_works WHERE status=0";
			if(StringUtils.isNotBlank(sord)){
				sql="SELECT * FROM t_works WHERE status=0 ORDER BY id DESC";
			}
			if(StringUtils.isNotBlank(spotsId)){
				sql = "SELECT * FROM t_works WHERE status=0 AND spotsId="+spotsId;
			}
				returnResult.setStatus(ReturnCodeType.SUCCESS).setData(worksService.selectBySQL(sql));
		}catch (Exception e) {

	@ResponseBody
	public ReturnResult getWorksByPhotographerId(Integer id) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			returnResult.setStatus(ReturnCodeType.SUCCESS).setData(worksService.getWorksByPhotographerId(id));
		} catch (Exception e) {
			logger.error("根据photographerid获取Works失败" + e);
		}
		return returnResult;
	}
	
	/**
	 * 分页获取works
	 * @return
	 */
	@RequestMapping(value = "getWorksListByPage", method = RequestMethod.POST)
	@ResponseBody
	public ReturnResult getWorksListByPage(PageVO page,String photographerId,String spotsId,String status) {
		returnResult.setStatus(ReturnCodeType.FAILURE);
		try {
			Map<String, Object> resultMap = new HashMap<String, Object>();
			StringBuffer sql = new StringBuffer("SELECT a.*,b.`name` AS photographer,c.`name` AS spots FROM t_works a,t_photographer b,t_spots c WHERE a.photographerId=b.id AND a.spotsId=c.id");
			StringBuffer countSql = new StringBuffer("SELECT COUNT(*) AS total FROM t_works a,t_photographer b,t_spots c WHERE a.photographerId=b.id AND a.spotsId=c.id");
			if(StringUtils.isNotBlank(photographerId)){
				sql.append(" AND b.id="+photographerId);
				countSql.append(" AND b.id="+photographerId);
			}
			if(StringUtils.isNotBlank(spotsId)){
				sql.append(" AND c.id="+spotsId);
				countSql.append(" AND c.id="+spotsId);
			}
			if(StringUtils.isNotBlank(status)){
				sql.append(" AND a.status="+status);
				countSql.append(" AND a.status="+status);
			}
			List<Map<String, Object>> results = worksService.selectPageBySQL(sql.toString(), page.getPage() - 1,
					page.getRows());
			if (!results.isEmpty() && results != null) {
				int total = Integer.valueOf(worksService.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);

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

m0_71327920
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于Pythonweb的摄影网站设计与实现
blsm3596的博客
12-09 2712
泉州信息工程学院 软件学院 课程设计报告书 课 程 名: python课程设计 课程设计项目名称： 摄影网站设计 团队成员： 黄志伟 刘斌峰 俞羡蓉 一、项目简介 1.1 项目博客地址 https://www.cnblogs.com/cyz-2016/ 1.2 项目完成的功能与特色 通过使用Django为框架，建立一个摄影的网站，从而让喜欢摄影的人们在这里分享自己的作品，对摄影有一点深入了...
Java项目:婚纱影楼摄影预约网站设计和实现(javaweb+SSM+springboot)
常年被追砍的博客
06-28 1129
主要功能设计： 运行环境:java jdk 1.8 环境：IDEA tomcat环境：Tomcat 7.x、8 主要功能说明：管理员角色包含以下功能：管理员登录,订单管理,摄影师管理,级别管理,标签管理,摄影地点管理,客片管理,轮播图管理,资讯管理等功能。 客户角色包含以下功能：客户首页,客片欣赏,预约摄影师,会员登录,填写预约摄影师信息,查看活动,订单查看等功能。 技术框架：HTML+CSS+JavaScript+jsp+mysql+Spring+SpringMVC+mybatis+...
摄影网站的设计与实现.pdf
10-07
摄影网站的设计与实现.pdf
基于JAVA的摄影网站的设计与实现
weixin_45769113的博客
09-20 760
开发工具(eclipse/idea/vscode等)： 数据库(sqlite/mysql/sqlserver等)： 功能模块(请用文字描述，至少200字)：
基于Vue和NodeJs摄影网站的设计与实现
03-13 591
摄影网站主要划分为前台功能模块和后台功能模块两大功能模块。 前台功能模块：用户注册、用户登录、样本查看、样本收藏、样本评论、活动预约和联系客服； 后台功能模块：用户登录、样本类型管理、样本详情管理、活动信息管理、预定信息管理、留言回复管理和系统设置功能。
Java项目:在线婚纱摄影预定系统(java+javaweb+SSM+springboot+mysql)源码
11-20
一、项目简述 ...环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术：HTML+CSS+JavaScript+jsp+mysql+Spring+SpringMVC+mybatis+Spring boot
Java项目:婚纱影楼摄影商城系统(java+SSM+JSP+jQuery+Mysql)
06-28
按分类查看,用户登录,查看商品详情,加入购物车,提交订单,查看订单,修改个人信息,查看网站公告,查看拍摄基地等功能。 环境需要 1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。 2...
Java项目:在线婚纱摄影预定系统(java+javaweb+SSM+springboot+mysql)
03-15
一、项目简述 ...环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： Jdbc+ Servlert + html+ css + JavaScript + JQuery + Ajax + Fileupload
摄影爱好者网站设计与实现
07-29
使用asp.net三层架构实现，网站实现图片上传，文章上传，留言回复等功能。使用jquery技术，html技术等
基于HTML5的摄影主题网站的设计与实现要求
04-05
基于HTML5的摄影主题网站的设计与实现要求基于HTML5的摄影主题网站的设计与实现要求
摄影网站源码
01-12
摄影 网站 源码
网上订餐python_网上订餐管理系统摘要.doc
weixin_39797264的博客
12-05 856
网上订餐管理系统摘要网上订餐管理系统的设计与实现摘要随着传统的购物方式正在向网络化发展，出现了“网购”这种越来越受欢迎的新型消费方式。为了提高餐饮业务水平和效率，实现比电话订购更有效的送餐业务，网上订餐系统因运而生。通过对订餐流程和业务进行全面考察分析，结合目前最先进的软件开发技术，实现了订餐的网络化管理。目前，网上订餐业务还处于形成期，成长空间还很大。论文中详细对网上订餐系统进行了需求分析和总体...
计算机毕业设计springboot摄影网站的设计与实现v09879【附源码+数据库+部署+LW】
海灵学姐
07-31 500
摄影网站的设计与实现是一个备受关注的话题，随着数字摄影技术的快速发展和普及，越来越多的人开始热衷于摄影。因此，建立一个专门为摄影爱好者提供交流、学习和展示作品的平台变得尤为重要。本文将从选题背景和意义两个方面进行阐述。 选题背景： 如今，摄影已经成为一种广泛流行的艺术形式和生活方式。越来越多的人购买相机并投入到摄影中，他们希望能够通过摄影记录生活、表达情感，并与其他摄影爱好者分享自己的作品。然而，传统的社交媒体平台并不能完全满足摄影爱好者的需求，因为它们更加注重文字内容，对于图片的展示和交流功能有限。因此
PHP摄影网站怎么制作,摄影网站的设计与实现.doc
weixin_28932927的博客
03-09 994
设计(论文)题目摄影网站的设计与实现院(系)： 电子与信息工程学院学生姓名： XXX专业班级： 13计算机应用3班学 号： XXXXXXXX指导教师： 巫 锦 润2015 年 6月15日目 录TOC \o "1-3" \h \u 11841 摘 要 127735 第一章 绪论 210919 1.1课题背景 222641 1.2课题意义 223...
django摄影网站的设计与实现(程序+开题报告)
最新发布
橙蓝毕设程序
02-16 837
最后，一个功能全面的摄影网站能够吸引更多的用户，形成良好的社区氛围，从而带动整个摄影行业的发展。[3] 郭婺, 郭建, 张劲松, 石翠萍, 刘道森, 刘超. 基于Python的网络爬虫的设计与实现[J]. 信息记录材料, 2023, 24 (04): 159-162.后端框架: Python开发的 Django 框架。[1] 张华, 翟新军, 胥勇, 李伟强, 杨健, 赵嘉伟, 张涛. Python在集控大数据应用的研究[J]. 价值工程, 2023, 42 (21): 84-86.
HTML5期末大作业：企业网页设计——摄影店铺5页(代码质量好) 学生DW网页设计作业源码 web课程设计网页规划与设计
m0_73143096的博客
08-04 713
常见网页设计作业题材有 个人、 美食、 公司、 学校、 旅游、 电商、 宠物、 电器、 茶叶、 家居、 酒店、 舞蹈、 动漫、 明星、 服装、 体育、 化妆品、 物流、 环保、 书籍、 婚纱、 军事、 游戏、 节日、 戒烟、 电影、 摄影、 文化、 家乡、 鲜花、 礼品、 汽车、 其他 等网页设计题目, 可满足大学生网页大作业和毕业网页设计需求!4.首页栏目数量不少于 3 个，各栏目能正确链接到相应栏目页面，同时各栏目页面能正确返回网站首页。5.网站内容具有原创性，内容充实，特效且运用合理。...
php+mysql婚纱摄影网站的设计与实现
shenchengyv的博客
10-17 1297
在社会经济飞速发展的21世纪，数码技术已经全面容入到人们生活中，随着计算机科学技术的日益发展，越来越多的摄影工作室层出不穷，人们生活中也离不开摄影，它不仅仅是爱好，更多的是一种美好的回忆。尤其是现在婚纱摄影、写真等深受人们的喜欢，也是当前社会摄影业发展的必然趋，对于摄影工作室来说，面向客户群体宠大，信息量也较大，客户需要拍照片，需要去实体店进行咨询、预订，花费时间较多，且效率也较低。传统的影楼宣传工作效率也较低，因此，传统的摄影工作室管理模式显然是满足不了客户需求和摄影的发展需求。
JavaWeb+SpringBoot流浪宠物管理系统设计与实现
"基于JavaWeb+SpringBoot的流浪宠物管理系统源码数据库" 该资源是一个毕业设计项目，构建了一个基于JavaWeb和SpringBoot的流浪宠物管理系统，旨在改进传统的人工管理模式，提高工作效率并提升用户体验。系统利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值