import nl.captcha.Captcha; //导入依赖的package包/类
private void getCaptchaImage(HttpServletRequest request, HttpServletResponse response) throws IOException
{
	String seed = request.getParameter("seed");
	if (seed == null || seed.isEmpty())
	{
		response.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE);
		return;
	}
	int seed_;
	try
	{
		seed_ = Integer.parseInt(seed);
	}
	catch (NumberFormatException i)
	{
		response.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE);
		return;
	}
	PredictableCaptchaTextProducer producer = new PredictableCaptchaTextProducer(seed_);
	final Captcha captcha = new Captcha.Builder(160, 50).addText(producer).addBackground(new GradiatedBackgroundProducer()).addNoise().gimp(new FishEyeGimpyRenderer()).addBorder().build();
	CaptchaServletUtil.writeImage(response, captcha.getImage());
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp)
		throws ServletException, IOException {
		
		List<java.awt.Font> textFonts = Arrays.asList(
		     new Font("Arial", Font.BOLD, 40), 
		     new Font("Courier", Font.BOLD, 40));
	    Captcha captcha = new Captcha.Builder(250, 90).addText()
			.addBackground(new FlatColorBackgroundProducer(Color.YELLOW))
			.gimp(new FishEyeGimpyRenderer())
			.addNoise(new CurvedLineNoiseProducer())
			.addText(new DefaultTextProducer(5), 
					 new DefaultWordRenderer(Color.RED, textFonts))
			.build();

	    CaptchaServletUtil.writeImage(resp, captcha.getImage());
	    req.getSession().setAttribute(NAME, captcha);
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Test
public void testShouldExpire() {
    Captcha captcha = new Captcha.Builder(200, 50)
        .addText()
        .build();
    
    assertFalse(StickyCaptchaServlet.shouldExpire(captcha));
    
    StickyCaptchaServlet.setTtl(0);
    assertTrue(StickyCaptchaServlet.shouldExpire(captcha));
    
    assertEquals(0, StickyCaptchaServlet.getTtl());
    StickyCaptchaServlet.setTtl(-1000);
    assertEquals(0, StickyCaptchaServlet.getTtl());
    
    StickyCaptchaServlet.setTtl(Long.MAX_VALUE);
    assertFalse(StickyCaptchaServlet.shouldExpire(captcha));
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
public boolean isValid(HttpSession session) {
  Captcha captchaValue = (Captcha) session.getAttribute(Captcha.NAME);
  session.removeAttribute(Captcha.NAME);
  if (captchaValue == null || captcha == null ||
      !captchaValue.isCorrect(captcha)) {
    errors.put("captchaError", "Text did not match image");
  }
  if (!StringUtils.hasText(getNameFirst())) {
    errors.put("nameFirstError", "Required field");
  }
  if (!StringUtils.hasText(getNameLast())) {
    errors.put("nameLastError", "Required field");
  }
  if (!StringUtils.hasText(getEmail())) {
    errors.put("emailError", "Required field");
  }
  if (!StringUtils.hasText(getDescription())) {
    errors.put("descriptionError", "Required field");
  }
  return (!hasErrors());
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Override
public void doGet(final HttpServletRequest req, final HttpServletResponse resp)
    throws ServletException,
    IOException {
    final HttpSession session = req.getSession();

    final Captcha captcha = new Captcha.Builder(_width, _height)
        .addText()
        .addBackground(new GradiatedBackgroundProducer())
        .gimp()
        .addBackground(new FlatColorBackgroundProducer(new Color(238, 238, 238)))
        .addBorder()
        .addNoise()
        .build();

    session.setAttribute(NAME, captcha);

    CaptchaServletUtil.writeImage(resp, captcha.getImage());
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@At("/captcha/update")
	@Ok("raw:image/png")
	public BufferedImage updateCaptcha(HttpSession session, @Param("w") int w, @Param("h") int h) {
		if (w * h == 0) { //长或宽为0?重置为默认长宽.
			w = 200;
			h = 60;
		}
		Captcha captcha = new Captcha.Builder(w, h)
								.addText().addBackground(new GradiatedBackgroundProducer())
//								.addNoise(new StraightLineNoiseProducer()).addBorder()
								.gimp(new FishEyeGimpyRenderer())
								.build();
		String text = captcha.getAnswer();
		session.setAttribute(Toolkit.captcha_attr, text);
		return captcha.getImage();
	}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
    //ColoredEdgesWordRenderer wordRenderer = new ColoredEdgesWordRenderer(COLORS, FONTS);
    ColoredEdgesWordRenderer wordRenderer = new ColoredEdgesWordRenderer(COLORS, FONTS, 1f);
    Captcha captcha = new Captcha.Builder(_width, _height).addText(wordRenderer)
            //.gimp()
            .addNoise()
            //.addBackground(new GradiatedBackgroundProducer())
            //.addBackground(new TransparentBackgroundProducer())
            //.addBackground(new FlatColorBackgroundProducer(Color.lightGray))
            .addBackground(new GradiatedBackgroundProducer(Color.lightGray, Color.white))
            .build();

    CaptchaServletUtil.writeImage(resp, captcha.getImage());
    req.getSession().setAttribute(NAME, captcha);
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
public static boolean validateSimpleCaptcha( HttpSession session, String answer) {
    Captcha captcha = (Captcha) session.getAttribute( Captcha.NAME );
    String code = captcha.getAnswer();
    if( code.equals(answer) ) {
        return true;
    }
    return false;
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
    ColoredEdgesWordRenderer wordRenderer = new ColoredEdgesWordRenderer(COLORS, FONTS);
    Captcha captcha = new Captcha.Builder(_width, _height).addText(wordRenderer)
            .gimp()
            .addNoise()
            .addBackground(new GradiatedBackgroundProducer())
            .build();

    CaptchaServletUtil.writeImage(resp, captcha.getImage());
    req.getSession().setAttribute(NAME, captcha);
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
private Captcha buildAndSetCaptcha(HttpSession session) {
    Captcha captcha = new Captcha.Builder(_width, _height)
        .addText()
        .gimp()
        .addBorder()
        .addNoise()
        .addBackground()
        .build();

    session.setAttribute(NAME, captcha);
    return captcha;
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
static boolean shouldExpire(Captcha captcha) {
    long ts = captcha.getTimeStamp().getTime();
    long now = new Date().getTime();
    long diff = now - ts;

    return diff >= _ttl;
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
/**
 * Gets the valid attribute of the UserBean object
 *
 * @param session the browser sessions
 * @return The valid value
 */
public boolean isValid(HttpSession session) {
  Captcha captchaValue = (Captcha) session.getAttribute(Captcha.NAME);
  session.removeAttribute(Captcha.NAME);
  if (captchaValue == null || captcha == null ||
      !captchaValue.isCorrect(captcha)) {
    errors.put("captchaError", "Text did not match image");
  }
  if (!StringUtils.hasText(nameFirst)) {
    errors.put("nameFirstError", "Required field");
  }
  if (!StringUtils.hasText(nameLast)) {
    errors.put("nameLastError", "Required field");
  }
  if (!StringUtils.hasText(companyName)) {
    errors.put("companyNameError", "Required field");
  }
  if (!StringUtils.hasText(email)) {
    errors.put("emailError", "Required field");
  }
  if (!StringUtils.hasText(phone)) {
    errors.put("phoneError", "Required field");
  }
  if (!StringUtils.hasText(addressLine1)) {
    errors.put("addressLine1Error", "Required field");
  }
  if (!StringUtils.hasText(getCity())) {
    errors.put("cityError", "Required field");
  }
  if (getState() == null || getState().equals("-1")) {
    errors.put("stateError", "Required field");
  }
  if (getCountry() == null || getCountry().equals("-1")) {
    errors.put("countryError", "Required field");
  }
  if (!agreement) {
    errors.put("agreementError", "Accepting the terms and conditions is required");
  }
  return (!hasErrors());
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
private String validateCaptcha(HttpServletRequest request,
      String returnIncompleteState) throws Exception {
      Captcha captcha = (Captcha) request.getSession().getAttribute(Captcha.NAME);
      if (captcha == null) {
          captcha = new Captcha.Builder(200, 50).addText().addBackground()
              // .addNoise()
              .gimp()
              // .addBorder()
              .build();
          request.getSession().setAttribute(Captcha.NAME, captcha);
      }

      // Do this so we can capture non-Latin chars
      request.setCharacterEncoding("UTF-8");
      String answer = HTTPUtils.cleanXSS((String) request.getParameter("answer"));
      if (answer == null || answer.length() == 0) {
          throw new NoReloadException(
              "Please enter the characters appearing in the image. ");
      }

      request.getSession().removeAttribute("reload");
      if (!captcha.isCorrect(answer)) {
          throw new InvalidCaptChaInputException(
              "WARNING: The string you entered does not match"
                  + " with what is shown in the image. Please try again.");
}
request.getSession().removeAttribute(Captcha.NAME);
      return null;
  }
 

import nl.captcha.Captcha; //导入依赖的package包/类
private String validateCaptcha(HttpServletRequest request,
      String returnIncompleteState) throws Exception {
      Captcha captcha = (Captcha) request.getSession().getAttribute(Captcha.NAME);
      if (captcha == null) {
          captcha = new Captcha.Builder(200, 50).addText().addBackground()
              // .addNoise()
              .gimp()
              // .addBorder()
              .build();
          request.getSession().setAttribute(Captcha.NAME, captcha);
      }

      // Do this so we can capture non-Latin chars
      request.setCharacterEncoding("UTF-8");
      String answer = HTTPUtils.cleanXSS((String) request.getParameter("answer"));
      if (answer == null || answer.length() == 0) {
          throw new NoReloadException(
              "Please enter the characters appearing in the image. ");
      }

      request.getSession().removeAttribute("reload");
      if (!captcha.isCorrect(answer)) {
          throw new InvalidCaptChaInputException(
              "WARNING: The string you entered does not match"
                  + " with what is shown in the image. Please try again.");
} else {
}        request.getSession().removeAttribute(Captcha.NAME);
      return null;
  }
 

import nl.captcha.Captcha; //导入依赖的package包/类
/**
 * Creates a {@link Captcha} and stores it in the session.
 *
 * @param width  the width of the image
 * @param height the height of the image
 * @return {@link BufferedImage} containing the captcha image
 */
public BufferedImage createCaptcha(int width, int height)
{
	Captcha captcha = new Captcha.Builder(width, height).addText()
														.addBackground(new GradiatedBackgroundProducer())
														.gimp()
														.addNoise()
														.addBorder()
														.build();
	session.setAttribute(Captcha.NAME, captcha);
	return captcha.getImage();
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Test
public void createCaptcha()
{
	BufferedImage captchaImg = captchaService.createCaptcha(100, 75);
	assertEquals(captchaImg.getWidth(), 100);
	assertEquals(captchaImg.getHeight(), 75);
	verify(httpSession).setAttribute(eq(Captcha.NAME), any(Captcha.class));
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Test
public void validateCaptcha() throws CaptchaException
{
	Captcha captcha = new Captcha.Builder(100, 75).build();
	when(httpSession.getAttribute(Captcha.NAME)).thenReturn(captcha);
	assertTrue(captchaService.validateCaptcha(captcha.getAnswer()));
	assertFalse(captchaService.validateCaptcha("invalid_answer"));
	assertTrue(captchaService.validateCaptcha(captcha.getAnswer()));
	verify(httpSession, times(0)).removeAttribute(Captcha.NAME);
	verify(httpSession, times(0)).setAttribute(eq(Captcha.NAME), any(Object.class));
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
public GenericBean processAction(ActionRequest request, ActionResponse response) throws Exception {
  // Determine the project container to use
  Project project = findProject(request);
  if (project == null) {
    throw new Exception("Project is null");
  }

  // Check the user's permissions
  User user = getUser(request);
  if (!user.isLoggedIn()) {
    throw new PortletException("User needs to be logged in");
  }

  // Determine the database connection to use
  Connection db = useConnection(request);

  // Track replies to previous messages
  PrivateMessage inboxPrivateMessage = null;

  // Populate all values from the request
  PrivateMessage privateMessage = (PrivateMessage) PortalUtils.getFormBean(request, PrivateMessage.class);
  if (privateMessage.getLinkModuleId() != Constants.PROJECT_MESSAGES_FILES) {
    privateMessage.setProjectId(project.getId());
    int linkProjectId = getLinkProjectId(db, privateMessage.getLinkItemId(), privateMessage.getLinkModuleId());
    if (linkProjectId == -1) {
      linkProjectId = project.getId();
    }
    privateMessage.setLinkProjectId(linkProjectId);
  } else {
    //reply to a message from the inbox, so the project id needs to be the profile of user who sent the message
    inboxPrivateMessage = new PrivateMessage(db, privateMessage.getLinkItemId());
    int profileProjectIdOfEnteredByUser = UserUtils.loadUser(inboxPrivateMessage.getEnteredBy()).getProfileProjectId();
    privateMessage.setProjectId(profileProjectIdOfEnteredByUser);
    privateMessage.setParentId(inboxPrivateMessage.getId());

    //update the last reply date of the message
    inboxPrivateMessage.setLastReplyDate(new Timestamp(System.currentTimeMillis()));
  }
  privateMessage.setEnteredBy(user.getId());

  // Validate the form
  if (!StringUtils.hasText(privateMessage.getBody())) {
    privateMessage.getErrors().put("bodyError", "Message body is required");
    return privateMessage;
  }

  // Check for captcha if this is a direct message (not a reply)
  if ("true".equals(PortalUtils.getApplicationPrefs(request).get(ApplicationPrefs.USERS_CAN_REGISTER)) &&
      privateMessage.getLinkModuleId() != Constants.PROJECT_MESSAGES_FILES &&
      privateMessage.getProjectId() > -1) {
    if (privateMessage.getProject().getProfile() && !TeamMemberList.isOnTeam(db, privateMessage.getProjectId(), user.getId())) {
      LOG.debug("Verifying the captcha...");
      String captcha = request.getParameter("captcha");
      PortletSession session = request.getPortletSession();
      Captcha captchaValue = (Captcha) session.getAttribute(Captcha.NAME);
      session.removeAttribute(Captcha.NAME);
      if (captchaValue == null || captcha == null ||
          !captchaValue.isCorrect(captcha)) {
        privateMessage.getErrors().put("captchaError", "Text did not match image");
        return privateMessage;
      }
    }
  } else {
    LOG.debug("Captcha not required");
  }

  // Insert the private message
  boolean inserted = privateMessage.insert(db);
  if (inserted) {
    // Update the message replied to
    if (inboxPrivateMessage != null && inboxPrivateMessage.getId() != -1) {
      inboxPrivateMessage.update(db);
    }
    // Send email notice
    PortalUtils.processInsertHook(request, privateMessage);
  }
  // Close the panel, everything went well
  String ctx = request.getContextPath();
  response.sendRedirect(ctx + "/close_panel_refresh.jsp");
  return null;
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
/**
 * Gets the valid attribute of the RegisterBean object
 *
 * @param session http session for captcha check
 * @return The valid value
 */
public boolean isValid(PortletSession session) {
  String captchaPassed = (String) session.getAttribute("TE-REGISTER-CAPTCHA-PASSED");
  if (!"passed".equals(captchaPassed)) {
    Captcha captchaValue = (Captcha) session.getAttribute(Captcha.NAME);
    session.removeAttribute(Captcha.NAME);
    if (captchaValue == null) {
      LOG.warn("RegisterBean-> Could not find captcha session variable for comparison to user input");
    }
    if (captchaValue == null || captcha == null ||
        !captchaValue.isCorrect(captcha)) {
      errors.put("captchaError", "Text did not match image");
    } else {
      session.setAttribute("TE-REGISTER-CAPTCHA-PASSED", "passed");
    }
  }
  if (!StringUtils.hasText(email)) {
    errors.put("emailError", "Required field");
  } else {
    if (!EmailUtils.checkEmail(email)) {
      errors.put("emailError", "Check the email address entered");
    }
  }
  if (!StringUtils.hasText(nameFirst)) {
    errors.put("nameFirstError", "Required field");
  }
  if (!StringUtils.hasText(nameLast)) {
    errors.put("nameLastError", "Required field");
  }
  if (!StringUtils.hasText(country)) {
    errors.put("countryError", "Required field");
  }
  if ("UNITED STATES".equals(country)) {
    if (!StringUtils.hasText(postalCode)) {
      errors.put("postalCodeError", "Required field");
    } else {
      LocationBean location = LocationUtils.findLocationByZipCode(postalCode);
      if (location == null) {
        errors.put("postalCodeError", "Could not locate this zip or postal code");
      }
    }
  }
  return (!hasErrors());
}
 

import nl.captcha.Captcha; //导入依赖的package包/类
@Override
protected AuthStatusResultBase doExecute(LoginAction action, ExecutionContext context)
    throws AuthenticationException,
    DispatchException {
    U user;

    LoginCaptchaInfo captchaInfo = captchaInfoProvider.get();
    _logger.info("User {} logging in", action.getUserName());
    synchronized (captchaInfo) {
        if (action.getGoogleLoginToken() == null
            && (action.getUserName() == null || action.getPassword() == null)) {
            captchaInfo.registerIncorrectAnswer();
            return new AuthStatusResultBase(captchaInfo.needCaptcha());
        }

        if (captchaInfo.needCaptcha()) {
            // incorrect request
            if (action.getCaptchaAnswer() == null
                || sessionProvider.get().getAttribute(Captcha.NAME) == null
                || !action.getCaptchaAnswer().equals(
                    ((Captcha) sessionProvider.get().getAttribute(Captcha.NAME)).getAnswer())) {
                captchaInfo.registerIncorrectAnswer();
                return new AuthStatusResultBase(captchaInfo.needCaptcha());
            }
        }

        user = findByUserNameAndPassword(
            action.getUserName(),
            action.getPassword(),
            action.isGoogleLogin(),
            action.getGoogleLoginToken(),
            action.getLoginProductType());
        if (user == null) {
            // incorrect password
            captchaInfo.registerIncorrectAnswer();
            return new AuthStatusResultBase(captchaInfo.needCaptcha());
        } else {
            captchaInfo.registerCorrectAnswer();
        }
    }

    R result = createResultBase();
    setUserToSession(user, result, action.getUserName());

    // if the login was successful and the user wants to stay signed in
    if (result.isSuccess() && action.isNeedStaySignedIn()) {
        String UUIDString = UUID.randomUUID().toString();
        result.setUserEmail(user.getUserAuthString());
        result.setUserUUID(UUIDString);
        // set the UUID for the user
        setUserStaySignedInUUID(result.getUserId(), UUIDString);
    }

    _logger.debug("Login successful: {}", authStatProvider.get());
    return result;
}