public void adiciona(Pessoa pessoa, Endereco endereco, List<NumeroTelefone> telefone) {

    if (pessoa.getNome() == null || pessoa.getNome().length() < 3) {

      validator.add(
          new ValidationMessage(
              "Nome é obrigatório e precisa ter mais de 3 letras", "pessoa.nome"));
    }

    if (telefone.get(0).getNumero() == null) {

      validator.add(
          new ValidationMessage("Pelo menos um telefone deverá ser cadastrado", "telefone.numero"));
    }

    validator.onErrorUsePageOf(PessoaController.class).formulario();

    pessoa.setEndereco(endereco);

    enderecoBanco.inserirEnderecoBanco(endereco);
    pessoaBanco.inserirPessoaBanco(pessoa);

    for (NumeroTelefone tel : telefone) {

      if (tel != null) {

        tel.setPessoa(pessoa);
        telefoneBanco.inserirTelefoneBanco(tel);
      }
    }
    result.redirectTo(this).listaContatos();
  }
Beispiel #2
0
  private void CodeValidation(Code code, boolean create) {

    List<Code> codeList;

    validator.validate(code);
    code = WithoutBlankChar(code);

    if (code.getName().isEmpty())
      validator.add(new ValidationMessage("Erro", "O campo Nome nao pode ser deixado em branco"));

    if (code.getTags().isEmpty())
      validator.add(new ValidationMessage("Erro", "O campo Tags não pode ser deixado em branco"));

    if (code.getLang().isEmpty())
      validator.add(
          new ValidationMessage("Erro", "Escolha uma linguagem para o codigo a ser cadastrado"));

    if (code.getSnippet().isEmpty())
      validator.add(
          new ValidationMessage(
              "Erro", "O campo de texto do codigo não pode ser deixado em branco"));
    if (create) {
      codeList = repository.findByName(code.getName());
      if (!codeList.isEmpty())
        validator.add(
            new ValidationMessage(
                "Erro", "Nao pode haver dois codigos com o mesmo nome, insira um nome diferente"));
    }
  }
  @Post
  @Path("/reports/{errorEntry.id}/comments")
  public void addComment(ErrorEntry errorEntry, String newComment) {
    newComment = sanitizer.sanitize(newComment, true);
    ErrorEntry errorEntryFromDB = errorEntryDAO.retrieve(new Long(errorEntry.getId()));

    LOG.debug("errorEntry: " + errorEntryFromDB);
    LOG.debug("newComment: " + newComment);
    if (newComment.trim().isEmpty()) {
      validator.add(
          new ValidationMessage(
              ExceptionMessages.COMMENT_SHOULD_NOT_BE_EMPTY, ExceptionMessages.ERROR));
      validator
          .onErrorUse(Results.logic())
          .redirectTo(ErrorReportController.class)
          .details(errorEntryFromDB);
    } else if (newComment.trim().length() > COMMENT_MAX_SIZE) {
      validator.add(
          new ValidationMessage(
              ExceptionMessages.COMMENT_SHOULD_NOT_EXCEED_CHAR, ExceptionMessages.ERROR));
      validator
          .onErrorUse(Results.logic())
          .redirectTo(ErrorReportController.class)
          .details(errorEntryFromDB);
    } else {
      errorEntryLogic.addCommentToErrorEntry(
          errorEntryFromDB.getId(), loggedUser.getUser().getId(), newComment);
    }

    result.include("gaEventCommentAdded", true);

    result.redirectTo(ErrorReportController.class).details(errorEntryFromDB);
  }
  @Get
  @Path("/reports/{errorEntry.id}/edit")
  @LoggedIn
  public void editDetails(ErrorEntry errorEntry) {
    if (errorEntry == null) {
      result.redirectTo(getClass()).list();
      return;
    }

    ErrorEntry errorEntryFromDB = errorEntryDAO.retrieve(new Long(errorEntry.getId()));
    LOG.debug("Details for: " + errorEntryFromDB);

    if (errorEntryFromDB == null) {
      validator.add(
          new ValidationMessage(ExceptionMessages.PAGE_NOT_FOUND, ExceptionMessages.ERROR));
      validator.onErrorUse(Results.logic()).redirectTo(ErrorReportController.class).list();
    } else if (!loggedUser.isLogged() || !loggedUser.getUser().getRole().getCanEditErrorReport()) {
      validator.add(
          new ValidationMessage(ExceptionMessages.USER_UNAUTHORIZED, ExceptionMessages.ERROR));
      validator
          .onErrorUse(Results.logic())
          .redirectTo(ErrorReportController.class)
          .details(errorEntryFromDB);
    } else {
      List<ProcessResult> procRes = cogrooFacade.processText(errorEntryFromDB.getText());

      boolean hasError = false;
      for (ProcessResult processResult : procRes) {
        if (processResult.getMistakes().size() > 0) {
          hasError = true;
          break;
        }
      }

      result
          .include("errorEntry", errorEntryFromDB)
          .include("hasError", hasError)
          .include("processResultList", procRes)
          .include(
              "singleGrammarErrorList",
              cogrooFacade.asSingleGrammarErrorList(errorEntryFromDB.getText(), procRes))
          .include("omissionCategoriesList", this.errorEntryLogic.getErrorCategoriesForUser());
    }
  }
 @Post("/login")
 public void login(Usuario usuario) {
   Usuario carrega = dao.carrega(usuario);
   if (carrega == null) {
     validator.add(new ValidationMessage("Login e/ou senha inválidos", "usuario.login"));
   }
   validator.onErrorUsePageOf(UsuariosController.class).loginForm();
   usuarioWeb.login(carrega);
   result.redirectTo(ProdutosController.class).lista();
 }
  @Post("/login")
  public void login(Administrador usuario) {
    Administrador carregado = dao.carregar(usuario);
    if (carregado == null) {
      validator.add(new ValidationMessage("Login ou Senha Incorretos", "usuario"));
    }
    validator.onErrorUsePageOf(this).loginForm();
    userinfo.login(carregado);

    result.redirectTo(UsertwitterController.class).lista();
  }
  @Post("/usuarios")
  public void adiciona(Usuario usuario) {
    if (dao.existeUsuario(usuario)) {
      validator.add(new ValidationMessage("Login já existe", "usuario.login"));
    }
    validator.onErrorUsePageOf(UsuariosController.class).novo();

    dao.adiciona(usuario);

    result.redirectTo(ProdutosController.class).lista();
  }
  @Put
  @Path("/reports/{reportId}")
  @LoggedIn
  public void updateErrorReport(
      Long reportId,
      String type,
      String badintIndex,
      String badintType,
      List<String> badintStart,
      List<String> badintEnd,
      List<String> badintRule,
      String omissionCategory,
      String omissionCustom,
      String omissionReplaceBy,
      String omissionStart,
      String omissionEnd) {

    LOG.debug(
        "reportId: "
            + reportId
            + "\n"
            + "type: "
            + type
            + "\n"
            + "badintIndex: "
            + badintIndex
            + "\n"
            + "badintType: "
            + badintType
            + "\n"
            + "badintStart: "
            + badintStart
            + "\n"
            + "badintEnd: "
            + badintEnd
            + "\n"
            + "badintRule: "
            + badintRule
            + "\n"
            + "omissionCategory: "
            + omissionCategory
            + "\n"
            + "omissionCustom: "
            + omissionCustom
            + "\n"
            + "omissionReplaceBy: "
            + omissionReplaceBy
            + "\n"
            + "omissionStart: "
            + omissionStart
            + "\n"
            + "omissionEnd: "
            + omissionEnd);

    ErrorEntry errorEntryFromDB = this.errorEntryDAO.retrieve(reportId);
    ErrorEntry originalErrorEntry = null;
    try {
      originalErrorEntry = (ErrorEntry) errorEntryFromDB.clone();

    } catch (CloneNotSupportedException e) {
      LOG.error("Error cloning ErrorEntry object: ", e);
    }
    if (type == null) {
      if (errorEntryFromDB.getBadIntervention() != null) {
        type = "BADINT";
      } else {
        type = "OMISSION";
      }
    }
    if (type.equals("BADINT")) {
      GrammarCheckerBadIntervention newBadIntervention = null;
      if (errorEntryFromDB.getBadIntervention() == null) {
        newBadIntervention = new GrammarCheckerBadIntervention();
        errorEntryFromDB.setBadIntervention(newBadIntervention);
      } else {
        newBadIntervention = errorEntryFromDB.getBadIntervention();
      }

      newBadIntervention.setClassification(
          Enum.valueOf(BadInterventionClassification.class, badintType));
      newBadIntervention.setErrorEntry(errorEntryFromDB);
      newBadIntervention.setRule(badintRule.get(Integer.valueOf(badintIndex) - 1));

      errorEntryFromDB.setSpanStart(
          Integer.valueOf(badintStart.get(Integer.valueOf(badintIndex) - 1)));
      errorEntryFromDB.setSpanEnd(Integer.valueOf(badintEnd.get(Integer.valueOf(badintIndex) - 1)));

      this.errorEntryLogic.updateBadIntervention(errorEntryFromDB, originalErrorEntry);
    } else {
      int start = -1;
      int end = -1;

      if (omissionStart != null && omissionEnd != null) {
        start = Integer.parseInt(omissionStart);
        end = Integer.parseInt(omissionEnd);
      }

      GrammarCheckerOmission o = null;
      if (errorEntryFromDB.getOmission() == null) {
        o = new GrammarCheckerOmission();
        errorEntryFromDB.setOmission(o);
      } else {
        o = errorEntryFromDB.getOmission();
      }

      o.setCategory(omissionCategory);
      if (omissionCategory.equals(ErrorEntryLogic.CUSTOM)) {
        o.setCustomCategory(sanitizer.sanitize(omissionCustom, false));
      } else {
        o.setCustomCategory(null);
      }
      o.setErrorEntry(errorEntryFromDB);
      o.setReplaceBy(sanitizer.sanitize(omissionReplaceBy, false));

      errorEntryFromDB.setSpanStart(start);
      errorEntryFromDB.setSpanEnd(end);

      if (!(end > 0 && end > start)) {
        validator.add(
            new ValidationMessage(
                ExceptionMessages.ERROR_REPORT_OMISSION_INVALID_SELECTION,
                ExceptionMessages.ERROR));
      }
      if (omissionCategory.equals("custom")
          && (omissionCustom == null || omissionCustom.length() == 0)) {
        validator.add(
            new ValidationMessage(
                ExceptionMessages.ERROR_REPORT_OMISSION_MISSING_CUSTOM_CATEGORY,
                ExceptionMessages.ERROR));
      }
      if ((omissionReplaceBy == null || omissionReplaceBy.length() == 0)) {
        validator.add(
            new ValidationMessage(
                ExceptionMessages.ERROR_REPORT_OMISSION_MISSING_REPLACE, ExceptionMessages.ERROR));
      }
      if (validator.hasErrors()) {
        validator
            .onErrorUse(Results.logic())
            .redirectTo(ErrorReportController.class)
            .editDetails(errorEntryFromDB);
        return;
      }
      this.errorEntryLogic.updateOmission(errorEntryFromDB, originalErrorEntry);
    }

    result.include("gaEventErrorChanged", true);
    result.redirectTo(getClass()).details(errorEntryFromDB);
  }