bmd-extension 1.6.3

package/src/provider/codeAction/entity/handleRelation.ts

@@ -0,0 +1,72 @@
+import * as vscode from 'vscode';
+import { EntityAction, PropertyType } from '../../../constant';
+import { getFullTextType } from '../../../util';
+import { FSProvider } from '../../../FsProvider';
+
+export function createRelationAction(document: vscode.TextDocument, range: vscode.Range) {
+    if (isEntityRelations(document, range)) {
+        const insertOneToMany = createAddRelationAction(document, range, EntityAction.OneToMany);
+        const insertManyToOne = createAddRelationAction(document, range, EntityAction.ManyToOne);
+        const insertManyToMany = createAddRelationAction(document, range, EntityAction.ManyToMany);
+        const insertOneToOne = createAddRelationAction(document, range, EntityAction.OneToOne);
+
+        return [
+            insertOneToMany,
+            insertManyToOne,
+            insertManyToMany,
+            insertOneToOne
+        ];
+    }
+
+    return []
+}
+
+function isEntityRelations(document: vscode.TextDocument, range: vscode.Range) {
+    const start = range.start;
+    const line = document.lineAt(start.line);
+    return line.text.includes('RELATIONS')
+}
+
+function createAddRelationAction(document: vscode.TextDocument, range: vscode.Range, typeFunc: EntityAction): vscode.CodeAction {
+    const entity = new vscode.CodeAction(typeFunc, vscode.CodeActionKind.QuickFix);
+    switch (typeFunc) {
+        case EntityAction.OneToMany:
+            entity.command = {
+                command: typeFunc,
+                title: 'OneToMany with:',
+                tooltip: 'OneToMany with:',
+                arguments: [document]
+            };
+            break
+
+        case EntityAction.ManyToOne:
+            entity.command = {
+                command: typeFunc,
+                title: 'ManyToOne with:',
+                tooltip: 'ManyToOne with:',
+                arguments: [document]
+            };
+            break
+
+        case EntityAction.ManyToMany:
+            entity.command = {
+                command: typeFunc,
+                title: 'ManyToMany with:',
+                tooltip: 'ManyToMany with:',
+                arguments: [document]
+            };
+            break
+
+        case EntityAction.OneToOne:
+            entity.command = {
+                command: typeFunc,
+                title: 'OneToOne with:',
+                tooltip: 'OneToOne with:',
+                arguments: [document]
+            };
+            break
+
+    }
+
+    return entity;
+}

package/src/provider/codeAction/entity/helper.ts

@@ -0,0 +1,132 @@
+import * as vscode from 'vscode';
+import { FSProvider } from '../../../FsProvider';
+import { getWordBetweenSpace, getFullTextType } from '../../../util';
+
+export function getEntityFromFunction(document: vscode.TextDocument, range: vscode.Range, isQuery: boolean = false) {
+    const start = range.start;
+    const line = document.lineAt(start.line);
+
+    if (!isQuery) {
+        const entities = line.text.match(/\s[A-Z][A-z]+/)
+        if (entities && entities.length) {
+            const entity = entities[0].replace(' ', '').replace('.', '')
+            return { text: entity, lastIndex: 0 }
+        }
+        return { text: "", lastIndex: 0 }
+    } else {
+        const { text, lastIndex } = getWordBetweenSpace(line.text, range.start.character)
+        if (!text) return { text: "", lastIndex: 0 }
+
+        const entityFullText = getFullTextType(text)
+        return { text: entityFullText.classifyCase, lastIndex }
+    }
+}
+
+
+export function getPropertiesEntity(name: string): any[] {
+    const lines = FSProvider.getLinesDocumentInFile(`src/entity/${name}.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(':', '').replace(';', '')
+            const words = lineProperty.split(' ').filter(Boolean)
+            if (words.length > 1) {
+                properties.push({ name: words[0], type: words[1] })
+            }
+            else continue
+        }
+    }
+    const propertyInCore = getPropertyInCore()
+    properties.push(...propertyInCore)
+
+    return properties
+}
+
+function getPropertyInCore() {
+    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(':', '').replace(';', '')
+            const words = lineProperty.split(' ').filter(Boolean)
+            if (words.length > 1) { properties.push({ name: words[0], type: words[1] }) }
+            else continue
+        }
+    }
+    return properties
+}
+
+
+export function getRelationsEntityDeeper(name: string, nameExcept: string = ''): { relations: any[], entities: any[] } {
+    const lines = FSProvider.getLinesDocumentInFile(`src/entity/${name}.ts`)
+    if (!lines.length) return { relations: [], entities: [] }
+    const relations = []
+    const nextEntity = []
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (line.includes('@ManyToMany') ||
+            line.includes('@OneToMany') ||
+            line.includes('@ManyToOne') ||
+            line.includes('@OneToOne')) {
+            let lineProperty = lines[index + 1]
+            if (lineProperty.includes('@')) {
+                lineProperty = lines[index + 2]
+            }
+            if (lineProperty.includes('@')) {
+                lineProperty = lines[index + 3]
+            }
+            lineProperty = lineProperty.replace(':', '').replace(';', '').replace('[]', '')
+
+            if (nameExcept && lineProperty == nameExcept) continue
+
+            const words = lineProperty.split(' ').filter(Boolean)
+            if (words.length > 1) {
+                relations.push(words[0])
+                nextEntity.push(words[1])
+            }
+        }
+    }
+
+    return { relations, entities: nextEntity }
+}
+
+export function getRelationsEntity(name: string): any[] {
+    const finalRelation: any[] = []
+    const { relations, entities } = getRelationsEntityDeeper(name)
+    if (!relations || !relations.length) return []
+
+    relations.map((r: any, i: number) => {
+        finalRelation.push(r)
+        const nextRelations = getRelationsEntityDeeper(entities[i], name)
+
+        if (relations && relations.length) {
+            finalRelation.push(...nextRelations.relations.map((n: any) => `${r}.${n}`))
+        }
+    })
+    return finalRelation
+}
+
+export function findLastLineRelation(document: vscode.TextDocument, currentLine: vscode.TextLine) {
+    let start = true
+    let currentLineNumber = currentLine.lineNumber
+    while (start) {
+        currentLineNumber += 1
+        let newLine = document.lineAt(currentLineNumber)
+        if (!newLine.text.includes('Join')) {
+            start = false
+        }
+    }
+    return currentLineNumber
+}

package/src/provider/codeAction/entity-request/codeAction.ts

@@ -0,0 +1,178 @@
+import { FSProvider } from '../../../FsProvider';
+import * as vscode from 'vscode';
+import { getFullTextType, toLowerCaseFirstLetter } from '../../../util';
+
+export enum EntityRequestAction {
+    AddProperty = 'BMD: Add property entity-request',
+}
+
+
+export class EntityRequestActionProvider implements vscode.CodeActionProvider {
+
+    public static readonly providedCodeActionKinds = [
+        vscode.CodeActionKind.QuickFix
+    ];
+
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        range: vscode.Range | vscode.Selection,
+        context: vscode.CodeActionContext
+    ): vscode.CodeAction[] | undefined {
+
+        if (this.isEntityRequestProperties(document, range)) {
+            const addProperty = this.createEntityFunc(document, range, EntityRequestAction.AddProperty);
+
+            return [
+                addProperty
+            ];
+        }
+
+    }
+
+    private isEntityRequestProperties(document: vscode.TextDocument, range: vscode.Range) {
+        const start = range.start;
+        const line = document.lineAt(start.line);
+        return line.text.includes('PROPERTIES') && document.fileName.includes('entity-request/')
+    }
+
+
+    private createEntityFunc(document: vscode.TextDocument, range: vscode.Range, typeFunc: EntityRequestAction): vscode.CodeAction {
+        const entity = new vscode.CodeAction(typeFunc, vscode.CodeActionKind.QuickFix);
+        switch (typeFunc) {
+            case EntityRequestAction.AddProperty:
+                entity.command = {
+                    command: typeFunc,
+                    title: 'Add property: ',
+                    tooltip: 'Add property: ',
+                    arguments: [document]
+                };
+                break
+
+            default:
+                break;
+
+        }
+
+        return entity;
+    }
+
+    public async addProperty(document: vscode.TextDocument) {
+        let entity = this.getEntityFromEntityRequest(document)
+        if (!entity)
+            return vscode.window.showInformationMessage('Find not found entity')
+
+        const propertiesInEntity = this.getPropertiesEntity(entity)
+        if (!propertiesInEntity.length)
+            return vscode.window.showInformationMessage('Find not found properties in entity')
+
+        const propertiesInEntityRequest = this.getPropertiesEntityRequest(document)
+
+        const propertiesNotInEntityRequest = propertiesInEntity.filter(property => {
+            if (propertiesInEntityRequest.indexOf(property) == -1)
+                return property
+        })
+
+        if (!propertiesNotInEntityRequest.length)
+            return vscode.window.showInformationMessage('All property were selected')
+
+        const property = await vscode.window.showQuickPick(
+            [...propertiesNotInEntityRequest],
+            { ignoreFocusOut: true }
+        )
+        if (!property)
+            return vscode.window.showInformationMessage('No property was selected')
+
+        const edit = new vscode.WorkspaceEdit();
+
+        let template = this.getTemplatePropertyEntity(entity, property)
+        if (!template)
+            return vscode.window.showInformationMessage('Can not generate template')
+
+        for (let index = 0; index < document.lineCount; index++) {
+            const line = document.lineAt(index)
+            if (line.text.includes('PROPERTIES')) {
+                edit.insert(document.uri, new vscode.Position(index + 1, 0), template);
+            }
+        }
+
+        const entityCamel = getFullTextType(entity).camelCase
+        for (let index = 0; index < document.lineCount; index++) {
+            const line = document.lineAt(index)
+            if (line.text.includes(`return ${entityCamel}`)) {
+                let templateTo = `${toLowerCaseFirstLetter(entity)}.${property} = this.${property} \n`
+                edit.insert(document.uri, new vscode.Position(index - 1, 0), templateTo);
+            }
+        }
+
+        vscode.workspace.applyEdit(edit)
+    }
+
+    private getEntityFromEntityRequest(document: vscode.TextDocument) {
+        let entity = ''
+        for (let index = 0; index < document.lineCount; index++) {
+            let lineText = document.lineAt(index).text
+            if (lineText.includes('new')) {
+                lineText = lineText.replace('()', '')
+                const words = lineText.split(' ')
+                entity = words[words.length - 1]
+                break;
+            }
+        }
+        return entity
+    }
+
+
+    private getPropertiesEntity(name: string): any[] {
+        const lines = FSProvider.getLinesDocumentInFile(`src/entity/${name}.ts`)
+        if (!lines.length) return []
+        const properties = []
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (line.includes('@Column')) {
+                let lineProperty = lines[index + 2]
+                lineProperty = lineProperty.replace(':', '').replace(';', '')
+                const words = lineProperty.split(' ').filter(Boolean)
+                if (words.length > 1) properties.push(words[0])
+                else continue
+            }
+        }
+        return properties
+    }
+
+    private getPropertiesEntityRequest(document: vscode.TextDocument): any {
+        const properties: any = []
+        for (let index = 0; index < document.lineCount; index++) {
+            let lineText = document.lineAt(index).text
+            if (lineText.includes('@JsonProperty') || lineText.includes('Property')) {
+                let lineProperty = document.lineAt(index + 1).text
+                lineProperty = lineProperty.replace(':', '').replace(';', '')
+                const words = lineProperty.split(' ').filter(Boolean)
+                if (words.length > 1) properties.push(words[0])
+                else continue
+            }
+        }
+        return properties
+    }
+
+    private getTemplatePropertyEntity(name: string, property: string): any {
+
+        const lines = FSProvider.getLinesDocumentInFile(`src/entity/${name}.ts`)
+        if (!lines.length) return vscode.window.showInformationMessage('Can not read file or file is empty')
+
+        let template = ''
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            const lineDecorator = lines[index + 1];
+            const lineProperty = lines[index + 2]
+            if (line.includes('@Column') && lineProperty.includes(property + ':')) {
+                return template = `
+${lineDecorator}
+${lineProperty}
+                `
+            }
+        }
+
+        return template
+    }
+
+}

package/src/provider/codeAction/enum/codeAction.ts

@@ -0,0 +1,95 @@
+import * as vscode from 'vscode';
+import { API } from '../../../API';
+import { BMDCommand } from '../../../constant';
+import { Request } from '../../../Request';
+
+export class EnumActionProvider implements vscode.CodeActionProvider {
+
+    public static readonly providedCodeActionKinds = [
+        vscode.CodeActionKind.QuickFix
+    ];
+
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        range: any
+    ): vscode.CodeAction[] | undefined | any {
+        if (isEnumLine(document, range)) {
+            const action = new vscode.CodeAction(BMDCommand.AddEnum, vscode.CodeActionKind.QuickFix);
+
+            action.command = {
+                command: BMDCommand.AddEnum,
+                title: 'Add enum',
+                tooltip: 'Add enum',
+                arguments: [document, range]
+            };
+            return [action];
+        }
+
+        return []
+    }
+
+}
+
+function isEnumLine(document: vscode.TextDocument, range: vscode.Range) {
+    const start = range.start;
+    const line = document.lineAt(start.line);
+    return line.text.includes('enum')
+}
+
+export async function addEnum(document: vscode.TextDocument, range: vscode.Range) {
+    const start = range.start;
+    const line = document.lineAt(start.line);
+
+    const enumName = getEnumNameInLine(line.text)
+    const enumBody = getEnumBody(document, range)
+
+    const folders = vscode.workspace.workspaceFolders
+    if (!folders?.length) return
+
+    const projectName = folders[0].name
+
+    const data = await Request.post(API.Enum.post, {
+        name: enumName,
+        project: projectName,
+        body: enumBody
+    })
+
+    if (data) {
+        vscode.window.showInformationMessage(`Upload successfully!`);
+    }
+}
+
+function getEnumNameInLine(line: string) {
+    const words = line.split(' ')
+
+    for (let index = 0; index < words.length; index++) {
+        const word = words[index];
+        if (word == 'enum') {
+            return words[index + 1]
+        }
+    }
+    return ``
+}
+
+function getEnumBody(document: vscode.TextDocument, range: vscode.Range) {
+    let start = range.start.line
+
+    const lines = []
+
+    const line = document.lineAt(start);
+    lines.push(line.text) // Add select line
+
+    let isLineOpenEnum = !line.text.includes('}')
+    while (isLineOpenEnum) {
+        start += 1
+        const nextLine = document.lineAt(start)
+        lines.push(nextLine.text)
+        isLineOpenEnum = !nextLine.text.includes('}')
+    }
+
+    const body = `
+${lines.join('\n')}
+    `
+
+    return body
+}