export class FundInfo {
  name: string;
  code: string;

  constructor(name: string, code: string) {
    this.name = name;
    this.code = code;
  }
}

import { TreeItem } from "vscode";
import { FundInfo } from "./FundInfo";

export class FundTreeItem extends TreeItem {
  constructor(info: FundInfo) {
    super(info.name + info.code);
  }
}

import { TreeDataProvider } from "vscode";
import { FundInfo } from "./FundInfo";
import { FundTreeItem } from "./FundTreeItem";

export class FundTreeDataProvider implements TreeDataProvider<FundInfo> {
  getChildren() {
    console.log("getChildren");

    const f1 = new FundInfo("基金1", "111111");
    const f2 = new FundInfo("基金1", "222222");
    return [f1, f2];
  }

  getTreeItem(element: FundInfo) {
    console.log("getTreeItem");
    return new FundTreeItem(element);
  }
}

  const fundProvider = new FundTreeDataProvider();
  vscode.window.registerTreeDataProvider("fund-favorite", fundProvider);

import { workspace, WorkspaceConfiguration } from "vscode";

export class Config {
  private readonly config: WorkspaceConfiguration;

  constructor(public name: string) {
    this.config = workspace.getConfiguration();
    this.name = name;
  }

  getData(defaultValue: string): string;
  getData(defaultValue: number): number;
  getData(defaultValue: Array<string>): Array<string>;
  getData(defaultValue: Array<number>): Array<number>;
  getData(defaultValue: Array<any>): Array<any>;
  getData(defaultValue: any): any {
    return this.config.get(this.name, defaultValue);
  }

  setData(data: any): void {
    this.config.update(this.name, data, true);
  }
}

import { TreeDataProvider, EventEmitter, Event } from "vscode";
import { FundInfo } from "./FundInfo";
import { FundTreeItem } from "./FundTreeItem";
import { Config } from "./Config";

export class FundTreeDataProvider implements TreeDataProvider<FundInfo> {
  private favConfig: Config;
  refreshEvent: EventEmitter<FundInfo | null>;
  readonly onDidChangeTreeData: Event<FundInfo | null>;

  constructor() {
    this.favConfig = new Config("fund-live.favorites");
    this.refreshEvent = new EventEmitter<FundInfo | null>();
    this.onDidChangeTreeData = this.refreshEvent.event;
  }

  getChildren() {
    const codes = this.favConfig.getData([]);
    const res = codes.map((d, i) => new FundInfo(`基金${i + 1}号`, d));
    return res;
  }

  getTreeItem(element: FundInfo) {
    console.log("getTreeItem");
    return new FundTreeItem(element);
  }

  addCode(code: string) {
    const codes = this.favConfig.getData([]);
    codes.push(code);
    this.favConfig.setData(codes);
  }

  removeCode(code: string) {
    const codes = this.favConfig.getData([]);
    const index = codes.indexOf(code);
    codes.splice(index, 1);
    this.favConfig.setData(codes);
  }

  refresh() {
    console.log("refresh");
    setTimeout(() => {
      this.refreshEvent.fire(null);
    }, 200);
  }
}

import * as vscode from "vscode";
import { FundTreeDataProvider } from "./FundTreeDataProvider";
import { FundInfo } from "./FundInfo";

export function activate(context: vscode.ExtensionContext) {
  console.log('Congratulations, your extension "fund-live" is now active!');

  const fundProvider = new FundTreeDataProvider();
  vscode.window.registerTreeDataProvider("fund-favorite", fundProvider);

  let add = vscode.commands.registerCommand("fund.add", () => {
    async function handler() {
      const code = await inputFund();

      if (code) {
        console.log("input", code);
        fundProvider.addCode(code);
        fundProvider.refresh();
      } else {
        console.log("input empty,ignore.", code);
      }
    }

    handler().then();
  });

  let remove = vscode.commands.registerCommand(
    "fund.item.remove",
    (fund: FundInfo) => {
      fundProvider.removeCode(fund.code);
      fundProvider.refresh();
    }
  );

  let refresh = vscode.commands.registerCommand("fund.refresh", () => {
    fundProvider.refresh();
  });

  context.subscriptions.push(add, refresh, remove);
}

// this method is called when your extension is deactivated
export function deactivate() {}

async function inputFund() {
  const res = await vscode.window.showInputBox({
    value: "",
    valueSelection: [5, -1],
    prompt: "添加基金到自选",
    placeHolder: "Add Fund To Favorite",
    validateInput: (inputCode: string) => {
      const codeArray = inputCode.split(/[\W]/);
      const hasError = codeArray.some((code) => {
        return code !== "" && !/^\d+$/.test(code);
      });

      return hasError ? "基金代码输入有误" : null;
    },
  });

  return res;
}

import * as https from "https";

//  `https://fundgz.1234567.com.cn/js/${code}.js?rt=${time}`;
const urlPrefix = `https://fundgz.1234567.com.cn/js/`;

/**
 * 拼接基金的请求地址和当前时间
 * @param code 基金代码
 */
function urlFull(code: string) {
  const realTime = Date.now();
  const res = urlPrefix + code + ".js?rt=" + realTime;

  return res;
}

/**
 * 获取基金信息
 * @param code 基金代码
 */
export async function show(code: string): Promise<any> {
  return new Promise((resolve, reject) => {
    https.get(urlFull(code), (res) => {
      let buffer: any;

      if (!res || res.statusCode !== 200) {
        reject(new Error("网络请求错误!"));
      }

      res.on("data", (d) => (buffer += d));

      res.on("end", () => {
        const jsonp = buffer.toString("utf8");

        const match = jsonp.match(/jsonpgz\((.+)\)/);
        if (!match || !match[1]) {
          reject(new Error("接口格式错误!"));
        }
        const str = match[1];
        const obj = JSON.parse(str);

        resolve(obj);
      });
    });
  });
}

/**
 * 并行获取多个基金信息
 * @param codes 基金代码数组
 */
export async function total(codes: string[]): Promise<any[]> {
  const parallel: Promise<any>[] = [];
  for (let i = 0; i < codes.length; i++) {
    parallel.push(show(codes[i]));
  }
  const resultArr: any[] = await Promise.all(parallel);

  return resultArr;
}

export class FundInfo {
  /** 基金名称 */
  name: string;
  /** 基金代码 */
  code: string;
  /** 当前净值 */
  now: string;
  /** 昨日净值 */
  lastClose: string;
  /** 涨跌幅 */
  changeRate: string;
  /** 涨跌额 */
  changeAmount: string;

  constructor(
    name: string,
    code: string,
    now: string,
    lastClose: string,
    changeRate: string,
    changeAmount: string
  ) {
    this.name = name;
    this.code = code;
    this.now = now;
    this.lastClose = lastClose;
    this.changeRate = changeRate;
    this.changeAmount = changeAmount;
  }
}

import { TreeItem } from "vscode";
import { FundInfo } from "./FundInfo";

export class FundTreeItem extends TreeItem {
  constructor(info: FundInfo) {
    const rate = Number(info.changeRate);
    const icon = rate >= 0 ? "📈" : "📉";
    const prev = rate >= 0 ? "+" : "-";
    const rage = `${prev}${Math.abs(rate)}%`;

    const title = icon + rage + "\t" + `[${info.code}]${info.name}`;

    /** 构造继承 */
    super(title);

    /** Tooltip鼠标悬停提示 */
    let sliceName = info.name;
    if (sliceName.length > 8) {
      sliceName = `${sliceName.slice(0, 8)}...`;
    }
    const tips = [
      `代码:　${info.code}`,
      `名称:　${sliceName}`,
      `--------------------------`,
      `单位净值:　　　　${info.now}`,
      `涨跌幅:　　　　　${info.changeRate}%`,
      `涨跌额:　　　　　${info.changeAmount}`,
      `昨收:　　　　　　${info.lastClose}`,
    ];

    this.tooltip = tips.join("\r\n");
  }
}

  async getChildren() {
    const codes = this.favConfig.getData([]);
    const funds = await total(codes);
    const res = funds.map(
      (d) =>
        new FundInfo(
          d.name,
          d.fundcode,
          d.gsz,
          d.dwjz,
          d.gszzl,
          (d.gsz - d.dwjz).toFixed(4)
        )
    );

    return res;
  }