bmd-extension 1.6.3

package/src/provider/treeDataProvider/controller/treeData.ts

@@ -0,0 +1,81 @@
+import * as vscode from 'vscode';
+import { ItemCommand } from "../TreeProviderCommand";
+import { BMDCommand, ControllerAction } from "../../../constant";
+import { Dependency } from "../Dependency";
+
+const controllerCommands: ItemCommand[] = [
+    {
+        id: BMDCommand.CreateController,
+        title: 'CONTROLLER',
+        icon: 'add'
+    }, {
+        id: BMDCommand.CreateControllerResource,
+        title: 'CONTROLLER RESOURCE',
+        icon: 'add'
+    },
+    {
+        id: ControllerAction.Get,
+        title: 'GET',
+        icon: 'get'
+    },
+    {
+        id: ControllerAction.Post,
+        title: 'POST',
+        icon: 'post'
+    },
+    {
+        id: ControllerAction.GetListAll,
+        title: 'GET (ALL)',
+        icon: 'list'
+    },
+    {
+        id: ControllerAction.GetListPagination,
+        title: 'GET (PAGINATION)',
+        icon: 'list'
+    },
+    {
+        id: ControllerAction.CreateItem,
+        title: 'CREATE (ENTITY)',
+        icon: 'create'
+    },
+    {
+        id: ControllerAction.CreateItemEntityRequest,
+        title: 'CREATE (ENTITY REQUEST)',
+        icon: 'create'
+    },
+    {
+        id: ControllerAction.UpdateItem,
+        title: 'UPDATE',
+        icon: 'update'
+    },
+    {
+        id: ControllerAction.DeleteItemByBlock,
+        title: 'DELETE (BLOCK)',
+        icon: 'quit'
+    },
+    {
+        id: ControllerAction.DeleteItemByRemove,
+        title: 'DELETE (REMOVE)',
+        icon: 'quit'
+    },
+    {
+        id: ControllerAction.Upload,
+        title: 'UPLOAD (NORMAL)',
+        icon: 'upload'
+    },
+    {
+        id: ControllerAction.UploadResize,
+        title: 'UPLOAD (RESIZE)',
+        icon: 'upload'
+    },
+]
+
+export const controllerDependencies = controllerCommands.map(c => {
+    return new Dependency(
+        c.title,
+        vscode.TreeItemCollapsibleState.None,
+        undefined,
+        c.id,
+        c.icon ? c.icon : 'none'
+    );
+})

package/src/provider/treeDataProvider/deploy/command/handleDeploy.ts

@@ -0,0 +1,70 @@
+import * as vscode from 'vscode';
+import { FSProvider } from '../../../../FsProvider';
+import { Password } from '../../../../utils/Password';
+
+let NEXT_TERM_ID = 1
+
+export async function handleDeploy() {
+    console.log('=== run handleDeploy ===')
+    vscode.window.showInformationMessage(`=== STARTING DEPLOY ===`);
+    const password = Password.getProjectPassword();
+    let settingFile = 'src/settings.json';
+    let version = '';
+
+    //get version
+    if (!FSProvider.checkExist(settingFile)) {
+        return vscode.window.showInformationMessage(`Deploy: Không tìm thấy settings.json`);
+    } else {
+        try {
+            const content = FSProvider.getContentInFile(settingFile);
+            if (!content) {
+                return vscode.window.showInformationMessage(`Deploy: File settings.json rỗng!`);
+            }
+
+            let object: any = {}
+            try {
+                object = JSON.parse(content);
+
+                version = object.version;
+            } catch (error) {
+                return vscode.window.showInformationMessage(`Deploy: Lỗi khi lấy cấu hình từ settings.json!`);
+            }
+        } catch (error) {
+            vscode.window.showInformationMessage(`Deploy: Lỗi khi đọc file cấu hình settings.json!`);
+            return;
+        }
+    }
+    //
+
+    //execute cmd
+    try {
+        const terminal = vscode.window.createTerminal(`Select deploy #${NEXT_TERM_ID++}`);
+        terminal.show();
+        terminal.sendText(`bmd-deploy -p ${password} -vc ${version}`, true);
+    } catch (error) {
+        if (error instanceof Error) {
+            vscode.window.showInformationMessage(`Deploy lỗi: ${error.message}`);
+        }
+    }
+
+}
+
+
+
+function isNotReplaceLink(file: string) {
+    const fileContent = FSProvider.getContentInFile(file)
+    return fileContent.includes('{{link}}')
+}
+
+export async function runDev() {
+    console.log('runDev:', runDev)
+    const terminal = vscode.window.createTerminal(`Development`);
+    terminal.show()
+    terminal.sendText(`npm run dev`, true);
+}
+
+export async function runStart() {
+    const terminal = vscode.window.createTerminal(`Development`);
+    terminal.show()
+    terminal.sendText(`npm run start`, true);
+}

package/src/provider/treeDataProvider/deploy/treeData.ts

@@ -0,0 +1,21 @@
+import { Deploy } from "../../../constant";
+import { Dependency } from "../Dependency";
+import * as vscode from 'vscode';
+
+const deployCommand = [
+    {
+        id: Deploy.Deploy,
+        title: 'Deploy V2',
+        icon: 'spaceship'
+    },
+]
+
+export const deployDependencies = deployCommand.map(c => {
+    return new Dependency(
+        c.title,
+        vscode.TreeItemCollapsibleState.None,
+        undefined,
+        c.id,
+        c.icon ? c.icon : 'none'
+    );
+})

package/src/provider/treeDataProvider/entity/command/addProperty.ts

@@ -0,0 +1,144 @@
+import * as vscode from 'vscode';
+import { PropertyType } from "../../../../constant";
+import { getFullTextType } from '../../../../util';
+
+export async function addProperty(document: vscode.TextDocument | undefined) {
+    let template = ''
+
+    const type = await vscode.window.showQuickPick([
+        PropertyType.String,
+        PropertyType.Number,
+        PropertyType.Boolean,
+        PropertyType.Text,
+        PropertyType.Double,
+        PropertyType.BalanceColumn,
+        PropertyType.IsBlockColumn,
+        PropertyType.TypeColumn,
+        PropertyType.StatusColumn,
+        PropertyType.IsDeleteColumn,
+    ], { ignoreFocusOut: true })
+
+    const edit = new vscode.WorkspaceEdit();
+
+    if (!document || !document.uri) {
+        document = vscode.window.activeTextEditor?.document
+    }
+
+    if (!document) {
+        return vscode.window.showInformationMessage("Cancel: Can not find open document to insert")
+    }
+
+    for (let index = 0; index < document.lineCount; index++) {
+        const line = document.lineAt(index)
+
+        if (line.text.includes('RELATIONS')) {
+            let lineInsertIndex = index - 2
+            switch (type) {
+                case PropertyType.String:
+                case PropertyType.Number:
+                case PropertyType.Boolean:
+                case PropertyType.Double:
+                case PropertyType.Text:
+                    template = await generateProperty(type)
+                    if (!template) return
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), template);
+                    break
+
+                case PropertyType.BalanceColumn:
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), `
+    @Column({ default: 0, width: 20 })
+    @Property()
+    balance: number;
+                    `);
+                    break
+
+                case PropertyType.IsBlockColumn:
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), `
+    @Column({ default: false })
+    @Property()
+    isBlock: boolean
+                    `);
+                    break
+
+                case PropertyType.IsDeleteColumn:
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), `
+    @Column({ default: false, select: false })
+    @Property()
+    isDeleted: boolean
+                    `);
+                    break
+
+                case PropertyType.StatusColumn:
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), `
+    @Column({ default: '' })
+    @Property()
+    status: string
+                    `);
+                    break
+
+                case PropertyType.TypeColumn:
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), `
+    @Column({ default: '' })
+    @Property()
+    type: string
+                    `);
+                    break
+
+                default:
+                    break;
+            }
+        }
+    }
+
+    vscode.workspace.applyEdit(edit)
+}
+
+async function generateProperty(propertyType: PropertyType) {
+    const inputName = await vscode.window.showInputBox({
+        placeHolder: 'Enter property name: ',
+        ignoreFocusOut: true
+    })
+    if (!inputName) return ''
+
+    const fullTextType = getFullTextType(inputName)
+
+    switch (propertyType) {
+        case PropertyType.String:
+            return `
+    @Column({ default: '' })
+    @Property()
+    ${fullTextType.camelCase}: string
+            `
+
+        case PropertyType.Number:
+            return `
+    @Column({ default: 0 })
+    @Property()
+    ${fullTextType.camelCase}: number
+            `
+
+        case PropertyType.Boolean:
+            return `
+    @Column({ default: false })
+    @Property()
+    ${fullTextType.camelCase}: boolean
+            `
+
+        case PropertyType.Double:
+            return `
+    @Column("double", { default: 0 })
+    @Property()
+    ${fullTextType.camelCase}: number
+            `
+
+        case PropertyType.Text:
+            return `
+    @Column('text', { nullable: true })
+    @Property()
+    ${fullTextType.camelCase}: string;
+            `
+
+        default:
+            return ''
+    }
+}

package/src/provider/treeDataProvider/entity/command/addRelation.ts

@@ -0,0 +1,125 @@
+import * as vscode from 'vscode';
+import { EntityAction } from '../../../../constant';
+import { FSProvider } from '../../../../FsProvider';
+import { getFullTextType } from '../../../../util';
+
+export async function insertEntityAction(
+    typeFunc: EntityAction, document: vscode.TextDocument | undefined
+): Promise<void> {
+    const edit = new vscode.WorkspaceEdit();
+    let entity = 'Entity'
+    let template = ''
+
+    if (!document || !document.uri) {
+        document = vscode.window.activeTextEditor?.document
+    }
+
+    if (!document) {
+        vscode.window.showInformationMessage("Cancel: Can not find open document to insert")
+        return
+    }
+
+    for (let index = 0; index < document.lineCount; index++) {
+        const line = document.lineAt(index)
+        if (line.text.includes('CoreEntity') && line.text.includes('class')) {
+            let words = line.text.split(' ')
+            for (let index = 0; index < words.length; index++) {
+                const word = words[index];
+                if (word == 'class') {
+                    entity = words[index + 1]
+                }
+            }
+        }
+
+        if (line.text.includes('METHODS')) {
+            let lineInsertIndex = index - 2
+            switch (typeFunc) {
+                case EntityAction.OneToMany:
+                    template = await generateRelations(entity, EntityAction.OneToMany)
+                    if (!template) return
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), template);
+                    break
+
+                case EntityAction.ManyToOne:
+                    template = await generateRelations(entity, EntityAction.ManyToOne)
+                    if (!template) return
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), template);
+                    break
+
+                case EntityAction.ManyToMany:
+                    template = await generateRelations(entity, EntityAction.ManyToMany)
+                    if (!template) return
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), template);
+                    break
+
+                case EntityAction.OneToOne:
+                    template = await generateRelations(entity, EntityAction.OneToOne)
+                    if (!template) return
+                    edit.insert(document.uri, new vscode.Position(lineInsertIndex, 0), template);
+                    break
+
+                default:
+                    break;
+            }
+        }
+    }
+
+    vscode.workspace.applyEdit(edit)
+}
+
+async function generateRelations(name1: string, relation: EntityAction) {
+    const entities = FSProvider.getAllFileInFolder('/src/entity')
+    let name2 = await vscode.window.showQuickPick(entities, {
+        placeHolder: 'Select entity',
+        ignoreFocusOut: true
+    })
+    if (!name2) return ''
+
+    let injectString1 = ''
+
+    switch (relation) {
+        case EntityAction.OneToMany:
+            injectString1 = `
+    @OneToMany(type => {{cap2}}, {{camel2}}s => {{camel2}}s.{{camel1}})
+    {{camel2}}s: {{cap2}}[];
+            `
+            break;
+
+        case EntityAction.ManyToOne:
+            injectString1 = `
+    @ManyToOne(type => {{cap2}}, {{camel2}} => {{camel2}}.{{camel1}}s)
+    {{camel2}}: {{cap2}};
+            `
+            break;
+
+        case EntityAction.ManyToMany:
+            injectString1 = `
+    @ManyToMany(type => {{cap2}}, {{camel2}}s => {{camel2}}s.{{camel1}}s)
+    {{camel2}}s: {{cap2}}[];
+            `
+            break;
+
+        case EntityAction.OneToOne:
+            injectString1 = `
+    @OneToOne(type => {{cap2}}, {{camel2}} => {{camel2}}.{{camel1}})
+    {{camel2}}: {{cap2}};
+            `
+            break;
+    }
+
+    const nameTextTypes1 = getFullTextType(name1)
+    const nameTextTypes2 = getFullTextType(name2)
+
+    injectString1 = injectString1.replace(/{{camel1}}/g, nameTextTypes1.camelCase);
+    injectString1 = injectString1.replace(/{{camel2}}/g, nameTextTypes2.camelCase);
+    injectString1 = injectString1.replace(/{{cap1}}/g, nameTextTypes1.classifyCase);
+    injectString1 = injectString1.replace(/{{cap2}}/g, nameTextTypes2.classifyCase);
+
+    if (injectString1.includes('ys')) {
+        injectString1 = injectString1.replace(/ys/g, 'ies');
+    }
+    if (injectString1.includes('sss')) {
+        injectString1 = injectString1.replace(/sss/g, 'sses');
+    }
+    return injectString1
+}

package/src/provider/treeDataProvider/entity/command/createEntity.ts

@@ -0,0 +1,53 @@
+import { FSProvider } from "../../../../FsProvider"
+import * as vscode from 'vscode';
+import { getFullTextType } from "../../../../util";
+import { Confirmation } from "../../../../constant";
+import { Uri, commands } from "vscode";
+
+export async function createEntity(fsPath: string) {
+    if (!FSProvider.isValidStructure()) {
+        return vscode.window.showInformationMessage("Cancel!. Wrong project's structure.");
+    }
+
+    if (fsPath != undefined && !fsPath.includes('entity')) {
+        return vscode.window.showInformationMessage("Please select 'entity' folder")
+    }
+
+    let entity = await vscode.window.showInputBox({
+        placeHolder: "Enter entity name: ",
+        ignoreFocusOut: true
+    })
+    if (!entity) {
+        return vscode.window.showInformationMessage("Cancel!. Do not input entity name.");
+    }
+
+    const entityTextTypes = getFullTextType(entity)
+
+    const distPath = `src/entity/${entityTextTypes.classifyCase}.ts`
+    if (FSProvider.checkExist(distPath)) {
+        const confirm = await vscode.window.showQuickPick(
+            [Confirmation.Yes, Confirmation.No],
+            {
+                placeHolder: "This file already exist in this folder. Do you want to replace it.",
+                ignoreFocusOut: true
+            }
+        )
+        if (!confirm || confirm == Confirmation.No) {
+            return vscode.window.showInformationMessage("Cancel: add ENTITY.");
+        }
+    }
+
+    FSProvider.copyAndReplaceFile(
+        'entity/entity.txt',
+        distPath,
+        [
+            { regex: /{{snake}}/g, value: entityTextTypes.snakeCase },
+            { regex: /{{classify}}/g, value: entityTextTypes.classifyCase },
+            { regex: /{{camel}}/g, value: entityTextTypes.camelCase }
+        ])
+
+    let uri = Uri.file(FSProvider.getFullPath(distPath))
+    await commands.executeCommand('vscode.openFolder', uri)
+
+    return vscode.window.showInformationMessage("Create ENTITY successfully!");
+}

package/src/provider/treeDataProvider/entity/command/createEntityRequest.ts

@@ -0,0 +1,65 @@
+import { FSProvider } from "../../../../FsProvider"
+import * as vscode from 'vscode';
+import { getFullTextType } from "../../../../util";
+import { Confirmation, TypeRequest } from "../../../../constant";
+import { Uri, commands } from "vscode";
+
+export async function createEntityRequest(fsPath: string) {
+    if (!FSProvider.isValidStructure()) {
+        return vscode.window.showInformationMessage("Cancel!. Wrong project's structure.");
+    }
+
+    if (fsPath != undefined && !fsPath.includes('entity-request')) {
+        return vscode.window.showInformationMessage("Please select 'entity' folder")
+    }
+
+    const entities = FSProvider.getAllFileInFolder('/src/entity')
+
+    const entity = await vscode.window.showQuickPick(
+        [...entities],
+        { ignoreFocusOut: true }
+    )
+    if (!entity) {
+        return vscode.window.showInformationMessage('Cancel! Do not select entity')
+    }
+
+    const type = await vscode.window.showQuickPick(
+        [TypeRequest.Insert, TypeRequest.Update],
+        { ignoreFocusOut: true }
+    )
+    if (!type) {
+        return vscode.window.showInformationMessage('Cancel! Do not select type entity request')
+    }
+
+    const entityRequestTextTypes = getFullTextType(entity + type)
+    const entityTextTypes = getFullTextType(entity)
+
+    const distPath = `src/entity-request/${entityRequestTextTypes.classifyCase}.ts`
+    if (FSProvider.checkExist(distPath)) {
+        const confirm = await vscode.window.showQuickPick(
+            [Confirmation.Yes, Confirmation.No],
+            {
+                placeHolder: "This file already exist in this folder. Do you want to replace it.",
+                ignoreFocusOut: true
+            }
+        )
+        if (!confirm || confirm == Confirmation.No) {
+            return vscode.window.showInformationMessage("Cancel: add ENTITY REQUEST.");
+        }
+    }
+
+    FSProvider.copyAndReplaceFile(
+        'entity-request/entity-request.txt',
+        distPath,
+        [
+            { regex: /{{snake}}/g, value: entityTextTypes.snakeCase },
+            { regex: /{{classify}}/g, value: entityTextTypes.classifyCase },
+            { regex: /{{classifyRaw}}/g, value: entityRequestTextTypes.classifyCase },
+            { regex: /{{camel}}/g, value: entityTextTypes.camelCase }
+        ])
+
+    let uri = Uri.file(FSProvider.getFullPath(distPath))
+    await commands.executeCommand('vscode.openFolder', uri)
+
+    return vscode.window.showInformationMessage("Create ENTITY REQUEST successfully!");
+}

package/src/provider/treeDataProvider/entity/command/exportInterface.ts

@@ -0,0 +1,130 @@
+import * as vscode from 'vscode';
+import { API } from '../../../../API';
+import { FSProvider } from '../../../../FsProvider';
+import { Request } from '../../../../Request';
+
+export async function createInterface(document: vscode.TextDocument | any, range: vscode.Range) {
+    const entities = FSProvider.getAllFileInFolder('/src/entity')
+
+    vscode.window.withProgress({
+        location: vscode.ProgressLocation.Notification,
+        title: "Uploading interface: ",
+        cancellable: true
+    }, async (progress, token) => {
+
+        token.onCancellationRequested(() => {
+            // console.log("User canceled the long running operation");
+        });
+
+        progress.report({ increment: 0 });
+
+        for (let index = 0; index < entities.length; index++) {
+            const entity = entities[index];
+
+            const linesProperty = getPropertyLinesEntity(entity, true)
+            let line = ``
+            linesProperty.map((l, i) => {
+                i == linesProperty.length - 1 ? line += `${l}` : line += `${l} \n`
+            })
+
+            let template = `
+export interface ${entity} {
+${line}
+}
+`
+            // let doc = await vscode.workspace.openTextDocument({ content: template, language: 'typescript' }); // calls back into the provider
+            // await vscode.window.showTextDocument(doc, { preview: false, viewColumn: vscode.ViewColumn.Beside });
+
+            const folders = vscode.workspace.workspaceFolders
+            if (!folders?.length) return
+
+            const projectName = folders[0].name
+
+            console.log(`template "${entity}"`, template);
+
+
+            const response = await Request.post(API.Interface.post, {
+                name: entity,
+                project: projectName,
+                body: template
+            })
+
+            if (response) {
+                progress.report({ increment: 100 / entities.length, message: `${entity}` });
+            }
+
+        }
+    });
+
+    const p = new Promise(resolve => resolve(''));
+    return p;
+}
+
+
+
+function getEntityFromFilename(filename: string) {
+    const words = filename.split('/')
+    const fileWithExtension = words[words.length - 1]
+    return fileWithExtension.replace('.ts', '')
+}
+
+function getPropertyLinesEntity(name: string, getComment: boolean = false): any[] {
+    const lines = FSProvider.getLinesDocumentInFile(`src/entity/${name}.ts`).filter(e => e)
+    if (!lines.length) return []
+    const properties = [];
+    let currentIndex = null;
+
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+
+        if (shouldGetComment(getComment, line)) {
+            properties.push(line)
+        }
+
+        if (currentIndex == null && line.includes('@') && !line.includes('@Entity')) {
+            currentIndex = index;
+        }
+
+
+        else if (!line.includes('@') && currentIndex !== null && line.includes(':')) {
+            let lineProperty = line.replace(';', '')
+            properties.push(`${lineProperty}`)
+            currentIndex = null;
+        }
+    }
+    const propertiesInCore = getPropertyLinesEntityCore()
+    return [...propertiesInCore, ...properties]
+}
+
+function shouldGetComment(getComment: boolean, line: string) {
+    return getComment &&
+        line.startsWith('//') &&
+        line.includes('//') &&
+        !line.includes('@') &&
+        !line.includes('IMPORT') &&
+        !line.includes('PROPERTIES') &&
+        !line.includes('RELATIONS') &&
+        !line.includes('METHODS') &&
+        !line.includes('END') &&
+        !line.includes(':')
+}
+
+function getPropertyLinesEntityCore(): any[] {
+    const lines = FSProvider.getLinesDocumentInFile(`src/core/entity/CoreEntity.ts`)
+    if (!lines.length) return []
+    const properties = []
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (line.includes('@Column') || line.includes('@PrimaryGeneratedColumn')) {
+            let lineProperty = lines[index + 1]
+
+            if (lineProperty.includes('JsonProperty') || lineProperty.includes('Property')) {
+                lineProperty = lines[index + 2]
+            }
+
+            lineProperty = lineProperty.replace(';', '')
+            properties.push(`${lineProperty}`)
+        }
+    }
+    return properties
+}