[feature]support sort by id,name,passing rate,frequency,solution count

hongjinfeng · hongjinfeng · commit 4c7c52a1e486 · 2021-05-20T11:29:59.000+08:00
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/AbstractSortAction.java b/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/AbstractSortAction.java
@@ -1,11 +1,46 @@
 package com.shuzijun.leetcode.plugin.actions.tree;
 
 import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.shuzijun.leetcode.plugin.model.Question;
+import com.shuzijun.leetcode.plugin.utils.DataKeys;
+import com.shuzijun.leetcode.plugin.window.WindowFactory;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.*;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.MutableTreeNode;
+import javax.swing.tree.TreeNode;
+import java.util.Enumeration;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
 
 /**
  * @author hongjinfeng
  * @date 2021/5/19 4:32 下午
  */
 public abstract class AbstractSortAction extends AnAction {
 
+    @Override
+    public void actionPerformed(@NotNull AnActionEvent anActionEvent) {
+        JTree tree = WindowFactory.getDataContext(Objects.requireNonNull(anActionEvent.getProject())).getData(DataKeys.LEETCODE_PROJECTS_TREE);
+        assert tree != null;
+        DefaultMutableTreeNode note = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
+        Enumeration<TreeNode> children = note.children();
+        List<MutableTreeNode> childrenForSort = new LinkedList<>();
+        while (children.hasMoreElements()) {
+            childrenForSort.add((MutableTreeNode) children.nextElement());
+        }
+        Question tag = (Question) note.getUserObject();
+        sortChildren(tag, childrenForSort);
+        note.setUserObject(tag);
+        note.removeAllChildren();
+        for (TreeNode treeNode : childrenForSort) {
+            note.add((MutableTreeNode) treeNode);
+        }
+        tree.updateUI();
+    }
+
+    public abstract void sortChildren(Question tag, List<MutableTreeNode> childrenForSort);
 }
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByDifficultyAction.java b/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByDifficultyAction.java
@@ -0,0 +1,26 @@
+package com.shuzijun.leetcode.plugin.actions.tree;
+
+import com.shuzijun.leetcode.plugin.model.Question;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.MutableTreeNode;
+import java.util.List;
+
+/**
+ * @author hongjinfeng
+ * @date 2021/5/20 9:42 上午
+ */
+public class SortByDifficultyAction extends AbstractSortAction {
+
+    @Override
+    public void sortChildren(Question tag, List<MutableTreeNode> childrenForSort) {
+        childrenForSort.sort((o1, o2) -> {
+            DefaultMutableTreeNode item1 = (DefaultMutableTreeNode) o1;
+            Question question1 = (Question) item1.getUserObject();
+            DefaultMutableTreeNode item2 = (DefaultMutableTreeNode) o2;
+            Question question2 = (Question) item2.getUserObject();
+            return tag.getLevelSortTrend() * (question1.getLevel() - question2.getLevel());
+        });
+        tag.setLevelSortTrend(-tag.getLevelSortTrend());
+    }
+}
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByIdAction.java b/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByIdAction.java
@@ -0,0 +1,36 @@
+package com.shuzijun.leetcode.plugin.actions.tree;
+
+import com.shuzijun.leetcode.plugin.model.Question;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.MutableTreeNode;
+import java.util.List;
+
+/**
+ * @author hongjinfeng
+ * @date 2021/5/20 9:40 上午
+ */
+public class SortByIdAction extends AbstractSortAction {
+
+    @Override
+    public void sortChildren(Question tag, List<MutableTreeNode> childrenForSort) {
+        childrenForSort.sort((o1, o2) -> {
+            DefaultMutableTreeNode item1 = (DefaultMutableTreeNode) o1;
+            Question question1 = (Question) item1.getUserObject();
+            DefaultMutableTreeNode item2 = (DefaultMutableTreeNode) o2;
+            Question question2 = (Question) item2.getUserObject();
+            int i = Integer.MAX_VALUE;
+            try {
+                i = Integer.parseInt(question1.getFrontendQuestionId());
+            } catch (Exception ignored) {
+            }
+            int j = Integer.MAX_VALUE;
+            try {
+                j = Integer.parseInt(question2.getFrontendQuestionId());
+            } catch (Exception ignored) {
+            }
+            return tag.getIdSortTrend() * (i - j);
+        });
+        tag.setIdSortTrend(-tag.getIdSortTrend());
+    }
+}
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByNameAction.java b/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByNameAction.java
@@ -0,0 +1,26 @@
+package com.shuzijun.leetcode.plugin.actions.tree;
+
+import com.shuzijun.leetcode.plugin.model.Question;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.MutableTreeNode;
+import java.util.List;
+
+/**
+ * @author hongjinfeng
+ * @date 2021/5/20 9:41 上午
+ */
+public class SortByNameAction extends AbstractSortAction {
+
+    @Override
+    public void sortChildren(Question tag, List<MutableTreeNode> childrenForSort) {
+        childrenForSort.sort((o1, o2) -> {
+            DefaultMutableTreeNode item1 = (DefaultMutableTreeNode) o1;
+            Question question1 = (Question) item1.getUserObject();
+            DefaultMutableTreeNode item2 = (DefaultMutableTreeNode) o2;
+            Question question2 = (Question) item2.getUserObject();
+            return tag.getNameSortTrend() * (question1.getTitle().compareTo(question2.getTitle()));
+        });
+        tag.setNameSortTrend(-tag.getNameSortTrend());
+    }
+}
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByOccurrenceFrequencyAction.java b/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByOccurrenceFrequencyAction.java
@@ -0,0 +1,26 @@
+package com.shuzijun.leetcode.plugin.actions.tree;
+
+import com.shuzijun.leetcode.plugin.model.Question;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.MutableTreeNode;
+import java.util.List;
+
+/**
+ * @author hongjinfeng
+ * @date 2021/5/20 9:43 上午
+ */
+public class SortByOccurrenceFrequencyAction extends AbstractSortAction{
+
+    @Override
+    public void sortChildren(Question tag, List<MutableTreeNode> childrenForSort) {
+        childrenForSort.sort((o1, o2) -> {
+            DefaultMutableTreeNode item1 = (DefaultMutableTreeNode) o1;
+            Question question1 = (Question) item1.getUserObject();
+            DefaultMutableTreeNode item2 = (DefaultMutableTreeNode) o2;
+            Question question2 = (Question) item2.getUserObject();
+            return tag.getOccurrenceFrequencySortTrend() * (question1.getOccurrenceFrequency().compareTo(question2.getOccurrenceFrequency()));
+        });
+        tag.setOccurrenceFrequencySortTrend(-tag.getOccurrenceFrequencySortTrend());
+    }
+}
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByPassRateAction.java b/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortByPassRateAction.java
@@ -0,0 +1,28 @@
+package com.shuzijun.leetcode.plugin.actions.tree;
+
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.shuzijun.leetcode.plugin.model.Question;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.MutableTreeNode;
+import java.util.List;
+
+/**
+ * @author hongjinfeng
+ * @date 2021/5/20 9:41 上午
+ */
+public class SortByPassRateAction extends AbstractSortAction{
+
+    @Override
+    public void sortChildren(Question tag, List<MutableTreeNode> childrenForSort) {
+        childrenForSort.sort((o1, o2) -> {
+            DefaultMutableTreeNode item1 = (DefaultMutableTreeNode) o1;
+            Question question1 = (Question) item1.getUserObject();
+            DefaultMutableTreeNode item2 = (DefaultMutableTreeNode) o2;
+            Question question2 = (Question) item2.getUserObject();
+            return tag.getPassingRateSortTrend() * (question1.getPassingRate().compareTo(question2.getPassingRate()));
+        });
+        tag.setPassingRateSortTrend(-tag.getPassingRateSortTrend());
+    }
+}
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortBySolutionAction.java b/src/main/java/com/shuzijun/leetcode/plugin/actions/tree/SortBySolutionAction.java
@@ -1,20 +1,10 @@
 package com.shuzijun.leetcode.plugin.actions.tree;
 
-import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.shuzijun.leetcode.plugin.model.Question;
-import com.shuzijun.leetcode.plugin.utils.DataKeys;
-import com.shuzijun.leetcode.plugin.window.WindowFactory;
-import org.jetbrains.annotations.NotNull;
 
-import javax.swing.*;
 import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.MutableTreeNode;
-import javax.swing.tree.TreeNode;
-import java.util.Comparator;
-import java.util.Enumeration;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Objects;
 
 /**
  * @author hongjinfeng
@@ -23,16 +13,7 @@
 public class SortBySolutionAction extends AbstractSortAction {
 
     @Override
-    public void actionPerformed(@NotNull AnActionEvent anActionEvent) {
-        JTree tree = WindowFactory.getDataContext(Objects.requireNonNull(anActionEvent.getProject())).getData(DataKeys.LEETCODE_PROJECTS_TREE);
-        assert tree != null;
-        DefaultMutableTreeNode note = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
-        Enumeration<TreeNode> children = note.children();
-        List<TreeNode> childrenForSort = new LinkedList<>();
-        while (children.hasMoreElements()) {
-            childrenForSort.add(children.nextElement());
-        }
-        Question tag = (Question) note.getUserObject();
+    public void sortChildren(Question tag, List<MutableTreeNode> childrenForSort) {
         childrenForSort.sort((o1, o2) -> {
             DefaultMutableTreeNode item1 = (DefaultMutableTreeNode) o1;
             Question question1 = (Question) item1.getUserObject();
@@ -41,11 +22,5 @@ public void actionPerformed(@NotNull AnActionEvent anActionEvent) {
             return tag.getSolutionSortTrend() * (question1.getTotalSolutionCount() - question2.getTotalSolutionCount());
         });
         tag.setSolutionSortTrend(-tag.getSolutionSortTrend());
-        note.setUserObject(tag);
-        note.removeAllChildren();
-        for (TreeNode treeNode : childrenForSort) {
-            note.add((MutableTreeNode) treeNode);
-        }
-        tree.updateUI();
     }
 }
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/listener/TreeMouseListener.java b/src/main/java/com/shuzijun/leetcode/plugin/listener/TreeMouseListener.java
@@ -57,7 +57,7 @@ public void run(@NotNull ProgressIndicator progressIndicator) {
                         }
                     });
                 }
-            } else if (Constant.NODETYPE_TAG.equals(question.getNodeType())) {
+            } else if (Constant.NODETYPE_TAG.equals(question.getNodeType()) || Constant.NODETYPE_PROBLEMS.equals(question.getNodeType())) {
                 if (e.getButton() == 3) { //鼠标右键
                     final ActionManager actionManager = ActionManager.getInstance();
                     final ActionGroup actionGroup = (ActionGroup) actionManager.getAction("leetcode.editor.tree.menu");
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/manager/QuestionManager.java b/src/main/java/com/shuzijun/leetcode/plugin/manager/QuestionManager.java
@@ -208,13 +208,15 @@ private static List<Question> parseQuestion(String str) {
                 question.setLeaf(Boolean.TRUE);
                 question.setQuestionId(object.getJSONObject("stat").getString("question_id"));
                 question.setFrontendQuestionId(object.getJSONObject("stat").getString("frontend_question_id"));
+                question.setTotalSolutionCount(object.getJSONObject("stat").getInteger("total_column_articles"));
+                question.setPassingRate(object.getJSONObject("stat").getDouble("total_acs")/object.getJSONObject("stat").getInteger("total_submitted"));
                 try {
                     if (object.getBoolean("paid_only") && isPremium) {
                         question.setStatus(object.getBoolean("paid_only") ? "lock" : null);
                     } else {
                         question.setStatus(object.get("status") == null ? "" : object.getString("status"));
                     }
-                    question.setTotalSolutionCount(object.getJSONObject("stat").getInteger("total_column_articles"));
+                    question.setOccurrenceFrequency(object.getDouble("frequency"));
                 } catch (Exception ee) {
                     question.setStatus("");
                 }
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/manager/ViewManager.java b/src/main/java/com/shuzijun/leetcode/plugin/manager/ViewManager.java
@@ -67,7 +67,9 @@ public String apply(Question question) {
         DefaultTreeModel treeMode = (DefaultTreeModel) tree.getModel();
         DefaultMutableTreeNode root = (DefaultMutableTreeNode) treeMode.getRoot();
         root.removeAllChildren();
-        DefaultMutableTreeNode node = new DefaultMutableTreeNode(new Question(String.format("Problems(%d)", questionList.size())));
+        Question problems = new Question(String.format("Problems(%d)", questionList.size()));
+        problems.setNodeType(Constant.NODETYPE_PROBLEMS);
+        DefaultMutableTreeNode node = new DefaultMutableTreeNode(problems);
         root.add(node);
         for (Question q : questionList) {
             node.add(new DefaultMutableTreeNode(q));
@@ -257,7 +259,7 @@ private static void addChild(DefaultMutableTreeNode rootNode, List<Tag> Lists, M
                 Question item = new Question(String.format("%s(%d)",
                         tag.getName(), qCnt));
                 Question parent = (Question) rootNode.getUserObject();
-                if (parent.getTitle().equals(Constant.FIND_TYPE_TAGS)){
+                if (parent.getTitle().equals(Constant.FIND_TYPE_TAGS)) {
                     item.setNodeType(Constant.NODETYPE_TAG);
                 }
                 DefaultMutableTreeNode tagNode = new DefaultMutableTreeNode(item);
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/model/Constant.java b/src/main/java/com/shuzijun/leetcode/plugin/model/Constant.java
@@ -32,6 +32,7 @@ public class Constant {
     public static final String NODETYPE_CHAPTER = "chapter";
     public static final String NODETYPE_ITEM = "item";
     public static final String NODETYPE_TAG = "tag";
+    public static final String NODETYPE_PROBLEMS = "problems";
     /**
      * 探索下列表内容
      */
diff --git a/src/main/java/com/shuzijun/leetcode/plugin/model/Question.java b/src/main/java/com/shuzijun/leetcode/plugin/model/Question.java
@@ -42,10 +42,24 @@ public class Question {
      */
     private String articleSlug;
 
+    private Double occurrenceFrequency = 0d;
+
+    private Double passingRate = 0d;
+
     private Integer totalSolutionCount;
 
     private Integer solutionSortTrend = 1;
 
+    private Integer idSortTrend = 1;
+
+    private Integer levelSortTrend = 1;
+
+    private Integer nameSortTrend = 1;
+
+    private Integer occurrenceFrequencySortTrend = 1;
+
+    private Integer passingRateSortTrend = 1;
+
     public Question() {
 
     }
@@ -211,6 +225,62 @@ public void setSolutionSortTrend(Integer solutionSortTrend) {
         this.solutionSortTrend = solutionSortTrend;
     }
 
+    public Integer getIdSortTrend() {
+        return idSortTrend;
+    }
+
+    public void setIdSortTrend(Integer idSortTrend) {
+        this.idSortTrend = idSortTrend;
+    }
+
+    public Integer getLevelSortTrend() {
+        return levelSortTrend;
+    }
+
+    public void setLevelSortTrend(Integer levelSortTrend) {
+        this.levelSortTrend = levelSortTrend;
+    }
+
+    public Integer getOccurrenceFrequencySortTrend() {
+        return occurrenceFrequencySortTrend;
+    }
+
+    public void setOccurrenceFrequencySortTrend(Integer occurrenceFrequencySortTrend) {
+        this.occurrenceFrequencySortTrend = occurrenceFrequencySortTrend;
+    }
+
+    public Integer getPassingRateSortTrend() {
+        return passingRateSortTrend;
+    }
+
+    public void setPassingRateSortTrend(Integer passingRateSortTrend) {
+        this.passingRateSortTrend = passingRateSortTrend;
+    }
+
+    public Integer getNameSortTrend() {
+        return nameSortTrend;
+    }
+
+    public void setNameSortTrend(Integer nameSortTrend) {
+        this.nameSortTrend = nameSortTrend;
+    }
+
+    public Double getOccurrenceFrequency() {
+        return occurrenceFrequency;
+    }
+
+    public void setOccurrenceFrequency(Double occurrenceFrequency) {
+        this.occurrenceFrequency = occurrenceFrequency;
+    }
+
+    public Double getPassingRate() {
+        return passingRate;
+    }
+
+    public void setPassingRate(Double passingRate) {
+        this.passingRate = passingRate;
+    }
+
     @Override
     public String toString() {
         StringBuffer sb = new StringBuffer();
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public void run(@NotNull ProgressIndicator progressIndicator) {`
`57`	`57`	`}`
`58`	`58`	`});`
`59`	`59`	`}`
`60`		`- } else if (Constant.NODETYPE_TAG.equals(question.getNodeType())) {`
	`60`	`+ } else if (Constant.NODETYPE_TAG.equals(question.getNodeType()) \|\| Constant.NODETYPE_PROBLEMS.equals(question.getNodeType())) {`
`61`	`61`	`if (e.getButton() == 3) { //鼠标右键`
`62`	`62`	`final ActionManager actionManager = ActionManager.getInstance();`
`63`	`63`	`final ActionGroup actionGroup = (ActionGroup) actionManager.getAction("leetcode.editor.tree.menu");`