package org.crazyit.auction.web;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@WebServlet(urlPatterns ={"/auth.jpg"})
public class AuthImg extends HttpServlet
{
    private static final long serialVersionUID = 1L;
    // 定义图形验证码中绘制字符的字体
    private final Font mFont = new Font("Arial Black", Font.PLAIN, 16);
    // 定义图形验证码的大小
    private final int IMG_WIDTH = 100;
    private final int IMG_HEIGTH = 18;
    // 定义一个获取随机颜色的方法
    private Color getRandColor(int fc, int bc)
    {
        Random random = new Random();
        if (fc > 255)
            fc = 255;
        if (bc > 255)
            bc = 255;
        int r = fc + random.nextInt(bc - fc);
        int g = fc + random.nextInt(bc - fc);
        int b = fc + random.nextInt(bc - fc);
        // 得到随机颜色
        return new Color(r, g, b);
    }
    // 重写service方法，生成对客户端的响应
    public void service(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException
    {
        // 设置禁止缓存
        response.setHeader("Pragma", "No-cache");
        response.setHeader("Cache-Control", "no-cache");
        response.setDateHeader("Expires", 0);
        response.setContentType("image/jpeg");
        BufferedImage image = new BufferedImage(IMG_WIDTH, IMG_HEIGTH,
                BufferedImage.TYPE_INT_RGB);
        Graphics g = image.getGraphics();
        Random random = new Random();
        g.setColor(getRandColor(200, 250));
        // 填充背景色
        g.fillRect(1, 1, IMG_WIDTH - 1, IMG_HEIGTH - 1);
        // 为图形验证码绘制边框
        g.setColor(new Color(102, 102, 102));
        g.drawRect(0, 0, IMG_WIDTH - 1, IMG_HEIGTH - 1);
        g.setColor(getRandColor(160, 200));
        // 生成随机干扰线
        for (int i = 0; i < 80; i++)
        {
            int x = random.nextInt(IMG_WIDTH - 1);
            int y = random.nextInt(IMG_HEIGTH - 1);
            int xl = random.nextInt(6) + 1;
            int yl = random.nextInt(12) + 1;
            g.drawLine(x, y, x + xl, y + yl);
        }
        g.setColor(getRandColor(160, 200));
        // 生成随机干扰线
        for (int i = 0; i < 80; i++)
        {
            int x = random.nextInt(IMG_WIDTH - 1);
            int y = random.nextInt(IMG_HEIGTH - 1);
            int xl = random.nextInt(12) + 1;
            int yl = random.nextInt(6) + 1;
            g.drawLine(x, y, x - xl, y - yl);
        }
        // 设置绘制字符的字体
        g.setFont(mFont);
        // 用于保存系统生成的随机字符串
        String sRand = "";
        for (int i = 0; i < 6; i++)
        {
            String tmp = getRandomChar();
            sRand += tmp;
            // 获取随机颜色
            g.setColor(new Color(20 + random.nextInt(110),
                    20 + random.nextInt(110), 20 + random.nextInt(110)));
            // 在图片上绘制系统生成的随机字符
            g.drawString(tmp, 15 * i + 10, 15);
        }
        // 获取HttpSesssion对象
        HttpSession session = request.getSession(true);
        // 将随机字符串放入HttpSesssion对象中
        session.setAttribute("rand", sRand);
        g.dispose();
        // 向输出流中输出图片
        ImageIO.write(image, "JPEG", response.getOutputStream());
    }
    // 定义获取随机字符串方法
    private String getRandomChar()
    {
        // 生成一个0、1、2的随机数字
        int rand = (int) Math.round(Math.random() * 2);
        long itmp = 0;
        char ctmp = '\u0000';
        switch (rand)
        {
            // 生成大写字母
            case 1 :
                itmp = Math.round(Math.random() * 25 + 65);
                ctmp = (char) itmp;
                return String.valueOf(ctmp);
            // 生成小写字母
            case 2 :
                itmp = Math.round(Math.random() * 25 + 97);
                ctmp = (char) itmp;
                return String.valueOf(ctmp);
            // 生成数字
            default :
                itmp = Math.round(Math.random() * 9);
                return itmp + "";
        }
    }
}

package org.crazyit.auction.controller.authority;

import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/auction")
public class AuthController
{
    @RequestMapping(value = "/authLogin")
    @ResponseBody
    public String preHandle(HttpSession session) throws Exception
    {
        // 1.在请求拦截执行之前 ,判断请求是否有权限
        // 取出HttpSession里的userId属性
        Integer userId = (Integer) session.getAttribute("userId");
        // 如果HttpSession里的userId属性为null，或小于等于0
        if (userId == null || userId <= 0)
        {
            // 如果还未登录，抛出异常
            return "false";
        } else
        {
            return "true";
        }
    }
}

package org.crazyit.auction.controller.authority;

import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpSession;
import org.aspectj.lang.ProceedingJoinPoint;

public class AuthorityInterceptor
{
    // 进行权限检查的方法
    public Object authority(ProceedingJoinPoint jp) throws Throwable
    {
        System.out.println("----------------------=====--------------------");
        HttpSession sess = null;
        // 获取被拦截方法的全部参数
        Object[] args = jp.getArgs();
        // 遍历被拦截方法的全部参数
        for (int i = 0; i < args.length; i++)
        {
            // 找到HttpSession类型的参数
            if (args[i] instanceof HttpSession)
                sess = (HttpSession) args[i];
        }
        // 取出HttpSession里的userId属性
        Integer userId = (Integer) sess.getAttribute("userId");
        // 如果HttpSession里的userId属性为null，或小于等于0
        if (userId == null || userId <= 0)
        {
            // 如果还未登录，抛出异常
            Map<String, String> map = new HashMap<>();
            map.put("error", "您还没有登录，必须先登录才能使用该功能");
            return map;
        }
        return jp.proceed();
    }
}

package org.crazyit.auction.controller;

import java.util.List;
import javax.servlet.http.HttpSession;
import org.crazyit.auction.business.ItemBean;
import org.crazyit.auction.domain.Bid;
import org.crazyit.auction.domain.Item;
import org.crazyit.auction.domain.Kind;
import org.crazyit.auction.service.AuctionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
@RequestMapping("/auction")
public class AuctionController
{
    // 该前端处理类所依赖的业务逻辑组件
    @Autowired
    private AuctionService auctionService;

    // 通过赢取者获取物品的方法
    @GetMapping("/getItemByWiner")
    @ResponseBody
    public Object getItemByWiner(HttpSession sess) throws Exception
    {
        // 从HttpSession中取出userId属性
        Integer winerId = (Integer) sess.getAttribute("userId");
        List<ItemBean> itembeans = auctionService.getItemByWiner(winerId);
        return itembeans;
    }

    // 获取所有流拍物品的方法
    @GetMapping("/getFailItems")
    @ResponseBody
    public Object getFailItems() throws Exception
    {
        return auctionService.getFailItems();
    }

    // 处理用户登录的方法
    @PostMapping(value = "/loginAjax")
    @ResponseBody
    public Object validLogin(String loginUser, String loginPass, String vercode,
            HttpSession sess) throws Exception
    {
        String rand = (String) sess.getAttribute("rand");
        if (rand != null && !rand.equalsIgnoreCase(vercode))
        {
            return "-2";
        }
        int result = auctionService.validLogin(loginUser, loginPass);
        if (result > 0)
        {
            sess.setAttribute("userId", result);
            return "1";
        }
        return "-1";
    }

    // 获取用户竞价的方法
    @GetMapping("/getBidByUser")
    @ResponseBody
    public Object getBidByUser(HttpSession sess) throws Exception
    {
        // 从HttpSession中取出userId属性
        Integer userId = (Integer) sess.getAttribute("userId");
        return auctionService.getBidByUser(userId);
    }

    @GetMapping("/getItemsByOwner")
    @ResponseBody
    // 根据属主获取物品的方法
    public Object getItemsByOwner(HttpSession sess) throws Exception
    {
        // 从HttpSession中取出userId属性
        Integer userId = (Integer) sess.getAttribute("userId");
        return auctionService.getItemsByOwner(userId);
    }

    // 获取所有物品种类的方法
    @GetMapping("/getAllKind")
    @ResponseBody
    public Object getAllKind() throws Exception
    {
        return auctionService.getAllKind();
    }

    // 添加物品的方法
    @PostMapping("/addItem")
    @ResponseBody
    public Object addItem(String name, String desc, String remark,
            double initPrice, int avail, int kind, HttpSession sess)
            throws Exception
    {
        // 从HttpSession中取出userId属性
        Integer userId = (Integer) sess.getAttribute("userId");
        Item item = new Item();
        item.setItemName(name);
        item.setItemDesc(desc);
        item.setItemRemark(remark);
        item.setInitPrice(initPrice);
        int rowNum = auctionService.addItem(item, avail, kind, userId);
        return rowNum > 0 ? "success" : "error";
    }

    // 添加种类的方法
    @PostMapping("/addKind")
    @ResponseBody
    public Object addKind(String name, String desc) throws Exception
    {
        Kind kind = new Kind();
        kind.setKindName(name);
        kind.setKindDesc(desc);
        int rowNum = auctionService.addKind(kind);
        return rowNum > 0 ? "success" : "error";
    }

    // 根据种类获取物品的方法
    @PostMapping("/getItemsByKind")
    @ResponseBody
    public Object getItemsByKind(int kindId) throws Exception
    {
        return auctionService.getItemsByKind(kindId);
    }
    // 添加竞价记录的方法
    @PostMapping("/addBid")
    @ResponseBody
    public Object addBid(int itemId, double bidPrice, HttpSession sess)
            throws Exception
    {
        Integer userId = (Integer) sess.getAttribute("userId");
        Bid bid = new Bid();
        bid.setBidPrice(bidPrice);
        int id = auctionService.addBid(itemId, bid, userId);
        return id > 0 ? "success" : "error";
    }
}

/**
 * 根据时间来修改物品的状态、赢取者
 */
public void updateWiner() throws AuctionException
{
    System.out.println("-----------------" + new Date());
    try
    {
        List<Item> itemList = itemDao.findByState(1);
        for (int i = 0; i < itemList.size(); i++)
        {
            Item item = itemList.get(i);
            if (!item.getEndtime().after(new Date()))
            {
                // 根据指定物品和最高竞价来查询用户
                AuctionUser au = userDao.findByItemAndPrice(item.getId(),
                        item.getMaxPrice());
                // 如果该物品的最高竞价者不为null
                if (au != null)
                {
                    // 将该竞价者设为赢取者
                    item.setWiner(au);
                    // 修改物品的状态成为“被赢取”
                    item.setItemState(stateDao.get(State.class, 2));
                    itemDao.save(item);
                } else
                {
                    // 设置该物品的状态为“流拍”
                    item.setItemState(stateDao.get(State.class, 3));
                    itemDao.save(item);
                }
            }
        }
    } catch (Exception ex)
    {
        log.debug(ex.getMessage());
        throw new AuctionException("根据时间来修改物品的状态、赢取者出现异常,请重试");
    }
}