Star Problems Extension && All Problems Category

package.json

@@ -94,6 +94,11 @@
                 "title": "Show Problem",
                 "category": "LeetCode"
             },
+            {
+                "command": "leetcode.starProblem",
+                "title": "Star/Unstar Problem",
+                "category": "LeetCode"
+            },
             {
                 "command": "leetcode.searchProblem",
                 "title": "Search Problem",
@@ -164,12 +169,21 @@
                     "command": "leetcode.showProblem",
                     "when": "view == leetCodeExplorer && viewItem == problem",
                     "group": "leetcode@1"
+                },
+                {
+                    "command": "leetcode.starProblem",
+                    "when": "view == leetCodeExplorer && viewItem == problem",
+                    "group": "leetcode@1"
                 }
             ],
             "commandPalette": [
                 {
                     "command": "leetcode.showProblem",
                     "when": "never"
+                },
+                {
+                    "command": "leetcode.starProblem",
+                    "when": "never"
                 }
             ],
             "explorer/context": [

src/commands/star.ts

@@ -0,0 +1,19 @@
+// Copyright (c) jdneo. All rights reserved.
+// Licensed under the MIT license.
+
+import { LeetCodeNode } from "../explorer/LeetCodeNode";
+import { LeetCodeTreeDataProvider } from "../explorer/LeetCodeTreeDataProvider";
+import { leetCodeExecutor } from "../leetCodeExecutor";
+import { IProblem } from "../shared";
+import { DialogType, promptForOpenOutputChannel } from "../utils/uiUtils";
+
+export async function starProblem(provider: LeetCodeTreeDataProvider, node: LeetCodeNode): Promise<void> {
+    try {
+        const problem: IProblem = Object.assign({}, node.nodeData, {
+            isFavorite: await leetCodeExecutor.starProblem(node, !node.isFavorite),
+        });
+        provider.updateProblem(problem);
+    } catch (error) {
+        await promptForOpenOutputChannel("Failed to star the problem. Please open the output channel for details.", DialogType.error);
+    }
+}

src/explorer/LeetCodeNode.ts

@@ -6,17 +6,26 @@ import { IProblem, ProblemState } from "../shared";
 export class LeetCodeNode {
     constructor(private data: IProblem, private parentNodeName: string, private isProblemNode: boolean = true) { }
 
+    public get nodeData(): IProblem {
+        return this.data;
+    }
+
+    public get isProblem(): boolean {
+        return this.isProblemNode;
+    }
+
+    public get parentName(): string {
+        return this.parentNodeName;
+    }
+
     public get locked(): boolean {
         return this.data.locked;
     }
+
     public get name(): string {
         return this.data.name;
     }
 
-    public get state(): ProblemState {
-        return this.data.state;
-    }
-
     public get id(): string {
         return this.data.id;
     }
@@ -37,15 +46,11 @@ export class LeetCodeNode {
         return this.data.companies;
     }
 
-    public get isFavorite(): boolean {
-        return this.data.isFavorite;
-    }
-
-    public get isProblem(): boolean {
-        return this.isProblemNode;
+    public get state(): ProblemState {
+        return this.data.state;
     }
 
-    public get parentName(): string {
-        return this.parentNodeName;
+    public get isFavorite(): boolean {
+        return this.data.isFavorite;
     }
 }

src/explorer/LeetCodeTreeDataProvider.ts

@@ -13,6 +13,8 @@ import { LeetCodeNode } from "./LeetCodeNode";
 
 export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCodeNode> {
 
+    private allProblems: Map<string, IProblem>; // store reference of all problems.
+
     private treeData: {
         Difficulty: Map<string, IProblem[]>,
         Tag: Map<string, IProblem[]>,
@@ -31,6 +33,14 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
         this.onDidChangeTreeDataEvent.fire();
     }
 
+    public async updateProblem(problem: IProblem): Promise<void> {
+        if (this.allProblems.has(problem.id)) {
+            this.updateTreeDataByProblem(problem); // only modify the content of tree data, problem is not updated.
+            Object.assign(this.allProblems.get(problem.id), problem); // update problem, where reference is preserved.
+            this.onDidChangeTreeDataEvent.fire();
+        }
+    }
+
     public getTreeItem(element: LeetCodeNode): vscode.TreeItem | Thenable<vscode.TreeItem> {
         if (element.id === "notSignIn") {
             return {
@@ -46,7 +56,7 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
 
         const idPrefix: number = Date.now();
         return {
-            label: element.isProblem ? `[${element.id}] ${element.name}` : element.name,
+            label: element.isProblem ? `[${element.id}] ${element.name} ${element.isFavorite ? "♥" : ""}` : element.name,
             tooltip: this.getSubCategoryTooltip(element),
             id: `${idPrefix}.${element.parentName}.${element.id}`,
             collapsibleState: element.isProblem ? vscode.TreeItemCollapsibleState.None : vscode.TreeItemCollapsibleState.Collapsed,
@@ -66,6 +76,10 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
         }
         if (!element) { // Root view
             return [
+                new LeetCodeNode(Object.assign({}, defaultProblem, {
+                    id: Category.All,
+                    name: Category.All,
+                }), "ROOT", false),
                 new LeetCodeNode(Object.assign({}, defaultProblem, {
                     id: Category.Difficulty,
                     name: Category.Difficulty,
@@ -85,6 +99,9 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
             ];
         } else {
             switch (element.name) { // First-level
+                case Category.All:
+                    const all: IProblem[] = [...this.allProblems.values()];
+                    return all.map((p: IProblem) => new LeetCodeNode(p, Category.All));
                 case Category.Favorite:
                     const nodes: IProblem[] = this.treeData[Category.Favorite];
                     return nodes.map((p: IProblem) => new LeetCodeNode(p, Category.Favorite));
@@ -100,13 +117,15 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
 
     private async getProblemData(): Promise<void> {
         // clear cache
+        this.allProblems = new Map<string, IProblem>();
         this.treeData = {
             Difficulty: new Map<string, IProblem[]>(),
             Tag: new Map<string, IProblem[]>(),
             Company: new Map<string, IProblem[]>(),
             Favorite: [],
         };
         for (const problem of await list.listProblems()) {
+            this.allProblems.set(problem.id, problem);
             // Add favorite problem, no matter whether it is solved.
             if (problem.isFavorite) {
                 this.treeData[Category.Favorite].push(problem);
@@ -168,12 +187,26 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
     }
 
     private getSubCategoryTooltip(element: LeetCodeNode): string {
-        // return '' unless it is a sub-category node
-        if (element.isProblem || !this.treeData[element.parentName]) {
+        // return '' if it does not directly hold problems.
+        if (element.isProblem) {
             return "";
         }
-
-        const problems: IProblem[] = this.treeData[element.parentName].get(element.id);
+        let problems: IProblem[];
+        switch (element.name) {
+            case Category.Difficulty:
+            case Category.Tag:
+            case Category.Company:
+                return "";
+            case Category.All:
+                problems = [...this.allProblems.values()];
+                break;
+            case Category.Favorite:
+                problems = this.treeData[Category.Favorite];
+                break;
+            default:
+                problems = this.treeData[element.parentName].get(element.id);
+                break;
+        }
 
         let acceptedNum: number = 0;
         let failedNum: number = 0;
@@ -197,6 +230,18 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
         ].join(os.EOL);
     }
 
+    private updateTreeDataByProblem(problem: IProblem): void {
+        const origin: IProblem | undefined = this.allProblems.get(problem.id);
+        if (origin && origin.isFavorite !== problem.isFavorite) {
+            const problemIndex: number = this.treeData.Favorite.findIndex((p: LeetCodeNode) => Number(p.id) >= Number(problem.id));
+            if (problem.isFavorite) {
+                this.treeData.Favorite.splice(problemIndex, 0, origin); // insert original problem's reference as favorite
+            } else {
+                this.treeData.Favorite.splice(problemIndex, 1); // delete favorite
+            }
+        }
+    }
+
     private addProblemToTreeData(problem: IProblem): void {
         this.putProblemToMap(this.treeData.Difficulty, problem.difficulty, problem);
         for (const tag of problem.tags) {

src/extension.ts

@@ -8,6 +8,7 @@ import { switchDefaultLanguage } from "./commands/language";
 import * as plugin from "./commands/plugin";
 import * as session from "./commands/session";
 import * as show from "./commands/show";
+import * as star from "./commands/star";
 import * as submit from "./commands/submit";
 import * as test from "./commands/test";
 import { LeetCodeNode } from "./explorer/LeetCodeNode";
@@ -44,6 +45,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
         vscode.commands.registerCommand("leetcode.selectSessions", () => session.selectSession()),
         vscode.commands.registerCommand("leetcode.createSession", () => session.createSession()),
         vscode.commands.registerCommand("leetcode.showProblem", (node: LeetCodeNode) => show.showProblem(node)),
+        vscode.commands.registerCommand("leetcode.starProblem", (node: LeetCodeNode) => star.starProblem(leetCodeTreeDataProvider, node)),
         vscode.commands.registerCommand("leetcode.searchProblem", () => show.searchProblem()),
         vscode.commands.registerCommand("leetcode.refreshExplorer", () => leetCodeTreeDataProvider.refresh()),
         vscode.commands.registerCommand("leetcode.testSolution", (uri?: vscode.Uri) => test.testSolution(uri)),

src/leetCodeExecutor.ts

@@ -87,6 +87,16 @@ class LeetCodeExecutor {
         return filePath;
     }
 
+    public async starProblem(node: IProblem, markStarred: boolean): Promise<boolean> {
+        let description: string = "";
+        if (markStarred) {
+            description = await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "star", node.id]);
+        } else {
+            description = await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "star", node.id, "-d"]);
+        }
+        return description.includes("♥");
+    }
+
     public async listSessions(): Promise<string> {
         return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "session"]);
     }

src/shared.ts

@@ -86,6 +86,7 @@ export const defaultProblem: IProblem = {
 };
 
 export enum Category {
+    All = "All Problems",
     Difficulty = "Difficulty",
     Tag = "Tag",
     Company = "Company",