org.javalite.activejdbc.Model Java Examples

public void validate(Model m) {
    Object value = m.get(this.attribute);

    if(allowBlank && (null == value || "".equals(value))) {
        return;
    }

    if(null == value) {
        m.addValidator(this, this.attribute);
        return;
    }

    if(!(value instanceof String)) {
        throw new IllegalArgumentException("Attribute must be a String");
    } else {
        if(!this.lengthOption.validate((String)((String)m.get(this.attribute)))) {
            //somewhat confusingly this adds an error for a validator.
            m.addValidator(this, this.attribute);
        }

    }
}
 

public static <T extends Model> Map<Long, Integer> convertRankToMap(List<T> drs, String idColumnName) {

        // Convert those votes to a map from id to rank
        Map<Long, Integer> rankMap = new HashMap<>();
        for (T dr : drs) {
            rankMap.put(dr.getLong(idColumnName), dr.getInteger("rank"));
        }

        try {
            log.debug(Tools.JACKSON.writeValueAsString(rankMap));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        return rankMap;
    }
 

public static <T extends Model> Map<Long,List<T>> convertRowsToMap(List<T> tags, String idColumnName) {

        Map<Long,List<T>> map = new HashMap<>();

        for (T dtv : tags) {
            Long id = dtv.getLong(idColumnName);
            List<T> arr = map.get(id);

            if (arr == null) {
                arr = new ArrayList<>();
                map.put(id, arr);
            }

            arr.add(dtv);
        }

        return map;
    }
 

public static Communities create(List<? extends Model> communities,
                                 List<Tables.CommunityTagView> communityTags,
                                 List<Tables.CommunityUserView> communityUsers,
                                 List<Tables.CommunityRank> communityRanks,
                                 Long count) {

    // Build maps keyed by community_id of the votes, tags, and users
    Map<Long, Integer> votes = (communityRanks != null) ?
            Transformations.convertRankToMap(communityRanks, "community_id") : null;

    Map<Long, List<Tables.CommunityTagView>> tagMap = (communityTags != null) ?
            Transformations.convertRowsToMap(communityTags, "community_id") : null;

    Map<Long, List<Tables.CommunityUserView>> userMap = (communityUsers != null) ?
            Transformations.convertRowsToMap(communityUsers, "community_id") : null;

    // Convert to a list of community objects
    List<Community> cos = new ArrayList<>();

    for (Model view : communities) {
        Long id = view.getLongId();
        Integer vote = (votes != null && votes.get(id) != null) ? votes.get(id) : null;
        List<Tables.CommunityTagView> tags = (tagMap != null && tagMap.get(id) != null) ? tagMap.get(id) : null;
        List<Tables.CommunityUserView> users = (userMap != null && userMap.get(id) != null) ? userMap.get(id) : null;
        Community c = Community.create(view, tags, users, vote);
        cos.add(c);
    }

    return new Communities(cos, count);
}
 

@Test
public void shouldRegisterCustomValidator() {

    class FutureBirthValidator extends ValidatorAdapter {
        FutureBirthValidator(){
            setMessage("invalid.dob.message");
        }
        @Override
        public void validate(Model m) {
            Date dob = m.getDate("dob");
            Date now = new java.sql.Date(System.currentTimeMillis());
            if(dob.after(now)){
                m.addValidator(this, "invalid.dob");//add validator to errors with a key
            }
        }
    }

    FutureBirthValidator validator = new FutureBirthValidator();

    Person.addValidator(validator);

    Person p = new Person();

    GregorianCalendar future = new GregorianCalendar();
    future.set(Calendar.YEAR, 3000);//will people still be using Java then... or computers? :)

    p.set("dob", new Date(future.getTimeInMillis()));
    p.validate();
    a(p.errors().size()).shouldBeEqual(3);

    a(p.errors().get("invalid.dob")).shouldBeEqual("date of birth cannot be in future");

    //this is so that other tests succeed
    Person.removeValidator(validator);
}
 

@Override
public void validate(Model m) {

    Object val = m.get(attributeName);
    if (!(val instanceof java.util.Date) && !blank(val)) {
        try {
            long time = df.parse(val.toString()).getTime();
            java.sql.Date d = new java.sql.Date(time);
            m.set(attributeName, d);
        } catch (ParseException e) {
            m.addValidator(this, attributeName);
        }
    }
}
 

@Override
public void validate(Model model) {
    MetaModel metaModel = metaModelOf(model.getClass());
    if (new DB(metaModel.getDbName()).count(metaModel.getTableName(), attribute + " = ?", model.get(attribute)) > 0) {
        model.addValidator(this, attribute);
    }
}
 

private void validateIntegerOnly(Object value, Model m){
    try{
        Integer.valueOf(value.toString());
    } catch(NumberFormatException e) {
        m.addValidator(this, attribute);
    }
}
 

private boolean present(Object value, Model m){

        if(allowNull){
            return true;
        }

        if(value == null){
            setMessage("value is missing");
            m.addValidator(this, attribute);
            return false;
        }else{
            return true;
        }
    }
 

@Override
public void validate(Model m) {
    Object val = m.get(attributeName);
    if (!(val instanceof Timestamp) && !blank(val)) {
        try {
            long time = df.parse(val.toString()).getTime();
            Timestamp t = new Timestamp(time);
            m.set(attributeName, t);
        } catch(ParseException e) {
            m.addValidator(this, attributeName);
        }
    }
}
 

@Override
public void validate(Model m) {
    if(m.get(attribute) == null){
        m.addValidator(this, attribute);
        return;
    }
    Object value = m.get(attribute);
    if (!(value instanceof String)) {
        throw new IllegalArgumentException("attribute " + attribute + " is not String");
    }
    Matcher matcher = pattern.matcher((String) value);
    if(!matcher.matches()){
       m.addValidator(this, attribute);
    }
}
 

protected void create() {
    Employee employee = new Employee("Hugo","C","M","BN");
    employee.saveIt();
    employee.add(new Role("Java Developer","BN"));
    LazyList<Model> all = Employee.findAll();
    System.out.println(all.size());
}
 

private static LazyList<Model> fetchComments(SessionScope scope) {
  if (scope.getTopParentId() != null) {
    return CommentBreadcrumbsView.where("discussion_id = ? and parent_id = ?", scope.getDiscussionId(),
        scope.getTopParentId());
  } else {
    return CommentThreadedView.where("discussion_id = ?", scope.getDiscussionId());
  }
}
 

public void messageReply(Session session, JsonNode data) {

    SessionScope ss = SessionScope.findBySession(sessionScopes, session);

    // Get the object
    ReplyData replyData = new ReplyData(data.get("parentId").asLong(), data.get("reply").asText());

    // Collect only works on refetch
    LazyList<Model> comments = fetchComments(ss);

    log.debug(ss.toString());

    // Necessary for comment tree
    Array arr = (Array) comments.collect("breadcrumbs", "id", replyData.getParentId()).get(0);
    List<Long> parentBreadCrumbs = Tools.convertArrayToList(arr);

    com.chat.db.Tables.Comment newComment = Actions.createComment(ss.getUserObj().getId(), ss.getDiscussionId(),
        parentBreadCrumbs, replyData.getReply());

    // Fetch the comment threaded view
    CommentThreadedView ctv = CommentThreadedView.findFirst("id = ?", newComment.getLongId());

    // Convert to a proper commentObj
    Comment co = Comment.create(ctv, null);

    Set<SessionScope> filteredScopes = SessionScope.constructFilteredMessageScopesFromSessionRequest(sessionScopes,
        session, co.getBreadcrumbs());

    broadcastMessage(filteredScopes, messageWrapper(MessageType.Reply, co.json()));

    // TODO find a way to do this without having to query every time?
    com.chat.types.discussion.Discussion do_ = Actions.saveFavoriteDiscussion(ss.getUserObj().getId(),
        ss.getDiscussionId());
    if (do_ != null)
      sendMessage(session, messageWrapper(MessageType.SaveFavoriteDiscussion, do_.json()));
  }
 

@OnWebSocketConnect
public void onConnect(Session session) {

  try {
    Tools.dbInit();

    // Get or create the session scope
    SessionScope ss = setupSessionScope(session);

    sendRecurringPings(session);

    // Send them their user info
    // TODO
    // session.getRemote().sendString(ss.getUserObj().json("user"));

    LazyList<Model> comments = fetchComments(ss);

    // send the comments
    sendMessage(session,
        messageWrapper(MessageType.Comments, Comments
            .create(comments, fetchVotesMap(ss.getUserObj().getId()), topLimit, maxDepth, ss.getCommentComparator())
            .json()));

    // send the updated users to everyone in the right scope(just discussion)
    Set<SessionScope> filteredScopes = SessionScope.constructFilteredUserScopesFromSessionRequest(sessionScopes,
        session);
    broadcastMessage(filteredScopes,
        messageWrapper(MessageType.Users, Users.create(SessionScope.getUserObjects(filteredScopes)).json()));

    log.debug("session scope " + ss + " joined");

  } catch (Exception e) {
    e.printStackTrace();
  } finally {
    Tools.dbClose();
  }

}
 

public static Comments create(
        LazyList<? extends Model> comments,
        Map<Long, Integer> votes,
        Long topLimit, Long maxDepth, Comparator<Comment> comparator) {

    List<Comment> commentObjs = Transformations.convertCommentsToEmbeddedObjects(
            comments, votes, topLimit, maxDepth, comparator);

    return new Comments(commentObjs);
}
 

public static Comments replies(LazyList<? extends Model> comments) {
    Set<Comment> commentObjs = new LinkedHashSet<>();
    for (Model c : comments) {
        commentObjs.add(Comment.create(c, null));
    }

    // Convert to a list
    List<Comment> list = new ArrayList<>(commentObjs);

    return new Comments(list);

}
 

public static Comment create(Model cv, Integer vote) {

        User user = User.create(cv.getLong("user_id"), cv.getString("user_name"));
        User modifiedByUser = User.create(cv.getLong("modified_by_user_id"), cv.getString("modified_by_user_name"));

        return new Comment(cv.getLong("id"), user, modifiedByUser, cv.getLong("discussion_id"),
                cv.getLong("discussion_owner_id"), cv.getString("text_"), cv.getLong("path_length"),
                cv.getLong("parent_id"), cv.getLong("parent_user_id"), cv.getString("breadcrumbs"),
                cv.getLong("num_of_parents"), cv.getLong("num_of_children"), cv.getInteger("avg_rank"), vote,
                cv.getInteger("number_of_votes"), cv.getBoolean("deleted"), cv.getBoolean("read"),
                cv.getBoolean("stickied"), cv.getTimestamp("created"), cv.getTimestamp("modified"));
    }
 

@Override
public void beforeValidation(Model m) {
    beforeValidationCalled = true;
    if(Util.blank(m.get("category"))){
        m.set("category", "none");
    }
}
 

public void messageNextPage(Session session, JsonNode data) {
  SessionScope ss = SessionScope.findBySession(sessionScopes, session);

  // Get the object
  NextPageData nextPageData = new NextPageData(data.get("topLimit").asLong(), data.get("maxDepth").asLong());

  // Refetch the comments based on the new limit
  LazyList<Model> comments = fetchComments(ss);

  // send the comments from up to the new limit to them
  sendMessage(session,
      messageWrapper(MessageType.Comments, Comments.create(comments, fetchVotesMap(ss.getUserObj().getId()),
          nextPageData.getTopLimit(), nextPageData.getMaxDepth(), ss.getCommentComparator()).json()));

}
 

public static List<Comment> convertCommentsToEmbeddedObjects(
        List<? extends Model> cvs,
        Map<Long, Integer> votes,
        Long topLimit, Long maxDepth, Comparator<Comment> comparator) {

    Map<Long, Comment> commentObjMap = convertCommentThreadedViewToMap(cvs, votes);

    List<Comment> cos = convertCommentsMapToEmbeddedObjects(commentObjMap, topLimit, maxDepth, comparator);

    return cos;
}
 

protected void checkBeforeDelete(Model m){
    beforeDeleteCalled = true;
    if(m.isFrozen())
        throw new TestException("new model must not be frozen before delete()");

}
 

public BelongsToAssociation(Class<? extends Model> source, Class<? extends Model> target, String fkName) {
    super(source, target);
    this.fkName = fkName;
}
 

public BelongsToPolymorphicAssociation(Class<? extends Model> sourceModelClass, Class<? extends Model> targetModelClass, String typeLabel, String parentClassName) {
    super(sourceModelClass, targetModelClass);
    this.typeLabel = typeLabel;
    this.parentClassName = parentClassName;
}
 

protected void checkAfterValidation(Model m){
    afterValidationCalled = true;
    if(m.errors().size() == 0)
            throw new TestException("model after validation must have errors");
}
 

protected void checkBeforeSave(Model m){
    beforeSaveCalled = true;
    if(m.getId() != null)
        throw new TestException("new model must not have an ID before save()");
}
 

protected void checkBeforeCreate(Model m){
    beforeCreateCalled = true;
    if(m.getId() != null)
        throw new TestException("new model must not have an ID before insert()");
}
 

protected void checkAfterCreate(Model m){
       afterCreateCalled = true;
       if(m.getId() == null)
           throw new TestException("new model must have an ID after insert()");
}
 

protected void checkAfterSave(Model m){
    afterSaveCalled = true;
    if(m.getId() == null)
        throw new TestException("new model must have an ID after save()");
}
 

@Override
public void beforeDelete(Model m) {
    beforeDeleteCalled = true;
}