Browse Source

temp

pull/7/head
cweijan 6 years ago
parent
commit
8fa85dc08d
  1. 2
      package.json
  2. 48
      resources/webview/changeTable.html
  3. 48
      resources/webview/createTable.html
  4. 49
      resources/webview/result.html
  5. 3
      resources/webview/test.css
  6. 10947
      resources/webview/vue.js
  7. 2
      src/common/appInsightsClient.ts
  8. 4
      src/database/DatabaseCache.ts
  9. 69
      src/database/SqlViewManager.ts
  10. 278
      src/database/utility.ts
  11. 7
      src/extension.ts
  12. 4
      src/model/columnNode.ts
  13. 4
      src/model/connectionNode.ts
  14. 4
      src/model/databaseNode.ts
  15. 4
      src/model/tableNode.ts
  16. 2
      src/provider/CompletionManager.ts
  17. 2
      src/provider/CompletionProvider.ts
  18. 2
      src/provider/mysqlTreeDataProvider.ts

2
package.json

@ -2,7 +2,7 @@
"name": "vscode-mysql-manager",
"displayName": "MySQL",
"description": "MySQL management tool",
"version": "1.4.0",
"version": "1.4.1",
"publisher": "cweijan",
"icon": "logo.png",
"engines": {

48
resources/webview/changeTable.html

@ -0,0 +1,48 @@
<html>
<head>
<title>result</title>
<link rel="stylesheet" href="${webviewPath}/test.css">
<script src="${webviewPath}/vue.js"></script>
</head>
<body>
<div id="app">
<div v-for="str in list" v-text="str"><br></div>
<span class="test">hello</span>
</div>
</body>
<script>
const vue=new Vue({
el:'#app',
data:{
list:["test",'hehe']
}
})
const vscode = acquireVsCodeApi();
document.write("test")
document.write("${webviewPath}/style.css")
console.log('test')
vscode.postMessage({
command: 'webview.table.change',
text: "test text"
})
window.addEventListener('message', event => {
const message = event.data; // The JSON data our extension sent
vue.list.push(message)
// console.log(message)
// document.write(message)
// switch (message.command) {
// case 'mysql.newQuery':
// count = Math.ceil(count * 0.5);
// counter.textContent = count;
// document.write(count)
// break;
// }
});
</script>
</html>

48
resources/webview/createTable.html

@ -0,0 +1,48 @@
<html>
<head>
<title>result</title>
<link rel="stylesheet" href="${webviewPath}/test.css">
<script src="${webviewPath}/vue.js"></script>
</head>
<body>
<div id="app">
<div v-for="str in list" v-text="str"><br></div>
<span class="test">hello</span>
</div>
</body>
<script>
const vue=new Vue({
el:'#app',
data:{
list:["test",'hehe']
}
})
const vscode = acquireVsCodeApi();
document.write("test")
document.write("${webviewPath}/style.css")
console.log('test')
vscode.postMessage({
command: 'webview.table.change',
text: "test text"
})
window.addEventListener('message', event => {
const message = event.data; // The JSON data our extension sent
vue.list.push(message)
// console.log(message)
// document.write(message)
// switch (message.command) {
// case 'mysql.newQuery':
// count = Math.ceil(count * 0.5);
// counter.textContent = count;
// document.write(count)
// break;
// }
});
</script>
</html>

49
resources/webview/result.html

@ -0,0 +1,49 @@
<html>
<head>
<title>result</title>
<link rel="stylesheet" href="${webviewPath}/test.css">
<script src="${webviewPath}/vue.js"></script>
</head>
<body>
<div id="app">
<div v-for="str in list" v-text="str"><br></div>
<span class="test">hello</span>
</div>
</body>
<script>
const vue=new Vue({
el:'#app',
data:{
list:["test",'hehe']
}
})
const vscode = acquireVsCodeApi();
document.write("test")
document.write("${webviewPath}/style.css")
console.log('test')
vscode.postMessage({
command: 'webview.table.change',
text: "test text"
})
window.addEventListener('message', event => {
// vscode.setState({ count });
// vscode.getState()
const message = event.data; // The JSON data our extension sent
vue.list.push(message)
// console.log(message)
// document.write(message)
// switch (message.command) {
// case 'mysql.newQuery':
// count = Math.ceil(count * 0.5);
// counter.textContent = count;
// document.write(count)
// break;
// }
});
</script>
</html>

3
resources/webview/test.css

@ -0,0 +1,3 @@
.test{
color: red;
}

10947
resources/webview/vue.js
File diff suppressed because it is too large
View File

2
src/common/appInsightsClient.ts

@ -1,6 +1,6 @@
"use strict";
import appInsights = require("applicationinsights");
import { Utility } from "./utility";
import { Utility } from "../database/utility";
export class AppInsightsClient {
public static sendEvent(eventName: string, properties?: { [key: string]: string; }): void {

4
src/common/DatabaseCache.ts → src/database/DatabaseCache.ts

@ -2,8 +2,8 @@ import { DatabaseNode } from "../model/databaseNode";
import { TableNode } from "../model/tableNode";
import { ColumnNode } from "../model/columnNode";
import { ExtensionContext, TreeItemCollapsibleState } from "vscode";
import { CacheKey, ModelType } from "./constants";
import { OutputChannel } from "./outputChannel";
import { CacheKey, ModelType } from "../common/constants";
import { OutputChannel } from "../common/outputChannel";
import { INode } from "../model/INode";
export class DatabaseCache {

69
src/database/SqlViewManager.ts

@ -0,0 +1,69 @@
import { WebviewPanel } from "vscode";
"use strict";
import * as fs from "fs";
import * as vscode from "vscode";
import { OutputChannel } from "../common/outputChannel";
export class ViewOption {
viewPath: string;
viewTitle: string;
viewId: string;
/**
* receive webview send message
*/
receiveListener?: (message: any) => {}
disposeListener?: (message: any) => {}
}
export class SqlViewManager {
static resultWebviewPanel: WebviewPanel
static tableEditWebviewPanel: WebviewPanel
static tableCreateWebviewPanel: WebviewPanel
static extensionPath: string
public static initExtesnsionPath(extensionPath: string) {
this.extensionPath = extensionPath
}
public static showQueueResult(data:any,title:string){
this.createWebviewPanel({
viewId: "queryResult",
viewPath: "result",
viewTitle: title
}).then(webviewPanel=>{
webviewPanel.webview.postMessage({data:data})
})
}
private static createWebviewPanel(viewOption: ViewOption): Promise<WebviewPanel> {
return new Promise((resolve, reject) => {
fs.readFile(`${this.extensionPath}/resources/webview/${viewOption.viewPath}.html`, 'utf8', async (err, data) => {
if (err) {
OutputChannel.appendLine(err)
reject(err)
return;
}
const webviewPanel = await vscode.window.createWebviewPanel(
viewOption.viewId,
viewOption.viewTitle,
vscode.ViewColumn.One,
{ enableScripts: true }
);
webviewPanel.webview.html = data.replace(/\$\{webviewPath\}/gi,
vscode.Uri.file(`${this.extensionPath}/resources/webview`)
.with({ scheme: 'vscode-resource' }).toString())
webviewPanel.webview.onDidReceiveMessage(viewOption.receiveListener);
webviewPanel.onDidDispose(viewOption.disposeListener)
resolve(webviewPanel)
})
})
}
}

278
src/common/utility.ts → src/database/utility.ts

@ -1,140 +1,138 @@
"use strict";
import * as fs from "fs";
import * as mysql from "mysql";
import * as vscode from "vscode";
import { IConnection } from "../model/connection";
import { AppInsightsClient } from "./appInsightsClient";
import { Global } from "./global";
import { OutputChannel } from "./outputChannel";
export class Utility {
public static readonly maxTableCount = Utility.getConfiguration().get<number>("maxTableCount");
public static getConfiguration(): vscode.WorkspaceConfiguration {
return vscode.workspace.getConfiguration("vscode-mysql");
}
public static queryPromise<T>(connection, sql: string): Promise<T> {
return new Promise((resolve, reject) => {
OutputChannel.appendLine(`Execute SQL:${sql}`)
connection.query(sql, (err, rows) => {
if (err) {
OutputChannel.appendLine(err)
reject("Error: " + err.message);
} else {
resolve(rows);
}
});
connection.end();
});
}
public static async runQuery(sql?: string, connectionOptions?: IConnection) {
AppInsightsClient.sendEvent("runQuery.start");
if (!sql && !vscode.window.activeTextEditor) {
vscode.window.showWarningMessage("No SQL file selected");
AppInsightsClient.sendEvent("runQuery.noFile");
return;
}
if (!connectionOptions && !Global.activeConnection) {
const hasActiveConnection = await Utility.hasActiveConnection();
if (!hasActiveConnection) {
vscode.window.showWarningMessage("No MySQL Server or Database selected");
AppInsightsClient.sendEvent("runQuery.noMySQL");
return;
}
}
if (!sql) {
const activeTextEditor = vscode.window.activeTextEditor;
const selection = activeTextEditor.selection;
if (selection.isEmpty) {
sql = activeTextEditor.document.getText();
} else {
sql = activeTextEditor.document.getText(selection);
}
}
connectionOptions = connectionOptions ? connectionOptions : Global.activeConnection;
connectionOptions.multipleStatements = true;
const connection = Utility.createConnection(connectionOptions);
connection.query(sql, (err, rows) => {
if (Array.isArray(rows)) {
if (rows.some(((row) => Array.isArray(row)))) {
rows.forEach((row, index) => {
if (Array.isArray(row)) {
Utility.showQueryResult(row);
} else {
OutputChannel.appendLine(JSON.stringify(row));
}
});
} else {
Utility.showQueryResult(rows);
}
} else {
OutputChannel.appendLine(JSON.stringify(rows));
}
if (err) {
OutputChannel.appendLine(err);
AppInsightsClient.sendEvent("runQuery.end", { Result: "Fail", ErrorMessage: err });
} else {
AppInsightsClient.sendEvent("runQuery.end", { Result: "Success" });
}
});
connection.end();
}
public static async createSQLTextDocument(sql: string = "") {
const textDocument = await vscode.workspace.openTextDocument({ content: sql, language: "sql" });
return vscode.window.showTextDocument(textDocument);
}
public static createConnection(connectionOptions: IConnection): any {
const newConnectionOptions: any = Object.assign({}, connectionOptions);
if (connectionOptions.certPath && fs.existsSync(connectionOptions.certPath)) {
newConnectionOptions.ssl = {
ca: fs.readFileSync(connectionOptions.certPath),
};
}
return mysql.createConnection(newConnectionOptions);
}
private static getPreviewUri(data) {
const uri = vscode.Uri.parse("sqlresult://mysql/data");
return uri.with({ query: data });
}
private static showQueryResult(data) {
// const panel = vscode.window.createWebviewPanel(
// 'catCoding',
// 'Cat Coding',
// vscode.ViewColumn.One,
// {}
// );
const uri = Utility.getPreviewUri(JSON.stringify(data))
vscode.commands.executeCommand('markdown.showPreview', uri)
vscode.commands.executeCommand('m2arkdown.preview.refresh', uri);
}
private static async hasActiveConnection(): Promise<boolean> {
let count = 5;
while (!Global.activeConnection && count > 0) {
await Utility.sleep(100);
count--;
}
return !!Global.activeConnection;
}
private static sleep(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
}
"use strict";
import * as fs from "fs";
import * as mysql from "mysql";
import * as path from 'path';
import * as vscode from "vscode";
import { IConnection } from "../model/connection";
import { AppInsightsClient } from "../common/appInsightsClient";
import { Global } from "../common/global";
import { OutputChannel } from "../common/outputChannel";
import { resolve } from "url";
import { SqlViewManager } from "./SqlViewManager";
export class Utility {
public static readonly maxTableCount = Utility.getConfiguration().get<number>("maxTableCount");
public static getConfiguration(): vscode.WorkspaceConfiguration {
return vscode.workspace.getConfiguration("vscode-mysql");
}
public static queryPromise<T>(connection, sql: string): Promise<T> {
return new Promise((resolve, reject) => {
OutputChannel.appendLine(`Execute SQL:${sql}`)
connection.query(sql, (err, rows) => {
if (err) {
OutputChannel.appendLine(err)
reject("Error: " + err.message);
} else {
resolve(rows);
}
});
connection.end();
});
}
public static async runQuery(sql?: string, connectionOptions?: IConnection) {
AppInsightsClient.sendEvent("runQuery.start");
if (!sql && !vscode.window.activeTextEditor) {
vscode.window.showWarningMessage("No SQL file selected");
AppInsightsClient.sendEvent("runQuery.noFile");
return;
}
if (!connectionOptions && !Global.activeConnection) {
const hasActiveConnection = await Utility.hasActiveConnection();
if (!hasActiveConnection) {
vscode.window.showWarningMessage("No MySQL Server or Database selected");
AppInsightsClient.sendEvent("runQuery.noMySQL");
return;
}
}
if (!sql) {
const activeTextEditor = vscode.window.activeTextEditor;
const selection = activeTextEditor.selection;
if (selection.isEmpty) {
sql = activeTextEditor.document.getText();
} else {
sql = activeTextEditor.document.getText(selection);
}
}
connectionOptions = connectionOptions ? connectionOptions : Global.activeConnection;
connectionOptions.multipleStatements = true;
const connection = Utility.createConnection(connectionOptions);
connection.query(sql, (err, rows) => {
if (Array.isArray(rows)) {
if (rows.some(((row) => Array.isArray(row)))) {
rows.forEach((row, index) => {
if (Array.isArray(row)) {
Utility.showQueryResult(row);
} else {
OutputChannel.appendLine(JSON.stringify(row));
}
});
} else {
Utility.showQueryResult(rows);
}
} else {
OutputChannel.appendLine(JSON.stringify(rows));
}
if (err) {
OutputChannel.appendLine(err);
AppInsightsClient.sendEvent("runQuery.end", { Result: "Fail", ErrorMessage: err });
} else {
AppInsightsClient.sendEvent("runQuery.end", { Result: "Success" });
}
});
connection.end();
}
public static async createSQLTextDocument(sql: string = "") {
const textDocument = await vscode.workspace.openTextDocument({ content: sql, language: "sql" });
return vscode.window.showTextDocument(textDocument);
}
public static createConnection(connectionOptions: IConnection): any {
const newConnectionOptions: any = Object.assign({}, connectionOptions);
if (connectionOptions.certPath && fs.existsSync(connectionOptions.certPath)) {
newConnectionOptions.ssl = {
ca: fs.readFileSync(connectionOptions.certPath),
};
}
return mysql.createConnection(newConnectionOptions);
}
private static getPreviewUri(data) {
const uri = vscode.Uri.parse("sqlresult://mysql/data");
return uri.with({ query: data });
}
static webviewPanel: vscode.WebviewPanel;
private static showQueryResult(data) {
SqlViewManager.showQueueResult(data,"test")
};
private static async hasActiveConnection(): Promise<boolean> {
let count = 5;
while (!Global.activeConnection && count > 0) {
await Utility.sleep(100);
count--;
}
return !!Global.activeConnection;
}
private static sleep(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
}

7
src/extension.ts

@ -1,7 +1,7 @@
"use strict";
import * as vscode from "vscode";
import { AppInsightsClient } from "./common/appInsightsClient";
import { Utility } from "./common/utility";
import { Utility } from "./database/utility";
import { ConnectionNode } from "./model/ConnectionNode";
import { DatabaseNode } from "./model/databaseNode";
import { INode } from "./model/INode";
@ -9,10 +9,11 @@ import { TableNode } from "./model/tableNode";
import { MySQLTreeDataProvider } from "./provider/mysqlTreeDataProvider";
import { SqlResultDocumentContentProvider } from "./provider/sqlResultDocumentContentProvider";
import { CompletionProvider } from "./provider/CompletionProvider";
import { DatabaseCache } from "./common/DatabaseCache";
import { DatabaseCache } from "./database/DatabaseCache";
import { Global } from "./common/global";
import { ColumnNode } from "./model/columnNode";
import { OutputChannel } from "./common/outputChannel";
import { SqlViewManager } from "./database/SqlViewManager";
export function activate(context: vscode.ExtensionContext) {
@ -20,6 +21,7 @@ export function activate(context: vscode.ExtensionContext) {
DatabaseCache.initCache(context)
SqlViewManager.initExtesnsionPath(context.extensionPath)
const mysqlTreeDataProvider = new MySQLTreeDataProvider(context);
const treeview= vscode.window.createTreeView("mysql",{
@ -74,6 +76,7 @@ export function activate(context: vscode.ExtensionContext) {
context.subscriptions.push(vscode.commands.registerCommand("mysql.newQuery", (databaseOrConnectionNode: DatabaseNode | ConnectionNode) => {
databaseOrConnectionNode.newQuery();
Utility.webviewPanel.webview.postMessage({command:'mysql.newQuery'})
}));
context.subscriptions.push(vscode.commands.registerCommand("mysql.template.sql", (tableNode: TableNode, run: Boolean) => {

4
src/model/columnNode.ts

@ -2,8 +2,8 @@ import * as path from "path";
import * as vscode from "vscode";
import { INode } from "./INode";
import { ModelType } from "../common/constants";
import { Utility } from "../common/utility";
import { DatabaseCache } from "../common/DatabaseCache";
import { Utility } from "../database/utility";
import { DatabaseCache } from "../database/DatabaseCache";
import { OutputChannel } from "../common/outputChannel";
import { Global } from "../common/global";

4
src/model/connectionNode.ts

@ -3,13 +3,13 @@ import * as vscode from "vscode";
import { AppInsightsClient } from "../common/appInsightsClient";
import { Constants, ModelType } from "../common/constants";
import { Global } from "../common/global";
import { Utility } from "../common/utility";
import { Utility } from "../database/utility";
import { MySQLTreeDataProvider } from "../provider/mysqlTreeDataProvider";
import { IConnection } from "./connection";
import { DatabaseNode } from "./databaseNode";
import { InfoNode } from "./infoNode";
import { INode } from "./INode";
import { DatabaseCache } from "../common/DatabaseCache";
import { DatabaseCache } from "../database/DatabaseCache";
import { OutputChannel } from "../common/outputChannel";
export class ConnectionNode implements INode {

4
src/model/databaseNode.ts

@ -3,11 +3,11 @@ import * as vscode from "vscode";
import mysqldump from 'mysqldump'
import { AppInsightsClient } from "../common/appInsightsClient";
import { Global } from "../common/global";
import { Utility } from "../common/utility";
import { Utility } from "../database/utility";
import { InfoNode } from "./infoNode";
import { INode } from "./INode";
import { TableNode } from "./tableNode";
import { DatabaseCache } from "../common/DatabaseCache";
import { DatabaseCache } from "../database/DatabaseCache";
import { ModelType } from "../common/constants";
import { OutputChannel } from "../common/outputChannel";

4
src/model/tableNode.ts

@ -3,11 +3,11 @@ import * as vscode from "vscode";
import mysqldump from 'mysqldump'
import { AppInsightsClient } from "../common/appInsightsClient";
import { Global } from "../common/global";
import { Utility } from "../common/utility";
import { Utility } from "../database/utility";
import { ColumnNode } from "./columnNode";
import { InfoNode } from "./infoNode";
import { INode } from "./INode";
import { DatabaseCache } from "../common/DatabaseCache";
import { DatabaseCache } from "../database/DatabaseCache";
import { ModelType } from "../common/constants";
import { IConnection } from "./connection";
import { OutputChannel } from "../common/outputChannel";

2
src/common/CompletionManager.ts → src/provider/CompletionManager.ts

@ -1,5 +1,5 @@
import * as vscode from "vscode";
import { DatabaseCache } from "./DatabaseCache";
import { DatabaseCache } from "../database/DatabaseCache";
export class CompletionManager {

2
src/provider/CompletionProvider.ts

@ -1,5 +1,5 @@
import * as vscode from 'vscode';
import { CompletionManager } from '../common/CompletionManager';
import { CompletionManager } from './CompletionManager';
export class CompletionProvider implements vscode.CompletionItemProvider {

2
src/provider/mysqlTreeDataProvider.ts

@ -6,7 +6,7 @@ import { Global } from "../common/global";
import { IConnection } from "../model/connection";
import { ConnectionNode } from "../model/ConnectionNode";
import { INode } from "../model/INode";
import { DatabaseCache } from "../common/DatabaseCache";
import { DatabaseCache } from "../database/DatabaseCache";
export class MySQLTreeDataProvider implements vscode.TreeDataProvider<INode> {
public _onDidChangeTreeData: vscode.EventEmitter<INode> = new vscode.EventEmitter<INode>();

Loading…
Cancel
Save