/** * Yona, Project Hosting SW * * Copyright 2016 the original author or authors. */ package controllers; import com.avaje.ebean.Ebean; import com.avaje.ebean.Query; import com.avaje.ebean.RawSql; import com.avaje.ebean.RawSqlBuilder; import com.fasterxml.jackson.databind.node.ObjectNode; import controllers.annotation.AnonymousCheck; import models.*; import models.enumeration.ResourceType; import models.support.IssueLabelAggregate; import org.apache.commons.lang.StringUtils; import play.Configuration; import play.libs.F; import play.libs.F.Promise; import play.libs.Json; import play.libs.ws.WS; import play.mvc.Result; import utils.ErrorViews; import views.html.migration.home; import javax.validation.constraints.NotNull; import java.time.LocalDateTime; import java.time.ZoneId; import java.time.format.DateTimeFormatter; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import java.util.stream.Collectors; import static play.libs.Json.toJson; import static play.mvc.Http.Context.Implicit.request; import static play.mvc.Results.forbidden; import static play.mvc.Results.ok; @AnonymousCheck public class MigrationApp { static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'"); private static final String YONA_SERVER = "/"; @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Promise<Result> migration() { final boolean isAllowed = Configuration.root().getBoolean("github.allow.migration", false); if(!isAllowed){ return Promise.pure(forbidden(ErrorViews.Forbidden.render("error.forbidden.or.not.allowed"))); } String authProcessingCode = request().getQueryString("code"); if(StringUtils.isNotBlank(authProcessingCode)){ return getOAuthToken(authProcessingCode).map((F.Function<String, Result>) token -> ok(home.render("Migration", authProcessingCode, token))); } else { return Promise.promise((F.Function0<Result>) () -> ok(home.render("Migration", null, null))); } } private static Promise<String> getOAuthToken(String code) { final String ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token"; final String CLIENT_ID = Configuration.root().getString("github.client.id"); final String CLIENT_SECRET = Configuration.root().getString("github.client.secret"); return WS.url(ACCESS_TOKEN_URL) .setContentType("application/x-www-form-urlencoded") .setHeader("Accept", "application/json,application/x-www-form-urlencoded,text/html,*/*") .post("client_id=" + CLIENT_ID + "&client_secret=" + CLIENT_SECRET + "&code=" + code) .map(response -> { play.Logger.debug(response.getBody()); String accessToken = ""; try { Pattern p = Pattern.compile("access_token=([^&]+)"); Matcher m = p.matcher(response.getBody()); if(m.find() ){ accessToken = m.group(1); } } catch (PatternSyntaxException ex) { play.Logger.error("Couldn't find access_token"); } play.Logger.error("token=" + accessToken); return accessToken; }); } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Result projects(){ Set<Project> sourceProjects = new HashSet<>(); getheringOrgProjects(sourceProjects); gatheringUserProjects(sourceProjects); List<ObjectNode> projects = new ArrayList<>(); for(Project project: sortProjectsByOwnerAndName(sourceProjects)){ ObjectNode projectNode = Json.newObject(); projectNode.put("owner", project.owner); projectNode.put("projectName", project.name); projectNode.put("private", project.isPrivate()); projectNode.put("members", project.members().size()); projectNode.put("full_name", project.owner + "/" + project.name); projects.add(projectNode); } return ok(toJson(projects)); } private static List<Project> sortProjectsByOwnerAndName(Set<Project> projects) { Comparator<Project> comparator = Comparator.comparing(project -> project.owner); comparator = comparator.thenComparing(Comparator.comparing(project -> project.name)); List<Project> list = new ArrayList<>(projects); Collections.sort(list, comparator); return list; } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Result project(String owner, String projectName){ Project project = Project.findByOwnerAndProjectName(owner, projectName); ObjectNode result = Json.newObject(); result.put("owner", project.owner); result.put("projectName", project.name); result.put("full_name", project.owner + "/" + project.name); result.put("assignees", toJson(getAssginees(project).toArray())); result.put("memberCount", project.members().size()); result.put("issueCount", project.issues.size()); result.put("postCount", project.posts.size()); result.put("milestoneCount", project.milestones.size()); return ok(result); } public static List<ObjectNode> getAssginees(Project project) { List<ObjectNode> members = new ArrayList<>(); for(Assignee assignee: project.assignees){ ObjectNode member = Json.newObject(); member.put("name", assignee.user.name); member.put("login", assignee.user.loginId); member.put("email", assignee.user.email); members.add(member); } return members; } public static List<ObjectNode> getAuthors(Project project) { List<ObjectNode> authors = new ArrayList<>(); for(User user: project.findAuthors()){ ObjectNode member = Json.newObject(); member.put("name", user.name); member.put("login", user.loginId); member.put("email", user.email); authors.add(member); } return authors; } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Result exportIssueLabelPairs(String owner, String projectName){ ObjectNode issueLabelPairs = composeIssueLabelPairJson(owner, projectName); return ok(issueLabelPairs); } public static ObjectNode composeIssueLabelPairJson(String owner, String projectName) { Project project = Project.findByOwnerAndProjectName(owner, projectName); Query<IssueLabelAggregate> query = Ebean.find(IssueLabelAggregate.class); String sql = "select issue_id, issue_label_id \n" + "from issue i, issue_issue_label iil \n" + "where project_id = " + project.id + "\n" + "and i.id = iil.issue_id"; RawSql rawSql = RawSqlBuilder.parse(sql).create(); query.setRawSql(rawSql); List<IssueLabelAggregate> results = query.findList(); ObjectNode issueLabelPairs = Json.newObject(); issueLabelPairs.put("issueLabelPairs", toJson(results)); return issueLabelPairs; } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Result exportLabels(String owner, String projectName){ Project project = Project.findByOwnerAndProjectName(owner, projectName); ObjectNode labels = Json.newObject(); for (IssueLabel label : IssueLabel.findByProject(project)) { ObjectNode node = Json.newObject(); node.put("id", label.id); node.put("name", label.name); node.put("categoryId", label.category.id); node.put("categoryName", label.category.name); labels.put(String.valueOf(label.id), node); } ObjectNode exportData = Json.newObject(); exportData.put("labels", toJson(labels)); return ok(exportData); } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Result exportMilestones(String owner, String projectName){ Project project = Project.findByOwnerAndProjectName(owner, projectName); List<ObjectNode> milestones = project.milestones.stream() .map(MigrationApp::composeMilestoneJson).collect(Collectors.toList()); ObjectNode exportData = Json.newObject(); exportData.put("milestones", toJson(milestones)); return ok(exportData); } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Result exportPosts(String owner, String projectName){ Project project = Project.findByOwnerAndProjectName(owner, projectName); List<ObjectNode> issues = project.posts.stream() .map(MigrationApp::composePostJson).collect(Collectors.toList()); ObjectNode exportData = Json.newObject(); exportData.put("issues", toJson(issues)); return ok(exportData); } @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true) public static Result exportIssues(String owner, String projectName){ Project project = Project.findByOwnerAndProjectName(owner, projectName); List<ObjectNode> issues = project.issues.stream() .map(MigrationApp::composeIssueJson).collect(Collectors.toList()); ObjectNode exportData = Json.newObject(); exportData.put("issues", toJson(issues)); return ok(exportData); } public static ObjectNode composeMilestoneJson(Milestone m) { ObjectNode milestoneJson = Json.newObject(); milestoneJson.put("milestone", getMilestoneNode(m)); return milestoneJson; } public static ObjectNode getMilestoneNode(Milestone m) { ObjectNode node = Json.newObject(); node.put("id", m.id); node.put("title", m.title); node.put("state", m.state.state()); node.put("description", m.contents); Optional.ofNullable(m.dueDate).ifPresent(dueDate -> node.put("due_on", LocalDateTime.ofInstant(m.dueDate.toInstant(), ZoneId.systemDefault()).format(formatter))); return node; } private static String addOriginalAuthorName(String bodyText, String authorLoginId, String authorName, String type, String link){ return String.format("@%s (%s) 님이 작성한 [%s](%s)입니다. \n\\---\n\n%s", authorLoginId, authorName, type, link, bodyText); } private static String relativeLinksToAbsolutePath(String text){ // replace relative img tag src to absolute path // and replace relative markdown link path to absolute path return text.replaceAll("(<img src=[\"\'])/(?<link>.*)([\"\']>)", "$1" + YONA_SERVER + "$2$3") .replaceAll("\\[(?<text>[^\\]]*)\\]\\(/(?<link>[^\\)]*)\\)", "[$1](" + YONA_SERVER + "$2)"); } private static String relativeLinksToWikiCommitPath(String text){ // replace relative img tag src to absolute path // and replace relative markdown link path to wiki commit file path return text.replaceAll("(<img src=[\"\'])/(?<link>.*)([\"\']>)", "$1" + YONA_SERVER + "$2$3") .replaceAll("\\[(?<text>[^\\]]*)\\]\\(/(?<link>[^\\)]*)\\)", "[$1](../wiki/$2/$1)"); } private static StringBuilder addAttachmentsString(@NotNull StringBuilder sb, ResourceType type, String id){ try { List<Map<String, String>> attachments = AttachmentApp.getFileList(type.toString(), id).get("attachments"); if(attachments.size()>0){ addListHeader(sb); } for(Map<String, String> attachment: attachments){ sb.append(String.format("\n[%s](%s)", attachment.get("name"), YONA_SERVER + attachment.get("url"))); } } catch (Exception e) { e.printStackTrace(); } return sb; } private static void addListHeader(@NotNull StringBuilder sb) { sb.append("\n\n--- attachments ---"); } private static StringBuilder addAttachmentsStringUsingWikiCommit(@NotNull StringBuilder sb, ResourceType type, String id){ try { List<Map<String, String>> attachments = AttachmentApp.getFileList(type.toString(), id).get("attachments"); if(attachments.size()>0){ addListHeader(sb); } for(Map<String, String> attachment: attachments){ sb.append(String.format("\n[%s](../wiki/files/%s/%s)", attachment.get("name"), attachment.get("id"), attachment.get("name").replaceAll("#", "%23"))); } } catch (Exception e) { e.printStackTrace(); } return sb; } private static ObjectNode composePostJson(Posting posting) { String originalPostingLink = String.format("%s/%s/post/%s", YONA_SERVER + posting.project.owner, posting.project.name, posting.getNumber()); ObjectNode node = Json.newObject(); node.put("title", posting.title); // body 작성 StringBuilder sb = new StringBuilder(); if(usingWikiCommitForAttachment()){ sb.append(addOriginalAuthorName( relativeLinksToWikiCommitPath(posting.body), posting.authorLoginId, posting.authorName, "게시글", originalPostingLink)); sb = addAttachmentsStringUsingWikiCommit(sb, ResourceType.BOARD_POST, posting.id.toString()); } else { sb.append(addOriginalAuthorName( relativeLinksToAbsolutePath(posting.body), posting.authorLoginId, posting.authorName, "게시글", originalPostingLink)); sb = addAttachmentsString(sb, ResourceType.BOARD_POST, posting.id.toString()); } node.put("body", sb.toString()); node.put("created_at", LocalDateTime.ofInstant(posting.createdDate.toInstant(), ZoneId.systemDefault()).format(formatter)); ObjectNode postingJson = Json.newObject(); postingJson.put("issue", node); // intentionally 'issue' key name is used for Github api compatibility postingJson.put("comments", toJson(composeCommentsJson(posting, originalPostingLink, ResourceType.NONISSUE_COMMENT))); return postingJson; } private static boolean usingWikiCommitForAttachment() { String withWikiCommit = request().getQueryString("withWikiCommit"); boolean usingWikiCommit = StringUtils.isNotBlank(withWikiCommit) && withWikiCommit.endsWith("true"); return usingWikiCommit; } private static ObjectNode composeIssueJson(Issue issue) { String originalIssueLink = String.format("%s/%s/issue/%s", YONA_SERVER + issue.project.owner, issue.project.name, issue.getNumber()); ObjectNode node = Json.newObject(); node.put("id", issue.id); node.put("title", issue.title); // body 작성 StringBuilder sb = new StringBuilder(); if(usingWikiCommitForAttachment()){ sb.append(addOriginalAuthorName( relativeLinksToWikiCommitPath(issue.body), issue.authorLoginId, issue.authorName, "이슈", originalIssueLink)); sb = addAttachmentsStringUsingWikiCommit(sb, ResourceType.ISSUE_POST, issue.id.toString()); } else { sb.append(addOriginalAuthorName( relativeLinksToAbsolutePath(issue.body), issue.authorLoginId, issue.authorName, "이슈", originalIssueLink)); sb = addAttachmentsString(sb, ResourceType.ISSUE_POST, issue.id.toString()); } node.put("body", sb.toString()); node.put("created_at", LocalDateTime.ofInstant(issue.createdDate.toInstant(), ZoneId.systemDefault()).format(formatter)); Optional.ofNullable(issue.assignee).ifPresent(assignee -> node.put("assignee", assignee.user.loginId)); Optional.ofNullable(issue.milestone).ifPresent(milestone -> node.put("milestone", milestone.title)); Optional.ofNullable(issue.milestone).ifPresent(milestone -> node.put("milestoneId", milestone.id)); node.put("closed", issue.isClosed()); ObjectNode issueJson = Json.newObject(); issueJson.put("issue", node); issueJson.put("comments", toJson(composeCommentsJson(issue, originalIssueLink, ResourceType.ISSUE_COMMENT))); return issueJson; } public static List<ObjectNode> composeCommentsJson(AbstractPosting posting, String orgLink, ResourceType type) { List<ObjectNode> comments = new ArrayList<>(); for (Comment comment : posting.getComments()) { StringBuilder sb = new StringBuilder(); ObjectNode commentNode = Json.newObject(); commentNode.put("created_at", LocalDateTime.ofInstant(comment.createdDate.toInstant(), ZoneId.systemDefault()).format(formatter)); if(usingWikiCommitForAttachment()){ sb.append(addOriginalAuthorName( relativeLinksToWikiCommitPath(comment.contents), comment.authorLoginId, comment.authorName, "코멘트", orgLink + "#comment-" + comment.id)); sb = addAttachmentsStringUsingWikiCommit(sb, type, comment.id.toString()); } else { sb.append(addOriginalAuthorName( relativeLinksToAbsolutePath(comment.contents), comment.authorLoginId, comment.authorName, "코멘트", orgLink + "#comment-" + comment.id)); sb = addAttachmentsString(sb, type, comment.id.toString()); } commentNode.put("body", sb.toString()); comments.add(commentNode); } return comments; } public static List<ObjectNode> composePlainCommentsJson(AbstractPosting posting, ResourceType type) { List<ObjectNode> comments = new ArrayList<>(); for (Comment comment : posting.getComments()) { ObjectNode commentNode = Json.newObject(); commentNode.put("id", comment.id); commentNode.put("type", comment.asResource().getType().toString()); commentNode.put("authorId", comment.authorLoginId); commentNode.put("authorName", comment.authorName); commentNode.put("created_at",comment.createdDate.getTime()); commentNode.put("body", comment.contents); List<Attachment> attachments = Attachment.findByContainer(comment.asResource()); if(attachments.size() > 0) { commentNode.put("attachments", toJson(attachments)); } comments.add(commentNode); } return comments; } private static void gatheringUserProjects(Set<Project> targetProjects) { User worker = UserApp.currentUser(); targetProjects.addAll(worker.projectUser.stream(). filter(projectUser -> ProjectUser.isAllowedToSettings(worker.loginId, projectUser.project)) .map(projectUser -> projectUser.project).collect(Collectors.toList())); } private static void getheringOrgProjects(Set<Project> targetProjects) { User worker = UserApp.currentUser(); for (OrganizationUser organizationUser : OrganizationUser.findByAdmin(worker.id)) { targetProjects.addAll(organizationUser.organization.projects); } } }