first commit

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+package-lock.json

README.md

@@ -0,0 +1,25 @@
+# 说明
+
+
+## 脚本说明
+
+```bash
+├── package.json
+├── package-lock.json
+├── README.md
+├── scripts
+│   ├── auto_check_model_and_table.js 检查模型和表是否匹配
+│   ├── auto_update_label.js 从数据库字段注释，更新owl界面设计器生成的界面json的label
+│   └── auto_update_php_model_relationships.js 从owl动态关系，更新php模型中的关系方法
+└── util
+    └── db.js 数据库链接信息
+```
+
+## 运行
+
+```bash
+# 先安装依赖
+npm install
+# 执行某个脚本
+node scripts/auto_update_label.js
+```

package.json

@@ -0,0 +1,13 @@
+{
+  "name": "auto-update-label",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "auto_update_label": "node ./scripts/auto_update_label.js",
+    "model": "node ./scripts/auto_update_php_model_relationships.js"
+  },
+  "bin": "scripts/auto_update_label.js",
+  "dependencies": {
+    "mysql2": "^3.11.4"
+  }
+}

scripts/auto_check_model_and_table.js

@@ -0,0 +1,157 @@
+/*
+    提取文件路径://home/fy/work/xiaoding/owl-admin/app/Models
+    下所有的文件中
+    protected $table = '要提取的表名';
+    所有的表名，然后去数据库中查询是否存在这些表，如果不存在，就打印出来
+ */
+
+const fs = require('fs');
+const path = require('path');
+const db = require('../util/db');
+
+// 模型文件目录路径
+const MODELS_DIR = '/home/fy/work/xiaoding/owl-admin/app/Models';
+
+// 从PHP文件中提取表名
+function extractTableName(fileContent) {
+    const tableMatch = fileContent.match(/protected\s+\$table\s*=\s*['"]([^'"]+)['"]/);
+    return tableMatch ? tableMatch[1] : null;
+}
+
+// 递归获取所有PHP文件
+async function getAllPhpFiles(dir) {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await getAllPhpFiles(fullPath));
+        } else if (entry.isFile() && entry.name.endsWith('.php')) {
+            files.push(fullPath);
+        }
+    }
+
+    return files;
+}
+
+// 检查表是否存在于数据库中
+async function checkTableExists(tableName) {
+    try {
+        const [rows] = await db.query(`
+            SELECT COUNT(*) as count 
+            FROM information_schema.tables 
+            WHERE table_schema = 'xiaoding_test' 
+            AND table_name = ?
+        `, [tableName]);
+        return rows[0].count > 0;
+    } catch (error) {
+        console.error(`检查表 ${tableName} 时出错:`, error);
+        return false;
+    }
+}
+
+// 检查数据库中存在但没有对应模型的表
+async function checkMissingModels() {
+    try {
+        const [rows] = await db.query(`
+            SELECT table_name AS table_name
+            FROM information_schema.tables
+            WHERE
+                table_schema = 'xiaoding_test'
+                AND table_name NOT LIKE 'admin_%'
+                AND table_name NOT LIKE 'manage_%'
+                AND table_name NOT IN(
+                    'cache',
+                    'cache_locks',
+                    'failed_jobs',
+                    'job_batches',
+                    'jobs',
+                    'migrations',
+                    'password_reset_tokens',
+                    'personal_access_tokens'
+                )  `);
+
+        const existingTables = rows.map(row => row.table_name);
+        const phpFiles = await getAllPhpFiles(MODELS_DIR);
+        const modelNames = phpFiles.map(file => {
+            const content = fs.readFileSync(file, 'utf8');
+            return extractTableName(content);
+        }).filter(name => name !== null);
+        const modelNamesWithUnderscore = phpFiles.map(file => path.basename(file, '.php').toLowerCase());
+    
+        const missingModels = existingTables.filter(table => {
+            if (table === undefined) {
+                return false; // Skip undefined table names
+            }
+            const tableWithoutPrefix = table.replace(/^admin_/, '');
+            return !modelNames.includes(tableWithoutPrefix) && !modelNamesWithUnderscore.includes(tableWithoutPrefix);
+        });
+
+        if (missingModels.length > 0) {
+            console.log('\n以下表在数据库中存在，但没有对应的模型:');
+            missingModels.forEach(table => {
+                console.log(`缺失模型的表名: ${table}`);
+            });
+        } else {
+            console.log('\n所有存在的表都有对应的模型');
+        }
+    } catch (error) {
+        console.error('检查缺失模型时出错:', error);
+    }
+}
+
+// 主函数
+async function main() {
+    try {
+        // 获取所有PHP文件
+        const phpFiles = await getAllPhpFiles(MODELS_DIR);
+        console.log(`找到 ${phpFiles.length} 个PHP文件`);
+
+        // 存储不存在的表
+        const missingTables = [];
+
+        // 遍历所有文件
+        for (const file of phpFiles) {
+            const content = fs.readFileSync(file, 'utf8');
+            const tableName = extractTableName(content);
+
+            if (tableName) {
+                const exists = await checkTableExists(tableName);
+                if (!exists) {
+                    missingTables.push({
+                        model: path.relative(MODELS_DIR, file),
+                        table: tableName
+                    });
+                }
+            }
+        }
+
+        // 打印结果
+        if (missingTables.length > 0) {
+            console.log('\n以下表在数据库中不存在:');
+            missingTables.forEach(({ model, table }) => {
+                console.log(`模型文件: ${model}`);
+                console.log(`缺失表名: ${table}`);
+                console.log('---');
+            });
+        } else {
+            console.log('\n所有表都存在于数据库中');
+        }
+
+        // 检查数据库中存在但没有对应模型的表
+        await checkMissingModels();
+
+    } catch (error) {
+        console.error('执行过程中出错:', error);
+    } finally {
+        // 关闭数据库连接
+        await db.end();
+    }
+}
+
+// 执行主函数
+main().catch(err => {
+    console.error('主函数执行出错:', err);
+    process.exit(1);
+});

scripts/auto_update_label.js

@@ -0,0 +1,124 @@
+const db = require('../util/db');
+
+async function getAllLabels() {
+    console.log('开始执行脚本');
+    let map = {};
+
+    try {
+        // 获取所有表名
+        const [tables] = await db.query(`
+            select table_name 
+            from information_schema.tables 
+            where table_schema = 'owl' 
+            AND table_name like 'biz_%' 
+            and table_name not LIKE 'admin_%' 
+            and table_name not LIKE 'user_%' 
+            and table_name not LIKE 'label_%' 
+            and table_name not LIKE 'label_record_%' 
+            and table_name not LIKE 'label_record_detail_%';
+        `);
+
+        if (tables.length === 0) {
+            console.log('没有找到符合条件的表');
+            return {};
+        }
+
+        // 使用 for...of 循环来按顺序处理每个表
+        for (const table of tables) {
+            // 获取每个表的所有字段的名称和备注
+            const [columns] = await db.query(`
+                select column_name, column_comment 
+                from information_schema.columns 
+                where table_schema = 'owl' 
+                and table_name = '${table.TABLE_NAME}' 
+                order by ordinal_position;
+            `);
+
+            if (columns.length === 0) {
+                continue;
+            }
+
+            columns.forEach(column => {
+                // 处理注释中包含冒号的情况
+                const comment = column.COLUMN_COMMENT || '';
+                const processedComment = comment.split(/[：:]/, 1)[0];
+                map[column.COLUMN_NAME] = processedComment;
+            });
+        }
+
+        return map;
+
+    } catch (err) {
+        console.error('执行脚本时出错:', err);
+        return null;
+    }
+}
+
+async function getAllPagesJson() {
+    try {
+        // 查询所有页面json
+        const [pages] = await db.query(`
+            select id, \`schema\` 
+            from admin_pages;
+        `);
+
+        if (pages.length === 0) {
+            console.log('没有找到页面json');
+            return null;
+        }
+
+        return pages.map(page => { return { id: page.id, schema: page.schema } });
+
+    } catch (err) {
+        console.error('查询页面json时出错:', err);
+        return null;
+    }
+}
+
+
+// 创建主函数并执行
+async function main() {
+    const dict = await getAllLabels();
+    dict['id'] = '编号';
+    dict['created_at'] = '创建时间';
+    dict['updated_at'] = '更新时间';
+    dict['deleted_at'] = '删除时间';
+
+    for (const key in dict) {
+        if (key.indexOf('_id') != -1) {
+            dict[key] = key.split('_id')[0] + '关联对象';
+        }
+    }
+
+    console.log(JSON.stringify(dict, null, 2));
+
+    const pages = await getAllPagesJson();
+    console.log(JSON.stringify(pages, null, 2));
+
+    if (pages && dict) {
+        for (const page of pages) {
+            let { id, schema } = page;
+            for (const [columnName, columnComment] of Object.entries(dict)) {
+                const labelRegex = new RegExp(`"label":"${columnName}"`, 'g');
+                const titleRegex = new RegExp(`"title":"${columnName}"`, 'g');
+                schema = schema.replace(labelRegex, `"label":"${columnComment}"`);
+                schema = schema.replace(titleRegex, `"title":"${columnComment}"`);
+            }
+
+            try {
+                await db.query(`
+                    UPDATE admin_pages
+                    SET \`schema\` = ?
+                    WHERE id = ?;
+                `, [schema, id]);
+                console.log(`页面ID ${id} 的schema更新成功`);
+            } catch (err) {
+                console.error(`更新页面ID ${id} 的schema时出错:`, err);
+            }
+        }
+    }
+}
+
+main().catch(err => {
+    console.error('主函数执行出错:', err);
+});

scripts/auto_update_php_model_relationships.js

@@ -0,0 +1,415 @@
+const db = require('../util/db');
+const fs = require('fs');
+const path = require('path');
+
+// 将字符串转换为驼峰命名
+function toCamelCase(str) {
+    return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase());
+}
+
+// 根据关系类型获取对应的方法名
+function getRelationshipMethod(type) {
+    const typeMap = {
+        'HAS_MANY': 'hasMany',
+        'BELONGS_TO': 'belongsTo',
+        'HAS_ONE': 'hasOne',
+        'BELONGS_TO_MANY': 'belongsToMany',
+        'MANY_TO_MANY': 'belongsToMany',
+        'MANY_TO_MANY_INVERSE': 'belongsToMany',
+        'MORPH_ONE': 'morphOne',
+        'MORPH_MANY': 'morphMany',
+        'MORPH_TO': 'morphTo',
+        'MORPH_TO_MANY': 'morphToMany',
+        'MORPHED_BY_MANY': 'morphedByMany',
+        'HAS_MANY_THROUGH': 'hasManyThrough',
+        'HAS_ONE_THROUGH': 'hasOneThrough',
+        'HAS_ONE_OF_MANY': 'hasOneOfMany',
+        'MORPH_TO_ONE': 'morphToOne',
+        'HAS_MANY_THROUGH_MANY': 'hasManyThroughMany'
+    };
+    return typeMap[type] || type;
+}
+
+// 生成关系方法的代码
+function generateMethodCode(data) {
+    const {title, type, remark, args} = data;
+    const argsObj = typeof args === 'string' ? JSON.parse(args) : args;
+    const relationshipMethod = getRelationshipMethod(type);
+    
+    // 构建方法参数
+    const methodArgs = [];
+    
+    // 基本参数处理
+    if (argsObj.related) {
+        // 只使用模型名称
+        const modelName = argsObj.related.split('\\').pop();
+        methodArgs.push(`${modelName}::class`);
+    }
+    
+    // 多态关系参数处理
+    if (relationshipMethod.includes('morph')) {
+        if (relationshipMethod === 'morphTo') {
+            // morphTo 方法的特殊处理
+            if (argsObj.name) {
+                methodArgs.push(`'${argsObj.name}'`);
+            }
+            if (argsObj.type && argsObj.id) {
+                methodArgs.push(`'${argsObj.type}'`);
+                methodArgs.push(`'${argsObj.id}'`);
+            }
+            // 支持 morphMap 类型数组
+            if (argsObj.morphMap && Array.isArray(argsObj.morphMap)) {
+                const morphMapStr = argsObj.morphMap.map(type => `'${type}'`).join(', ');
+                methodArgs.push(`[${morphMapStr}]`);
+            }
+        } else if (relationshipMethod === 'morphToMany' || relationshipMethod === 'morphedByMany') {
+            // morphToMany 和 morphedByMany 的特殊处理
+            if (argsObj.name) {
+                methodArgs.push(`'${argsObj.name}'`);
+            }
+            if (argsObj.table) {
+                methodArgs.push(`'${argsObj.table}'`);
+            }
+            if (argsObj.foreignPivotKey) {
+                methodArgs.push(`'${argsObj.foreignPivotKey}'`);
+            }
+            if (argsObj.relatedPivotKey) {
+                methodArgs.push(`'${argsObj.relatedPivotKey}'`);
+            }
+            if (argsObj.parentKey) {
+                methodArgs.push(`'${argsObj.parentKey}'`);
+            }
+            if (argsObj.relatedKey) {
+                methodArgs.push(`'${argsObj.relatedKey}'`);
+            }
+            if (argsObj.morphType) {
+                methodArgs.push(`'${argsObj.morphType}'`);
+            }
+            if (argsObj.morphClass) {
+                // 只使用模型名称
+                const morphClassName = argsObj.morphClass.split('\\').pop();
+                methodArgs.push(`${morphClassName}::class`);
+            }
+        } else if (relationshipMethod === 'morphToOne') {
+            // morphToOne 处理
+            if (argsObj.name) {
+                methodArgs.push(`'${argsObj.name}'`);
+            }
+            if (argsObj.type) {
+                methodArgs.push(`'${argsObj.type}'`);
+            }
+            if (argsObj.id) {
+                methodArgs.push(`'${argsObj.id}'`);
+            }
+            if (argsObj.morphClass) {
+                const morphClassName = argsObj.morphClass.split('\\').pop();
+                methodArgs.push(`${morphClassName}::class`);
+            }
+            if (argsObj.localKey) {
+                methodArgs.push(`'${argsObj.localKey}'`);
+            }
+        } else {
+            // morphOne 和 morphMany 处理
+            if (argsObj.name) {
+                methodArgs.push(`'${argsObj.name}'`);
+            }
+            if (argsObj.type) {
+                methodArgs.push(`'${argsObj.type}'`);
+            }
+            if (argsObj.id) {
+                methodArgs.push(`'${argsObj.id}'`);
+            }
+            if (argsObj.localKey) {
+                methodArgs.push(`'${argsObj.localKey}'`);
+            }
+            if (argsObj.morphClass) {
+                // 只使用模型名称
+                const morphClassName = argsObj.morphClass.split('\\').pop();
+                methodArgs.push(`${morphClassName}::class`);
+            }
+        }
+    } else {
+        // 普通关系参数处理
+        if (argsObj.foreignKey) {
+            methodArgs.push(`'${argsObj.foreignKey}'`);
+        }
+        if (argsObj.localKey) {
+            methodArgs.push(`'${argsObj.localKey}'`);
+        }
+        
+        // belongsTo 额外参数
+        if (relationshipMethod === 'belongsTo' && argsObj.ownerKey) {
+            methodArgs.push(`'${argsObj.ownerKey}'`);
+        }
+        
+        // belongsToMany 额外参数
+        if (relationshipMethod === 'belongsToMany') {
+            if (argsObj.table) {
+                methodArgs.push(`'${argsObj.table}'`);
+            }
+            if (argsObj.foreignPivotKey) {
+                methodArgs.push(`'${argsObj.foreignPivotKey}'`);
+            }
+            if (argsObj.relatedPivotKey) {
+                methodArgs.push(`'${argsObj.relatedPivotKey}'`);
+            }
+            if (argsObj.parentKey) {
+                methodArgs.push(`'${argsObj.parentKey}'`);
+            }
+            if (argsObj.relatedKey) {
+                methodArgs.push(`'${argsObj.relatedKey}'`);
+            }
+        }
+        
+        // through 关系额外参数
+        if (relationshipMethod.includes('Through')) {
+            if (argsObj.through) {
+                // 只使用模型名称
+                const throughModelName = argsObj.through.split('\\').pop();
+                methodArgs.push(`${throughModelName}::class`);
+            }
+            if (argsObj.firstKey) {
+                methodArgs.push(`'${argsObj.firstKey}'`);
+            }
+            if (argsObj.secondKey) {
+                methodArgs.push(`'${argsObj.secondKey}'`);
+            }
+            if (argsObj.localKey) {
+                methodArgs.push(`'${argsObj.localKey}'`);
+            }
+            if (argsObj.secondLocalKey) {
+                methodArgs.push(`'${argsObj.secondLocalKey}'`);
+            }
+            if (argsObj.farKey) {
+                methodArgs.push(`'${argsObj.farKey}'`);
+            }
+        }
+        
+        // hasManyThroughMany 特殊参数
+        if (relationshipMethod === 'hasManyThroughMany') {
+            if (argsObj.through) {
+                const throughModelName = argsObj.through.split('\\').pop();
+                methodArgs.push(`${throughModelName}::class`);
+            }
+            if (argsObj.firstKey) {
+                methodArgs.push(`'${argsObj.firstKey}'`);
+            }
+            if (argsObj.secondKey) {
+                methodArgs.push(`'${argsObj.secondKey}'`);
+            }
+            if (argsObj.localKey) {
+                methodArgs.push(`'${argsObj.localKey}'`);
+            }
+            if (argsObj.secondLocalKey) {
+                methodArgs.push(`'${argsObj.secondLocalKey}'`);
+            }
+        }
+        
+        // hasOneOfMany 特殊参数
+        if (relationshipMethod === 'hasOneOfMany') {
+            if (argsObj.aggregate) {
+                methodArgs.push(`'${argsObj.aggregate}'`);
+            }
+            if (argsObj.column) {
+                methodArgs.push(`'${argsObj.column}'`);
+            }
+        }
+    }
+
+    // 构建方法链
+    let methodChain = relationshipMethod;
+    
+    // 软删除相关
+    if (argsObj.withTrashed) {
+        methodChain += '->withTrashed()';
+    } else if (argsObj.onlyTrashed) {
+        methodChain += '->onlyTrashed()';
+    } else {
+        methodChain += '';
+    }
+    
+    // 生成方法代码
+    return `    /**
+     * @Author FelixYin
+     * @description ${remark}
+     */
+    public function ${toCamelCase(title)}()
+    {
+        return $this->${methodChain}(${methodArgs.join(', ')});
+    }`;
+}
+
+// 查找类的边界（开始和结束行）
+function findClassBoundaries(lines) {
+    let classStartLine = -1;
+    let classEndLine = -1;
+    let braceCount = 0;
+    let foundClass = false;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes('class ')) {
+            classStartLine = i;
+            foundClass = true;
+        }
+        if (foundClass) {
+            braceCount += (line.match(/{/g) || []).length;
+            braceCount -= (line.match(/}/g) || []).length;
+            if (braceCount === 0 && line.includes('}')) {
+                classEndLine = i;
+                break;
+            }
+        }
+    }
+
+    if (classStartLine === -1 || classEndLine === -1) {
+        throw new Error('无效的PHP类格式');
+    }
+
+    return { start: classStartLine, end: classEndLine };
+}
+
+// 在类中查找特定方法
+function findMethodInClass(lines, methodName, classStart, classEnd) {
+    let methodStartLine = -1;
+    let methodEndLine = -1;
+    let braceCount = 0;
+    let inMethod = false;
+
+    // 向上查找注释的起始位置
+    function findCommentStart(startLine) {
+        let line = startLine;
+        while (line >= classStart) {
+            if (!lines[line].trim().startsWith('*') && !lines[line].trim().startsWith('/*')) {
+                return line + 1;
+            }
+            line--;
+        }
+        return startLine;
+    }
+
+    for (let i = classStart; i <= classEnd; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('public function') && line.includes(`function ${methodName}`)) {
+            methodStartLine = findCommentStart(i - 1);
+            inMethod = true;
+        }
+        if (inMethod) {
+            braceCount += (line.match(/{/g) || []).length;
+            braceCount -= (line.match(/}/g) || []).length;
+            if (braceCount === 0 && line.includes('}')) {
+                methodEndLine = i;
+                break;
+            }
+        }
+    }
+
+    if (methodStartLine === -1 || methodEndLine === -1) {
+        return null;
+    }
+
+    return { start: methodStartLine, end: methodEndLine };
+}
+
+// 更新模型文件
+async function updateModelFile(modelPath, methodCode, title) {
+    try {
+        // 检查文件是否存在
+        if (!fs.existsSync(modelPath)) {
+            console.error(`未找到模型文件: ${modelPath}`);
+            return;
+        }
+
+        // 读取文件内容并按行分割
+        let lines = fs.readFileSync(modelPath, 'utf8').split('\n');
+        
+        // 查找类的边界
+        const classBoundaries = findClassBoundaries(lines);
+        
+        // 在类边界内查找现有方法
+        const existingMethod = findMethodInClass(lines, toCamelCase(title), classBoundaries.start, classBoundaries.end);
+        
+        // 将新方法代码分割成行
+        const newLines = methodCode.split('\n');
+        
+        if (existingMethod) {
+            // 替换现有方法
+            lines.splice(existingMethod.start, existingMethod.end - existingMethod.start + 1);
+            
+            // 确保方法前有一个空行
+            if (existingMethod.start === 0 || lines[existingMethod.start - 1].trim() !== '') {
+                lines.splice(existingMethod.start, 0, '', ...newLines);
+            } else {
+                lines.splice(existingMethod.start, 0, ...newLines);
+            }
+        } else {
+            // 在类结束前添加新方法
+            let insertPosition = classBoundaries.end;
+            
+            // 如果前一行不是空行，添加一个空行
+            if (lines[insertPosition - 1].trim() !== '') {
+                lines.splice(insertPosition, 0, '', ...newLines);
+            } else {
+                // 如果前一行是空行，直接添加方法
+                lines.splice(insertPosition, 0, ...newLines);
+            }
+        }
+
+        // 清理多余的空行
+        let cleanedLines = [];
+        let lastLineEmpty = false;
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            const isEmpty = line === '';
+
+            // 如果当前行不为空，或者（当前行为空但前一行不为空）
+            if (!isEmpty || !lastLineEmpty) {
+                cleanedLines.push(lines[i]);
+            }
+            lastLineEmpty = isEmpty;
+        }
+
+        // 将更新后的内容写回文件
+        fs.writeFileSync(modelPath, cleanedLines.join('\n'), 'utf8');
+        console.log(`已更新模型文件: ${modelPath}`);
+    } catch (error) {
+        console.error(`更新模型文件 ${modelPath} 时出错:`, error);
+    }
+}
+
+// 主函数
+async function main() {
+    try {
+        // 查询关系数据
+        const [rows] = await db.query('SELECT * FROM admin_relationships');
+        console.log('找到的关系数量:', rows.length);
+        
+        // 遍历每个关系
+        for (const relation of rows) {
+            console.log('正在处理关系:', relation.model);
+            
+            // 将模型命名空间转换为文件路径
+            const modelFile = relation.model
+                .replace('App\\Models\\', '')
+                .replace(/\\/g, '/')
+                + '.php';
+            
+            // 构建完整的模型文件路径
+            const modelPath = path.join('/home/fy/work/xiaoding/owl-admin/app/Models', modelFile);
+            
+            // 生成关系方法代码并更新模型文件
+            const methodCode = generateMethodCode(relation);
+            await updateModelFile(modelPath, methodCode, relation.title);
+        }
+        
+        console.log('已完成模型关系的更新');
+        process.exit(0);
+    } catch (error) {
+        console.error('发生错误:', error);
+        process.exit(1);
+    }
+}
+
+// 执行主函数
+main();

util/db.js

@@ -0,0 +1,16 @@
+const mysql = require('mysql2');
+
+// 创建连接池
+const pool = mysql.createPool({
+    host: '192.168.110.85', // 数据库主机
+    port: 3306, // 数据库端口
+    user: 'xiaoding_test', // 数据库用户名
+    password: '5zWmCxsxsSPt6fH3', // 数据库密码
+    database: 'xiaoding_test', // 数据库名称
+    waitForConnections: true,
+    connectionLimit: 10,
+    queueLimit: 0
+});
+
+// 导出连接池
+module.exports = pool.promise();