/** * Yona, 21st Century Project Hosting SW * <p> * Copyright Yona & Yobi Authors & NAVER Corp. & NAVER LABS Corp. * https://yona.io **/ package controllers.api; import com.avaje.ebean.ExpressionList; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; import controllers.AbstractPostingApp; import controllers.UserApp; import controllers.annotation.AnonymousCheck; import controllers.annotation.IsAllowed; import controllers.annotation.IsCreatable; import controllers.routes; import models.*; import models.enumeration.*; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.lang3.StringUtils; import play.api.mvc.Codec; import play.db.ebean.Transactional; import play.i18n.Messages; import play.libs.F; import play.libs.Json; import play.libs.ws.WS; import play.libs.ws.WSRequestHolder; import play.libs.ws.WSResponse; import play.mvc.Http; import play.mvc.Result; import utils.*; import javax.annotation.Nonnull; import java.io.IOException; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; import java.util.function.Supplier; import java.util.stream.Collectors; import static controllers.UserApp.MAX_FETCH_USERS; import static controllers.UserApp.currentUser; import static controllers.api.UserApi.*; import static play.libs.Json.toJson; public class IssueApi extends AbstractPostingApp { public static String TRANSLATION_API = play.Configuration.root().getString("application.extras.translation.api", ""); public static String TRANSLATION_HEADER_KEY = play.Configuration.root().getString("application.extras.translation.headerKey", ""); public static String TRANSLATION_HEADER_VALUE = play.Configuration.root().getString("application.extras.translation.headerValue", ""); public static final int TRANSLATE_TEXT_LENGTH_LIMIT = 4500; public static final String NEWLINE = "\r\n"; @Transactional public static Result imports(String owner, String projectName) { Project project = Project.findByOwnerAndProjectName(owner, projectName); try { String postNumber = request().getQueryString("postNumber"); Long number = Optional.ofNullable(postNumber) .map(Long::parseLong) .orElseThrow(NumberFormatException::new); Posting posting = Posting.findByNumber(project, number); Issue issue = Issue.from(posting); issue.save(); Map<String, String> postingCommentIdToIssueCommentIdMap = copyCommentsToIssue(posting.comments, issue); copyAttachmentsToIssue(posting, issue); copyAttachmentsToIssueComments(postingCommentIdToIssueCommentIdMap); removePosting(posting); ObjectNode json = Json.newObject(); json.put("number", issue.getNumber()); return ok(json); } catch (NumberFormatException numberFormatException) { String errorMessage = String.format("IssueApi.imports() error with NumberFormatException. owner: %s, projectName: %s - ", owner, projectName); play.Logger.error(errorMessage, numberFormatException); } return badRequest(); } private static void copyAttachmentsToIssue(Posting from, Issue to) { List<Attachment> attachments = Attachment.findByContainer(ResourceType.BOARD_POST, String.valueOf(from.id)); attachments.forEach(attachment -> { Attachment newAttachment = Attachment.copyAs(attachment); newAttachment.containerId = String.valueOf(to.id); newAttachment.containerType = ResourceType.ISSUE_POST; newAttachment.save(); attachment.delete(); }); } private static void copyAttachmentsToIssueComments(Map<String, String> postingCommentIdToIssueCommentIdMap) { List<Attachment> attachments = postingCommentIdToIssueCommentIdMap.keySet().stream() .flatMap(postingCommentId -> Attachment.findByContainer(ResourceType.NONISSUE_COMMENT, String.valueOf(postingCommentId)).stream()) .collect(Collectors.toList()); attachments.forEach(attachment -> { String containerId = postingCommentIdToIssueCommentIdMap.get(attachment.containerId); Attachment newAttachment = Attachment.copyAs(attachment); newAttachment.containerId = containerId; newAttachment.containerType = ResourceType.ISSUE_COMMENT; newAttachment.save(); attachment.delete(); }); } private static void removePosting(Posting posting) { posting.deleteOnly(); } private static Map<String, String> copyCommentsToIssue(Collection<PostingComment> postingComments, Issue issue) { // 최상위 댓글 List<PostingComment> topLevelPostingComments = postingComments.stream() .filter(postingComment -> Objects.isNull(postingComment.getParentComment())) .collect(Collectors.toList()); // 대댓글 List<PostingComment> secondLevelPostingComments = postingComments.stream() .filter(postingComment -> Objects.nonNull(postingComment.getParentComment())) .collect(Collectors.toList()); // 최상위 댓글의 postingCommentId와 새로 생성될 issueCommentId의 mapping // XXX: id는 Long 타입이지만, parentId는 String 타입이다. Map<String, String> postingCommentIdToIssueCommentIdMap = new HashMap<>(); // 최상위 댓글을 issueComment에 생성하고, 이때 발급된 issueCommentId를 보관한다. List<IssueComment> issueComments = new ArrayList<>(); topLevelPostingComments.forEach(topLevelPostingComment -> { IssueComment issueComment = IssueComment.from(topLevelPostingComment, issue); issueComment.save(); postingCommentIdToIssueCommentIdMap.put(String.valueOf(topLevelPostingComment.id), String.valueOf(issueComment.id)); issueComments.add(issueComment); }); // 대댓글을 issueComment에 생성하고, 이때 새로 발급된 issueCommentId를 parentCommentId에 넣어준다. secondLevelPostingComments.forEach(secondLevelPostingComment -> { String parentCommentId = postingCommentIdToIssueCommentIdMap.get(String.valueOf(secondLevelPostingComment.getParentComment().id)); IssueComment issueComment = IssueComment.from(secondLevelPostingComment, issue); issueComment.parentCommentId = parentCommentId; issueComment.setParentComment(IssueComment.find.byId(Long.valueOf(parentCommentId))); issueComment.save(); issueComments.add(issueComment); }); return postingCommentIdToIssueCommentIdMap; } @Transactional public static Result updateIssueLabel(String owner, String projectName, Long number) { JsonNode json = request().body().asJson(); if(json == null) { return badRequest("Expecting Json data"); } Project project = Project.findByOwnerAndProjectName(owner, projectName); Issue issue = Issue.findByNumber(project, number); Set<IssueLabel> labels = new HashSet<>(); for(JsonNode node: json){ Long labelId = Long.parseLong(node.asText()); labels.add(IssueLabel.finder.byId(labelId)); } issue.labels = labels; issue.save(); ObjectNode result = Json.newObject(); result.put("id", project.owner); result.put("labels", toJson(issue.labels.size())); return ok(result); } @Transactional public static Result getIssue(String owner, String projectName, Long number) { ObjectNode result = Json.newObject(); if (!isAuthored(request())) { return unauthorized(result.put("message", "unauthorized request")); } Project project = Project.findByOwnerAndProjectName(owner, projectName); if (project == null) { return badRequest(result.put("message", "no project by request")); } Issue issue = Issue.findByNumber(project, number); if (issue == null) { return badRequest(result.put("message", "no issue by request")); } ObjectNode json = ProjectApi.getResult(issue); return ok(Json.newObject().set("result", toJson(addIssueEvents(issue, json)))); } private static ObjectNode addIssueEvents(Issue issue, ObjectNode json) { if (issue.events.size() > 0) { json.put("events", getIssueEvents(issue)); } return json; } private static ArrayNode getIssueEvents(Issue issue) { ArrayNode array = Json.newObject().arrayNode(); if (issue.events.size() > 0) { for (IssueEvent event: issue.events) { ObjectNode result = Json.newObject(); User sender = User.findByLoginId(event.senderLoginId); result.put("id", event.id); result.put("createdDate", JodaDateUtil.getDateString(event.created, JodaDateUtil.ISO_FORMAT)); result.put("eventType", event.eventType.toString()); result.put("eventDescription", event.eventType.getDescr()); result.put("oldValue", event.oldValue); result.put("newValue", event.newValue); result.put("actor", getActorJson(sender)); array.add(result); } } return array; } private static JsonNode getActorJson(User user) { ObjectNode result = Json.newObject(); result.put("name", user.getPureNameOnly()); result.put("loginId", user.loginId); result.put("englishName", user.englishName); return result; } @Transactional @IsCreatable(ResourceType.ISSUE_POST) public static Result newIssues(String owner, String projectName) { ObjectNode result = Json.newObject(); JsonNode json = request().body().asJson(); if (json == null) { return badRequest(result.put("message", "Expecting Json data")); } JsonNode issuesNode = json.findValue("issues"); if (issuesNode == null || !issuesNode.isArray()) { return badRequest(result.put("message", "No issues key exists or value wasn't array!")); } boolean sendNotification = json.findValue("sendNotification") != null && json.findValue("sendNotification").asBoolean(); Project project = Project.findByOwnerAndProjectName(owner, projectName); List<JsonNode> createdIssues = new ArrayList<>(); for (JsonNode issueNode : issuesNode) { createdIssues.add(createIssuesNode(issueNode, project, sendNotification)); } return created(toJson(createdIssues)); } @Transactional public static Result updateIssue(String owner, String projectName, Long number) { ObjectNode result = Json.newObject(); if (!isAuthored(request())) { return unauthorized(result.put("message", "unauthorized request")); } JsonNode json = request().body().asJson(); if(json == null) { return badRequest(result.put("message", "Expecting Json data")); } User user = getAuthorizedUser(getAuthorizationToken(request())); Project project = Project.findByOwnerAndProjectName(owner, projectName); final Issue issue = Issue.findByNumber(project, number); return updateIssueNode(json, project, issue, user); } @Transactional public static Result updateIssueState(String owner, String projectName, Long number) { ObjectNode result = Json.newObject(); if (!isAuthored(request())) { return unauthorized(result.put("message", "unauthorized request")); } JsonNode json = request().body().asJson(); if(json == null) { return badRequest(result.put("message", "Expecting Json data")); } User user = getAuthorizedUser(getAuthorizationToken(request())); Project project = Project.findByOwnerAndProjectName(owner, projectName); final Issue issue = Issue.findByNumber(project, number); State newIssueState = findIssueState(json); if (!newIssueState.equals(issue.state)) { addNewIssueEvent(issue, user, EventType.ISSUE_STATE_CHANGED, issue.state.state(), newIssueState.state()); } issue.state = newIssueState; issue.save(); result = ProjectApi.getResult(issue); return ok(Json.newObject().set("result", toJson(addIssueEvents(issue, result)))); } @Transactional public static Result updateIssueContent(String owner, String projectName, Long number) { User user = UserApp.currentUser(); if (user.isAnonymous()) { return unauthorized(Json.newObject().put("message", "unauthorized request")); } JsonNode json = request().body().asJson(); if(json == null) { return badRequest(Json.newObject().put("message", "Expecting Json data")); } Project project = Project.findByOwnerAndProjectName(owner, projectName); final Issue issue = Issue.findByNumber(project, number); if (!AccessControl.isAllowed(user, issue.asResource(), Operation.UPDATE)) { return forbidden(Json.newObject().put("message", "Forbidden request")); } // TODO: It is TOO bulky comparing whole text String content = json.findValue("content").asText(); String original = json.findValue("original").asText(); if (isModifiedByOthers(issue.body, original)) { return conflicted(issue.body); } issue.body = content; issue.update(); return ok(ProjectApi.getResult(issue)); } private static Result updateIssueNode(JsonNode json, Project project, Issue issue, User user) { issue.title = json.findValue("title").asText(); issue.body = json.findValue("body").asText(); issue.milestone = findMilestone(json.findValue("milestoneTitle"), project); issue.updatedDate = JodaDateUtil.now(); // TODO: Separate function for adding possible events String state = json.findValue("state").asText(); if (!state.equals(issue.state.toString())) { addNewIssueEvent(issue, user, EventType.ISSUE_STATE_CHANGED, issue.state.state(), State.valueOf(state).state()); } issue.state = findIssueState(json); JsonNode assigneeNode = json.findValue("assignees").get(0); String oldAssignee = issue.assignee != null ? issue.assignee.user.loginId : ""; String newAssignee = assigneeNode != null ? assigneeNode.findValue("loginId").asText() : ""; if (!oldAssignee.equals(newAssignee)) { oldAssignee = oldAssignee.length() == 0 ? null : oldAssignee; newAssignee = newAssignee.length() == 0 ? null : newAssignee; addNewIssueEvent(issue, user, EventType.ISSUE_ASSIGNEE_CHANGED, oldAssignee, newAssignee); } issue.assignee = findAssginee(json.findValue("assignees"), project); issue.save(); ObjectNode issueNode = ProjectApi.getResult(issue); return ok(Json.newObject().set("result", toJson(addIssueEvents(issue, issueNode)))); } private static void addNewIssueEvent(Issue issue, User user, EventType eventType, String oldValue, String newValue) { IssueEvent issueEvent = new IssueEvent(); issueEvent.issue = issue; issueEvent.senderLoginId = user.loginId; issueEvent.oldValue = oldValue; issueEvent.newValue = newValue; issueEvent.created = new Date(); issueEvent.eventType = eventType; issueEvent.save(); } private static JsonNode createIssuesNode(JsonNode json, Project project, boolean sendNotification) { JsonNode files = json.findValue("temporaryUploadFiles"); final Issue issue = new Issue(); issue.setAuthor(findAuthor(json.findValue("author"))); issue.project = project; issue.title = json.findValue("title").asText(); issue.body = json.findValue("body").asText(); issue.state = findIssueState(json); issue.createdDate = parseDateString(json.findValue("createdAt")); issue.updatedDate = parseDateString(json.findValue("updatedAt")); issue.assignee = findAssginee(json.findValue("assignees"), project); issue.milestone = findMilestone(json.findValue("milestoneTitle"), project); issue.dueDate = findDueDate(json.findValue("dueDate")); updateLabels(json, issue, project); issue.numOfComments = 0; if(json.findValue("number") != null && json.findValue("number").asLong() > 0){ issue.saveWithNumber(json.findValue("number").asLong()); } else { issue.save(); } attachUploadFilesToPost(files, issue.asResource()); ObjectNode result = Json.newObject(); result.put("status", 201); result.put("location", controllers.routes.IssueApp.issue(project.owner, project.name, issue.getNumber()).toString()); if (sendNotification) { NotificationEvent.afterNewIssue(issue); } return result; } private static void updateLabels(JsonNode json, Issue issue, Project project) { JsonNode labelsNode = json.findValue("labels"); if (labelsNode != null && labelsNode.isArray()) { for (JsonNode labelNode : labelsNode) { IssueLabel issueLabel = IssueLabel.findByName( labelNode.findValue("labelName").asText(), labelNode.findValue("category").asText(), project); if(issueLabel != null){ if(issue.labels == null) { issue.labels = new HashSet<>(); } issue.labels.add(issueLabel); } } } } private static Milestone findMilestone(JsonNode milestoneTitle, Project project) { if(milestoneTitle != null){ return Milestone.findMilestoneByTitle(project, milestoneTitle.asText()); } return null; } private static Date findDueDate(JsonNode dueDateNode) { DateFormat df = new SimpleDateFormat("yyyy-MM-dd a hh:mm:ss Z", Locale.ENGLISH); if(dueDateNode != null){ try { return df.parse(dueDateNode.asText()); } catch (ParseException e) { e.printStackTrace(); } } return null; } private static State findIssueState(JsonNode json){ JsonNode issueNode = json.findValue("state"); if( issueNode == null) { return State.OPEN; } if ("OPEN".equalsIgnoreCase(issueNode.asText())) { return State.OPEN; } else { return State.CLOSED; } } public static Result commentNotiRecivers(String ownerName, String projectName, Long number) { JsonNode json = request().body().asJson(); if (json == null) { return badRequest(Json.newObject().put("message", "Expecting Json data")); } Project project = Project.findByOwnerAndProjectName(ownerName, projectName); final Issue issue = Issue.findByNumber(project, number); User user = UserApp.currentUser(); String commentText = json.findValue("comment").asText(); String parentCommentId = json.findValue("parentCommentId").asText(); final IssueComment comment = new IssueComment(issue, user, commentText); comment.createdDate = JodaDateUtil.now(); comment.setAuthor(user); comment.issue = issue; if (StringUtils.isNotBlank(parentCommentId)) { comment.parentCommentId = parentCommentId; comment.setParentComment(IssueComment.find.byId(json.findValue("parentCommentId").asLong())); } Set<User> receivers = NotificationEvent.getMandatoryReceivers(comment, EventType.NEW_COMMENT); List<ObjectNode> users = new ArrayList<>(); for(User receiver: receivers) { addUserToUsers(receiver, users); } ObjectNode result = Json.newObject(); result.put("receivers", toJson(users)); return ok(result); } @Transactional public static Result newIssueComment(String ownerName, String projectName, Long number) throws IOException { JsonNode json = request().body().asJson(); if(json == null) { return badRequest("Expecting Json data"); } Project project = Project.findByOwnerAndProjectName(ownerName, projectName); final Issue issue = Issue.findByNumber(project, number); if (request().getHeader("Authorization") != null) { ObjectNode result = Json.newObject(); if (!isAuthored(request())) { return unauthorized(result.put("message", "unauthorized request")); } User user = getAuthorizedUser(getAuthorizationToken(request())); String comment = json.findValue("comment").asText(); return createCommentUsingToken(issue, user, comment); } else { return createCommentByUser(project, issue, json); } } public static boolean isModifiedByOthers(String current, String fromView){ // At present, using .val() on textarea elements strips carriage return characters // https://stackoverflow.com/a/8601601/1450196 // At first, I added hook of above link at the front page. // But I found that it introduce another problem, cursor location detection error. // So, decided to calculate sha1 without \r char. String currentChecksum = DigestUtils.sha1Hex(current.replaceAll("\r","").trim()); String fromViewChecksum = DigestUtils.sha1Hex(fromView.replaceAll("\r","").trim()); return !currentChecksum.equals(fromViewChecksum); } public static Result detectChange(String ownerName, String projectName, Long number) { if (UserApp.currentUser().isAnonymous()) { return unauthorized(Json.newObject().put("message", "unauthorized request")); } JsonNode json = request().body().asJson(); if(json == null) { return badRequest(Json.newObject().put("message", "Expecting Json data")); } Project project = Project.findByOwnerAndProjectName(ownerName, projectName); final Issue issue = Issue.findByNumber(project, number); ObjectNode result = Json.newObject(); String receivedChecksum = json.findValue("issueBodyChecksum").asText(); int receivedNumOfComments = json.findValue("numOfComments").asInt(); int currentNumOfComments = issue.computeNumOfComments(); if( receivedNumOfComments < currentNumOfComments) { IssueComment issueComment = issue.comments.get(issue.comments.size() - 1); result.put("commentAuthorName", User.findByLoginId(issueComment.authorLoginId).getDisplayName()); } String hex = DigestUtils.sha1Hex(issue.body); result.put("issueBodyChanged", !hex.equals(receivedChecksum)); result.put("numOfComments", currentNumOfComments); result.put("issueBodyChecksum", hex); result.put("issueUpdateDate", issue.updatedDate.getTime()); result.put("result", "ok"); return ok(result); } public static Status conflicted(String content) { ObjectNode result = Json.newObject(); result.put("message", "Already modified by someone."); result.put("storedContent", content); return new Status(play.core.j.JavaResults.Conflict(), result, Codec.javaSupported("utf-8")); } @Transactional public static Result updateIssueComment(String ownerName, String projectName, Long number, Long commentId) { User user = UserApp.currentUser(); if (user.isAnonymous()) { return unauthorized(Json.newObject().put("message", "unauthorized request")); } JsonNode json = request().body().asJson(); if(json == null) { return badRequest(Json.newObject().put("message", "Expecting Json data")); } String comment = json.findValue("content").asText(); // TODO: It is TOO bulky comparing whole text String original = json.findValue("original").asText(); Project project = Project.findByOwnerAndProjectName(ownerName, projectName); final Issue issue = Issue.findByNumber(project, number); IssueComment issueComment = issue.findCommentByCommentId(commentId); if (isModifiedByOthers(issueComment.contents, original)) { return conflicted(issueComment.contents); } if (!AccessControl.isAllowed(user, issueComment.asResource(), Operation.UPDATE)) { return forbidden(Json.newObject().put("message", "Forbidden request")); } issueComment.contents = comment; issueComment.save(); ObjectNode commentNode = getCommentJsonNode(issueComment); ObjectNode authorNode = getAuthorJsonNode(user); commentNode.set("author", toJson(authorNode)); ObjectNode result = Json.newObject(); result.set("result", commentNode); return ok(result); } private static Result createCommentByUser(Project project, Issue issue, JsonNode json) { if (!AccessControl.isResourceCreatable( UserApp.currentUser(), issue.asResource(), ResourceType.ISSUE_COMMENT)) { return forbidden(ErrorViews.Forbidden.render("error.forbidden", project)); } User user = findAuthor(json.findValue("author")); String body = json.findValue("body").asText(); IssueComment issueComment = createComment(issue, user, body, json.findValue("createdAt")); attachUploadFilesToPost(json.findValue("temporaryUploadFiles"), issueComment.asResource()); ObjectNode result = Json.newObject(); result.put("status", 201); result.put("location", RouteUtil.getUrl(issueComment)); return created(result); } private static Result createCommentUsingToken(Issue issue, User user, String comment) { createComment(issue, user, comment, null); ObjectNode result = ProjectApi.getResult(issue); return created(Json.newObject().set("result", toJson(addIssueEvents(issue, result)))); } private static IssueComment createComment(Issue issue, User user, String comment, JsonNode dateNode) { final IssueComment issueComment = new IssueComment(issue, user, comment); issueComment.createdDate = dateNode == null ? JodaDateUtil.now() : parseDateString(dateNode); issueComment.setAuthor(user); issueComment.issue = issue; issueComment.save(); return issueComment; } public static ObjectNode getCommentJsonNode(Comment comment) { ObjectNode commentNode = Json.newObject(); commentNode.put("id", comment.id); commentNode.put("contents", comment.contents); commentNode.put("createdDate", JodaDateUtil.getDateString(comment.createdDate, JodaDateUtil.ISO_FORMAT)); return commentNode; } public static ObjectNode getAuthorJsonNode(User user) { ObjectNode authorNode = Json.newObject(); authorNode.put("id", user.id); authorNode.put("loginId", user.loginId); authorNode.put("name", user.name); return authorNode; } public static User findAuthor(JsonNode authorNode){ if (authorNode != null) { String email = authorNode.findValue("email").asText(); User originalAuthor = User.findByEmail(email); if (originalAuthor != null) { return originalAuthor; } else { createUserNode(authorNode); return User.findByEmail(email); } } User user = User.findUserIfTokenExist(UserApp.currentUser()); if (user.isAnonymous()) { play.Logger.error("Import error caused by unknown user import!"); } return user; } private static Assignee findAssginee(JsonNode assigneesNode, @Nonnull Project project) { if ( assigneesNode != null && assigneesNode.isArray() && assigneesNode.size() > 0) { JsonNode assigneeNode = assigneesNode.get(0); User user = User.findByEmail(assigneeNode.findValue("email").asText()); if(!user.isAnonymous()) { return Assignee.add(user.id, project.id); } } return null; } public static Date parseDateString(JsonNode dateStringNode){ if(dateStringNode == null) { return null; } DateFormat df = new SimpleDateFormat("yyyy-MM-dd a hh:mm:ss Z", Locale.ENGLISH); try { return df.parse(dateStringNode.asText()); } catch (ParseException e) { e.printStackTrace(); } return null; } @IsAllowed(Operation.READ) public static Result findAssignableUsersOfProject(String ownerName, String projectName, String query) { if (!request().accepts("application/json")) { return status(Http.Status.NOT_ACCEPTABLE); } Project project = Project.findByOwnerAndProjectName(ownerName, projectName); List<ObjectNode> users = new ArrayList<>(); if(StringUtils.isEmpty(query)){ addUserToUsersWithCustomName(UserApp.currentUser(), users, Messages.get("issue.assignToMe")); for(User user: project.getAssignableUsers()){ addUserToUsers(user, users); } return ok(toJson(users)); } ExpressionList<User> el = getUserExpressionList(query, request().getQueryString("type")); int total = el.findRowCount(); if (total > MAX_FETCH_USERS) { el.setMaxRows(MAX_FETCH_USERS); response().setHeader("Content-Range", "items " + MAX_FETCH_USERS + "/" + total); } gatheringUsersFromExpressionList(project, users, el); return ok(toJson(users)); } private static void gatheringUsersFromExpressionList(Project project, List<ObjectNode> users, ExpressionList<User> el) { for (User user : el.findList()) { if (project.isPublic()) { addUserToUsers(user, users); } else { if (user.isMemberOf(project) || project.hasGroup() && (user.isMemberOf(project.organization) || user.isAdminOf(project.organization))) { addUserToUsers(user, users); } } } } @IsAllowed(Operation.READ) public static Result findAssignableUsers(String ownerName, String projectName, Long number, String query) { if (!request().accepts("application/json")) { return status(Http.Status.NOT_ACCEPTABLE); } Project project = Project.findByOwnerAndProjectName(ownerName, projectName); Issue issue = Issue.findByNumber(project, number); List<ObjectNode> users = new ArrayList<>(); if(StringUtils.isEmpty(query)){ User issueAuthor = issue.getAuthor(); if (issue.hasAssignee()) { addMyself(issue, users); addAuthorIfNotMeAndNotAssginee(issue, users, issueAuthor); addUserToUsersWithCustomName(User.anonymous, users, Messages.get("issue.noAssignee")); addUserToUsers(issue.assignee.user, users); // To positioned up rank of list } else { addUserToUsersWithCustomName(UserApp.currentUser(), users, Messages.get("issue.assignToMe")); addAuthorIfNotMe(issue, users, issueAuthor); } for(User user: project.getAssignableUsersAndAssignee(issue)){ addUserToUsers(user, users); } return ok(toJson(users)); } ExpressionList<User> el = getUserExpressionList(query, request().getQueryString("type")); int total = el.findRowCount(); if (total > MAX_FETCH_USERS) { el.setMaxRows(MAX_FETCH_USERS); response().setHeader("Content-Range", "items " + MAX_FETCH_USERS + "/" + total); } gatheringUsersFromExpressionList(project, users, el); return ok(toJson(users)); } private static ExpressionList<User> getUserExpressionList(String query, String searchType) { ExpressionList<User> el = User.find.select("loginId, name").where() .eq("state", UserState.ACTIVE).disjunction(); if( StringUtils.isNotBlank(searchType)){ el.eq(searchType, query); } else { el.icontains("loginId", query); el.icontains("name", query); el.icontains("englishName", query); el.endJunction(); } return el; } private static ExpressionList<Project> getProjectExpressionList(String query, String searchType) { ExpressionList<Project> el = Project.find.select("id, name").where() .eq("projectScope", ProjectScope.PUBLIC).disjunction(); el.icontains("name", query); el.endJunction(); return el; } private static void addAuthorIfNotMe(Issue issue, List<ObjectNode> users, User issueAuthor) { if (!issue.getAuthor().loginId.equals(UserApp.currentUser().loginId)) { addUserToUsersWithCustomName(issueAuthor, users, Messages.get("issue.assignToAuthor")); } } private static void addAuthorIfNotMeAndNotAssginee(Issue issue, List<ObjectNode> users, User issueAuthor) { if (!issue.getAuthor().loginId.equals(UserApp.currentUser().loginId) && !issue.getAuthor().loginId.equals(issue.assignee.user.loginId)) { addUserToUsersWithCustomName(issueAuthor, users, Messages.get("issue.assignToAuthor")); } } private static void addMyself(Issue issue, List<ObjectNode> users) { if (!UserApp.currentUser().loginId.equals(issue.assignee.user.loginId)) { addUserToUsersWithCustomName(UserApp.currentUser(), users, Messages.get("issue.assignToMe")); } } static void addUserToUsers(User user, List<ObjectNode> users) { ObjectNode userNode = Json.newObject(); userNode.put("loginId", user.loginId); userNode.put("name", user.getDisplayName()); userNode.put("pureNameOnly", user.getPureNameOnly()); userNode.put("avatarUrl", user.avatarUrl()); userNode.put("type", "user"); if(!users.contains(userNode)) { users.add(userNode); } } static void addProjectToProjects(Project project, List<ObjectNode> projects) { ObjectNode projectNode = Json.newObject(); projectNode.put("loginId", project.id); projectNode.put("name", project.owner + "/" + project.name); projectNode.put("avatarUrl", ""); projectNode.put("type", "project"); if(!projects.contains(projectNode)) { projects.add(projectNode); } } private static void addUserToUsersWithCustomName(User user, List<ObjectNode> users, String name) { ObjectNode userNode = Json.newObject(); userNode.put("loginId", user.loginId); userNode.put("name", name); userNode.put("avatarUrl", ""); if(!users.contains(userNode)) { users.add(userNode); } } public static Result updateAssginees(String owner, String projectName, Long number){ ObjectNode result = Json.newObject(); JsonNode json = request().body().asJson(); if (json == null) { return badRequest(result.put("message", "Expecting Json data")); } Project project = Project.findByOwnerAndProjectName(owner, projectName); Issue issue = Issue.findByNumber(project, number); if (AccessControl.isAllowed(UserApp.currentUser(), issue.asResource(), Operation.UPDATE)) { JsonNode assignees = json.findValue("assignees"); if(assignees == null || assignees.size() == 0){ return badRequest(result.put("message", "No assignee")); } boolean assigneeChanged = false; for(JsonNode assgineeNode: assignees){ User assigneeUser = User.findByLoginId(assgineeNode.asText()); User oldAssignee = null; if (issue.hasAssignee()) { oldAssignee = issue.assignee.user; } Assignee newAssignee = getAssignee(project, assigneeUser); assigneeChanged = !issue.assignedUserEquals(newAssignee); issue.assignee = newAssignee; issue.updatedDate = JodaDateUtil.now(); issue.update(); if(assigneeChanged) { NotificationEvent notiEvent = NotificationEvent.afterAssigneeChanged(oldAssignee, issue); IssueEvent.addFromNotificationEvent(notiEvent, issue, UserApp.currentUser().loginId); } composeResultJson(result, assigneeUser); } } result.put("issue", routes.IssueApp.issue(owner, projectName, number).url()); return ok(result); } private static void composeResultJson(ObjectNode result, User assigneeUser) { ObjectNode node = Json.newObject(); node.put("loginId", assigneeUser.loginId); if(assigneeUser.isAnonymous()){ node.put("name", Messages.get("common.none")); } else { node.put("name", assigneeUser.getDisplayName()); } result.put("assignee", node); } private static Assignee getAssignee(Project project, User assigneeUser) { Assignee newAssignee; if (assigneeUser.isAnonymous()) { newAssignee = null; } else { newAssignee = Assignee.add(assigneeUser.id, project.id); } return newAssignee; } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static F.Promise<Result> translate() { if(StringUtils.isBlank(TRANSLATION_API)) { return F.Promise.promise( () -> status(412, "Precondition Failed")); } JsonNode json = request().body().asJson(); String owner = json.findValue("owner").asText(); String projectName = json.findValue("projectName").asText(); String type = json.findValue("type").asText(); long number = json.findValue("number").asLong(); String text = ""; Project project = Project.findByOwnerAndProjectName(owner, projectName); switch (type) { case "issue": Issue issue = Issue.findByNumber(project, number); text = "Title: " + issue.title + NEWLINE + NEWLINE + issue.body; break; case "posting": Posting posting = Posting.findByNumber(project, number); text = "Title: " + posting.title + NEWLINE + NEWLINE + posting.body; break; case "issue-comment": text = IssueComment.find.byId(number).contents; break; case "post-comment": text = PostingComment.find.byId(number).contents; break; default: break; } return getTranslation(text, project, translatorWsRequestHolderSupplier); } private static F.Promise<WSResponse> translate(String text, WSRequestHolder translator) { if (StringUtils.isBlank(text)) { return F.Promise.pure(null); } else { return translator.post("source=ko&target=en&text=" + text); } } private static Supplier<WSRequestHolder> translatorWsRequestHolderSupplier = () -> WS.url(TRANSLATION_API) .setContentType("application/x-www-form-urlencoded; charset=UTF-8") .setHeader("Accept", "application/json,application/x-www-form-urlencoded,text/html,*/*") .setHeader(TRANSLATION_HEADER_KEY, TRANSLATION_HEADER_VALUE); private static List<String> merge(List<String> texts) { List<String> results = new ArrayList<>(); int chunkLength = 0; String chunk = ""; for (int i = 0 ; i < texts.size(); i += 1) { String text = texts.get(i); if (chunkLength + text.length() < TRANSLATE_TEXT_LENGTH_LIMIT) { chunk += text; chunk += NEWLINE; chunkLength += text.length(); } else { results.add(chunk); chunk = text; chunk += NEWLINE; chunkLength = text.length(); } } results.add(chunk); return results; } private static F.Promise<Result> getTranslations(List<String> texts, Project project, Supplier<WSRequestHolder> translatorSupplier) { WSRequestHolder translator = translatorSupplier.get(); List<String> mergedTexts = merge(texts); List<F.Promise<WSResponse>> promises = mergedTexts.stream() .map(text -> translate(text, translator)) .collect(Collectors.toList()); return F.Promise.sequence(promises) .map(results -> results.stream() .map(jsonNode -> { if (jsonNode == null) { return NEWLINE; } JsonNode resultNode = jsonNode.asJson().findPath("result"); JsonNode translatedTextNode = resultNode.findPath("translatedText"); return translatedTextNode.textValue(); }) .collect(Collectors.toList())) .map(translatedList -> { String translated = String.join(NEWLINE, translatedList); ObjectNode node = Json.newObject(); node.put("translated", Markdown.render(translated, project)); return ok(node); }); } private static F.Promise<Result> getTranslation(String text, Project project, Supplier<WSRequestHolder> by) { List<String> texts = Arrays.asList(text.replaceAll("&", "%26").split(NEWLINE)); return getTranslations(texts, project, by); } @AnonymousCheck public static Result findSharerByloginIds(String ownerName, String projectName, Long number, String commaSeperatedIds) { if (!request().accepts("application/json")) { return status(Http.Status.NOT_ACCEPTABLE); } Project project = Project.findByOwnerAndProjectName(ownerName, projectName); Issue issue = Issue.findByNumber(project, number); List<IssueSharer> list = getExpressionListByExtractingLoginIds(issue, commaSeperatedIds).findList(); sortListByAddedDate(list); List<ObjectNode> users = new ArrayList<>(); for (IssueSharer sharer :list) { addUserToUsers(sharer.user, users); } return ok(toJson(users)); } private static void sortListByAddedDate(List<IssueSharer> list) { list.sort(new Comparator<IssueSharer>() { @Override public int compare(IssueSharer o1, IssueSharer o2) { return o1.created.compareTo(o2.created); } }); } private static ExpressionList<IssueSharer> getExpressionListByExtractingLoginIds(Issue issue, String query) { String[] queryItems = query.split(","); ExpressionList<IssueSharer> el = IssueSharer.find .where() .in("loginId", Arrays.asList(queryItems)) .eq("issue.id", issue.id); return el; } @IsAllowed(Operation.READ) public static Result findSharableUsers(String ownerName, String projectName, Long number, String query) { if (!request().accepts("application/json")) { return status(Http.Status.NOT_ACCEPTABLE); } List<ObjectNode> results = new ArrayList<>(); ExpressionList<User> userExpressionList = getUserExpressionList(query, request().getQueryString("type")); ExpressionList<Project> projectExpressionList = getProjectExpressionList(query, request().getQueryString("type")); int total = userExpressionList.findRowCount() + projectExpressionList.findRowCount(); if (total > MAX_FETCH_USERS) { userExpressionList.setMaxRows(MAX_FETCH_USERS / 2); projectExpressionList.setMaxRows(MAX_FETCH_USERS / 2); response().setHeader("Content-Range", "items " + MAX_FETCH_USERS + "/" + total); } for (User user :userExpressionList.findList()) { addUserToUsers(user, results); } for (Project project: projectExpressionList.findList()) { addProjectToProjects(project, results); } return ok(toJson(results)); } public static Result updateSharer(String owner, String projectName, Long number){ JsonNode json = request().body().asJson(); if (json == null) { return badRequest(Json.newObject().put("message", "Expecting Json data")); } Project project = Project.findByOwnerAndProjectName(owner, projectName); Issue issue = Issue.findByNumber(project, number); if (!AccessControl.isAllowed(UserApp.currentUser(), issue.asResource(), Operation.UPDATE)) { return forbidden(Json.newObject().put("message", "Permission denied")); } JsonNode sharer = json.findValue("sharer"); if(noSharer(sharer)){ return badRequest(Json.newObject().put("message", "No sharer")); } final String action = json.findValue("action").asText(); ObjectNode result = changeSharer(sharer, issue, action); return ok(result); } public static Result upvoteWeight(String owner, String projectName, Long number){ Project project = Project.findByOwnerAndProjectName(owner, projectName); Issue issue = Issue.findByNumber(project, number); if (!AccessControl.isAllowed(UserApp.currentUser(), issue.asResource(), Operation.UPDATE)) { return forbidden(Json.newObject().put("message", "Permission denied")); } issue.weight = issue.weight + 1; issue.update(); ObjectNode result = Json.newObject(); result.put("weight", issue.weight); return ok(result); } public static Result downvoteWeight(String owner, String projectName, Long number){ Project project = Project.findByOwnerAndProjectName(owner, projectName); Issue issue = Issue.findByNumber(project, number); if (!AccessControl.isAllowed(UserApp.currentUser(), issue.asResource(), Operation.UPDATE)) { return forbidden(Json.newObject().put("message", "Permission denied")); } issue.weight = issue.weight - 1; issue.update(); ObjectNode result = Json.newObject(); result.put("weight", issue.weight); return ok(result); } private static ObjectNode changeSharer(JsonNode sharer, Issue issue, String action) { ObjectNode result = Json.newObject(); List<String> users = new ArrayList<>(); if(sharer.findValue("type").asText().equals("project")) { changeSharerByProject(sharer.findValue("loginId").asLong(), issue, action, result, users); } else { changeSharerByUser(sharer.findValue("loginId").asText(), issue, action, result, users); } sendNotification(users, issue, action); return result; } private static void changeSharerByUser(String loginId, Issue issue, String action, ObjectNode result, List<String> users) { if ("add".equalsIgnoreCase(action)) { addSharer(issue, loginId); } else if ("delete".equalsIgnoreCase(action)) { removeSharer(issue, loginId); } else { play.Logger.error("Unknown issue sharing action: " + issue + ":" + action + " by " + currentUser()); } users.add(loginId); setShareActionToResponse(action, result); result.put("sharer", User.findByLoginId(loginId).getDisplayName()); } private static void changeSharerByProject(Long projectId, Issue issue, String action, ObjectNode result, List<String> users) { List<ProjectUser> projectUsers = ProjectUser.findMemberListByProject(projectId); for (ProjectUser projectUser: projectUsers) { if ("add".equalsIgnoreCase(action)) { addSharer(issue, projectUser.user.loginId); } else if ("delete".equalsIgnoreCase(action)) { removeSharer(issue, projectUser.user.loginId); } else { play.Logger.error("Unknown issue sharing action: " + issue + ":" + action + " by " + currentUser()); } users.add(projectUser.user.loginId); } setShareActionToResponse(action, result); result.put("sharer", Project.find.byId(projectId).name); } private static void setShareActionToResponse(String action, ObjectNode result) { if ("add".equalsIgnoreCase(action)) { result.put("action", "added"); } else if ("delete".equalsIgnoreCase(action)) { result.put("action", "deleted"); } else { result.put("action", "Do nothing. Unsupported action: " + action); } } private static void sendNotification(List<String> users, Issue issue, String action) { Runnable preUpdateHook = new Runnable() { @Override public void run() { for(String sharerLoginId: users){ addSharerChangedNotification(issue, sharerLoginId, action); } } }; preUpdateHook.run(); } private static void addSharerChangedNotification(Issue issue, String sharerLoginId, String action) { NotificationEvent notiEvent = NotificationEvent.afterIssueSharerChanged(issue, sharerLoginId, action); IssueEvent.addFromNotificationEventWithoutSkipEvent(notiEvent, issue, UserApp.currentUser().loginId); } private static boolean noSharer(JsonNode sharers) { return sharers == null || sharers.size() == 0; } private static void addSharer(Issue issue, String loginId) { IssueSharer issueSharer = IssueSharer.find.where() .eq("loginId", loginId) .eq("issue.id", issue.id).findUnique(); if(issueSharer == null) { issueSharer = IssueSharer.createSharer(loginId, issue); issueSharer.save(); } issue.sharers.add(issueSharer); } private static void removeSharer(Issue issue, String loginId) { IssueSharer issueSharer = IssueSharer.find.where() .eq("loginId", loginId) .eq("issue.id", issue.id) .findUnique(); issueSharer.delete(); issue.sharers.remove(issueSharer); } }