6aspec 2.0.0-dev.2

package/.6aspec/script/create_entities_from_markdown.py

@@ -0,0 +1,688 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+从Markdown文档创建实体表的完整流程
+1. 解析Markdown文档获取表结构
+2. 转换为实体JSON格式
+3. 调用HTTP接口创建表
+"""
+
+import os
+import json
+import re
+import argparse
+import uuid
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+import requests
+
+
+# ==================== 第一部分：解析Markdown文档 ====================
+
+def parse_length(length_str: str) -> Optional[int]:
+    """解析长度字段，返回整数或None"""
+    if not length_str or length_str.strip() == '-' or length_str.strip() == '':
+        return None
+    try:
+        return int(length_str.strip())
+    except ValueError:
+        return None
+
+
+def parse_required(required_str: str) -> bool:
+    """解析是否必填字段"""
+    if not required_str:
+        return False
+    required_str = required_str.strip()
+    return required_str == '是' or required_str.lower() == 'true' or required_str == '1'
+
+
+def is_primary_key(description: str) -> bool:
+    """判断是否是主键"""
+    if not description:
+        return False
+    return '主键' in description or 'GUID' in description.upper()
+
+
+def extract_default_value(description: str) -> Optional[Any]:
+    """从字段说明中提取默认值"""
+    if not description:
+        return None
+
+    patterns = [
+        r'默认[为值]?[：:]\s*(\d+)',
+        r'默认[为值]?(\d+)',
+        r'，默认[为值]?[：:]?\s*(\d+)',
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, description)
+        if match:
+            try:
+                return int(match.group(1))
+            except ValueError:
+                return match.group(1)
+
+    return None
+
+
+def parse_table_section(content: str) -> List[Dict[str, Any]]:
+    """解析数据库物理设计部分的所有表结构"""
+
+    # 只匹配「数据库物理设计」章节，不要求「第三步」等前缀（文档格式可能不同）
+    section_pattern = r'###\s*[^#\n]*数据库物理设计[^\n]*\n'
+    match = re.search(section_pattern, content)
+    if not match:
+        raise ValueError("未找到'数据库物理设计'章节")
+
+    start_pos = match.end()
+    next_section = re.search(r'\n###\s+', content[start_pos:])
+    if next_section:
+        section_content = content[start_pos:start_pos + next_section.start()]
+    else:
+        section_content = content[start_pos:]
+
+    tables = []
+    table_pattern = r'#####\s+\d+\.\s+([^(]+)\s*\(([^)]+)\)'
+    table_matches = list(re.finditer(table_pattern, section_content))
+
+    for i, table_match in enumerate(table_matches):
+        table_name_cn = table_match.group(1).strip()
+        table_name = table_match.group(2).strip()
+
+        if i + 1 < len(table_matches):
+            table_end = table_matches[i + 1].start()
+        else:
+            table_end = len(section_content)
+
+        table_section = section_content[table_match.end():table_end]
+
+        table_info_pattern = r'\|\s*表中文名称\s*\|\s*([^|]+)\s*\|\s*\n\|\s*[：:]\s*---\s*\|\s*[：:]\s*---\s*\|\s*\n\|\s*表英文名称\s*\|\s*([^|]+)\s*\|\s*\n\|\s*说明\s*\|\s*([^|]+)\s*\|'
+        table_info_match = re.search(table_info_pattern, table_section)
+
+        if table_info_match:
+            table_name_cn = table_info_match.group(1).strip()
+            table_name = table_info_match.group(2).strip()
+            description = table_info_match.group(3).strip()
+        else:
+            description = ""
+            desc_match = re.search(r'\|\s*说明\s*\|\s*([^|]+)\s*\|', table_section)
+            if desc_match:
+                description = desc_match.group(1).strip()
+
+        fields = []
+        field_table_pattern = r'\|\s*字段中文名称\s*\|\s*字段英文名称\s*\|\s*字段类型\s*\|\s*长度\s*\|\s*是否必填\s*\|\s*字段说明\s*\|'
+        field_table_match = re.search(field_table_pattern, table_section)
+
+        if field_table_match:
+            table_start = field_table_match.end()
+            table_end_match = re.search(r'\n\n|\n---|\n#####', table_section[table_start:])
+            if table_end_match:
+                table_content = table_section[table_start:table_start + table_end_match.start()]
+            else:
+                table_content = table_section[table_start:]
+
+            field_lines = [line.strip() for line in table_content.split('\n') if line.strip() and line.strip().startswith('|')]
+
+            for line in field_lines:
+                if re.match(r'^\|\s*[：:]\s*---', line):
+                    continue
+
+                parts = [p.strip() for p in line.split('|') if p.strip()]
+                if len(parts) >= 6:
+                    field_name_cn = parts[0]
+                    field_name = parts[1]
+                    field_type = parts[2]
+                    length = parse_length(parts[3])
+                    required = parse_required(parts[4])
+                    field_description = parts[5]
+
+                    is_pk = is_primary_key(field_description) or 'GUID' in field_name.upper()
+                    default_value = extract_default_value(field_description)
+
+                    field = {
+                        "fieldName": field_name,
+                        "fieldNameCN": field_name_cn,
+                        "fieldType": field_type,
+                        "length": length,
+                        "required": required,
+                        "description": field_description,
+                        "isPrimaryKey": is_pk
+                    }
+
+                    if default_value is not None:
+                        field["defaultValue"] = default_value
+
+                    fields.append(field)
+
+        table = {
+            "tableName": table_name,
+            "tableNameCN": table_name_cn,
+            "description": description,
+            "fields": fields
+        }
+
+        tables.append(table)
+
+    return tables
+
+
+# ==================== 第二部分：转换为实体JSON ====================
+
+def map_field_type_to_db_type(field_type: str, length: Optional[int]) -> Dict[str, Any]:
+    """将字段类型映射为数据库类型和字段类型"""
+    field_type_lower = field_type.lower()
+
+    if "唯一标识" in field_type or "guid" in field_type_lower:
+        return {
+            "dbType": "uniqueidentifier",
+            "fieldType": "guid",
+            "attributeType": "Guid",
+            "length": None,
+            "decimalPrecision": 0
+        }
+
+    if "单行文本" in field_type:
+        db_length = length if length and length > 0 else 512
+        return {
+            "dbType": "nvarchar",
+            "fieldType": "singleLineText",
+            "attributeType": f"文本（nvarchar({db_length})）",
+            "length": db_length,
+            "decimalPrecision": 0
+        }
+
+    if "多行文本" in field_type:
+        db_length = length if length and length > 0 else -1
+        if db_length > 0 and db_length <= 512:
+            return {
+                "dbType": "nvarchar",
+                "fieldType": "multiLineText",
+                "attributeType": f"文本（nvarchar({db_length})）",
+                "length": db_length,
+                "decimalPrecision": 0
+            }
+        else:
+            return {
+                "dbType": "nvarchar",
+                "fieldType": "multiLineText",
+                "attributeType": "文本（nvarchar(max)）",
+                "length": -1,
+                "decimalPrecision": 0
+            }
+
+    if "日期时间" in field_type or "日期" in field_type or "时间" in field_type:
+        return {
+            "dbType": "datetime",
+            "fieldType": "dateTime",
+            "attributeType": "日期与时间",
+            "length": None,
+            "decimalPrecision": 0
+        }
+
+    if "整数" in field_type:
+        return {
+            "dbType": "int",
+            "fieldType": "digit",
+            "attributeType": "整数",
+            "length": None,
+            "decimalPrecision": 0
+        }
+
+    if "图片" in field_type:
+        return {
+            "dbType": "nvarchar",
+            "fieldType": "picture",
+            "attributeType": "图片",
+            "length": -1,
+            "decimalPrecision": 0
+        }
+
+    db_length = length if length and length > 0 else 512
+    return {
+        "dbType": "nvarchar",
+        "fieldType": "singleLineText",
+        "attributeType": f"文本（nvarchar({db_length})）",
+        "length": db_length,
+        "decimalPrecision": 0
+    }
+
+
+def create_control_config(field_type: str, db_type: str, field_type_name: str,
+                          display_name: str, is_required: bool, length: Optional[int]) -> Dict[str, Any]:
+    """创建控件配置对象"""
+
+    if field_type_name == "guid":
+        return {
+            "$type": "Mysoft.Map6.Metadata.Models.Entity.GuidField, Mysoft.Map6.Metadata.Models",
+            "isRequired": is_required,
+            "displayName": display_name,
+            "fillExample": ""
+        }
+    elif field_type_name == "singleLineText":
+        max_length = length if length and length > 0 else 512
+        return {
+            "$type": "Mysoft.Map6.Metadata.Models.Entity.SingleLineText, Mysoft.Map6.Metadata.Models",
+            "isRequired": is_required,
+            "displayName": display_name,
+            "maxLength": max_length,
+            "fillExample": ""
+        }
+    elif field_type_name == "multiLineText":
+        max_length = length if length and length > 0 else 0
+        return {
+            "$type": "Mysoft.Map6.Metadata.Models.Entity.MultiLineText, Mysoft.Map6.Metadata.Models",
+            "isRequired": is_required,
+            "displayName": display_name,
+            "maxLength": max_length,
+            "fillExample": ""
+        }
+    elif field_type_name == "dateTime":
+        return {
+            "$type": "Mysoft.Map6.Metadata.Models.Entity.DateTimeField, Mysoft.Map6.Metadata.Models",
+            "isRequired": is_required,
+            "displayName": display_name,
+            "format": "yyyy-MM-dd",
+            "fillExample": ""
+        }
+    elif field_type_name == "digit":
+        return {
+            "$type": "Mysoft.Map6.Metadata.Models.Entity.Digit, Mysoft.Map6.Metadata.Models",
+            "isRequired": is_required,
+            "displayName": display_name,
+            "unitText": "",
+            "unitTextType": 0,
+            "fillExample": ""
+        }
+    elif field_type_name == "picture":
+        return {
+            "$type": "Mysoft.Map6.Metadata.Models.Entity.PictureField, Mysoft.Map6.Metadata.Models",
+            "isRequired": is_required,
+            "displayName": display_name,
+            "limitFileCount": 1,
+            "fileLimitSize": 5,
+            "limitType": "*.*",
+            "fillExample": ""
+        }
+
+    return {
+        "$type": "Mysoft.Map6.Metadata.Models.Entity.SingleLineText, Mysoft.Map6.Metadata.Models",
+        "isRequired": is_required,
+        "displayName": display_name,
+        "maxLength": length if length and length > 0 else 512,
+        "fillExample": ""
+    }
+
+
+def convert_field_to_attribute(field: Dict[str, Any], is_primary: bool) -> Dict[str, Any]:
+    """将字段转换为属性格式"""
+
+    field_type = field.get("fieldType", "")
+    length = field.get("length")
+    field_name = field.get("fieldName", "")
+    field_name_cn = field.get("fieldNameCN", "")
+    description = field.get("description", "")
+    required = field.get("required", False)
+    default_value = field.get("defaultValue")
+
+    type_info = map_field_type_to_db_type(field_type, length)
+
+    if is_primary and type_info["fieldType"] == "guid":
+        attr_default_value = "newid()"
+    elif default_value is not None:
+        attr_default_value = str(default_value)
+    else:
+        attr_default_value = ""
+
+    control = create_control_config(
+        field_type,
+        type_info["dbType"],
+        type_info["fieldType"],
+        field_name_cn,
+        required,
+        type_info["length"]
+    )
+
+    attribute = {
+        "attributeType": type_info["attributeType"],
+        "defaultValue": attr_default_value,
+        "dbType": type_info["dbType"],
+        "decimalPrecision": type_info["decimalPrecision"],
+        "fieldType": type_info["fieldType"],
+        "control": control,
+        "displayName": field_name_cn,
+        "name": field_name,
+        "remark": description,
+        "isPrimaryAttribute": is_primary,
+        "isNullable": not required,
+        "curEntityState": "modify",
+        "entityState": "Created"
+    }
+
+    if type_info["length"] is not None:
+        attribute["length"] = type_info["length"]
+
+    return attribute
+
+
+def convert_table_to_entity(table: Dict[str, Any], application: str, function_guid: str) -> Dict[str, Any]:
+    """将表转换为实体格式"""
+
+    table_name = table.get("tableName", "")
+    table_name_cn = table.get("tableNameCN", "")
+    description = table.get("description", "")
+    fields = table.get("fields", [])
+
+    primary_key_field = None
+    primary_key_name = None
+    for field in fields:
+        if field.get("isPrimaryKey", False):
+            primary_key_field = field
+            primary_key_name = field.get("fieldName", "")
+            break
+
+    if not primary_key_name:
+        for field in fields:
+            if "GUID" in field.get("fieldName", "").upper() or "唯一标识" in field.get("fieldType", ""):
+                primary_key_name = field.get("fieldName", "")
+                primary_key_field = field
+                break
+        if not primary_key_name and fields:
+            primary_key_name = fields[0].get("fieldName", "")
+            primary_key_field = fields[0]
+
+    attributes = []
+    for field in fields:
+        field_name = field.get("fieldName", "")
+        if field_name == primary_key_name:
+            continue
+        is_primary = False
+        attribute = convert_field_to_attribute(field, is_primary)
+        attributes.append(attribute)
+
+    primary_key_display_name = ""
+    if primary_key_field:
+        primary_key_display_name = primary_key_field.get("fieldNameCN", "")
+
+    entity = {
+        "entity": {
+            "application": application,
+            "functionGUID": function_guid,
+            "displayName": table_name_cn + "\n",
+            "name": table_name,
+            "primaryKeyName": primary_key_name,
+            "isOpenApprove": False,
+            "isEnableIsolateForCompany": False,
+            "enableFieldAttribute": True,
+            "scope": "current",
+            "remark": description,
+            "attributes": attributes
+        },
+        "primaryKeyDisplayName": primary_key_display_name + " ",
+        "primaryKeyRemark": ""
+    }
+
+    return entity
+
+
+def convert_tables_to_entities(tables: List[Dict[str, Any]], application: str, function_guid: str) -> List[Dict[str, Any]]:
+    """将表列表转换为实体列表"""
+    return [convert_table_to_entity(table, application, function_guid) for table in tables]
+
+
+# ==================== 第三部分：HTTP请求 ====================
+
+def load_config_from_file() -> Dict[str, str]:
+    """从用户目录下的.6aspec/modeling_env文件读取配置"""
+    config = {}
+    config_file = Path.home() / '.6aspec' / 'modeling_env'
+
+    if config_file.exists():
+        try:
+            with open(config_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith('#'):
+                        continue
+                    if '=' in line:
+                        key, value = line.split('=', 1)
+                        key = key.strip()
+                        value = value.strip()
+                        # 只保存非空值
+                        if value:
+                            config[key] = value
+        except Exception:
+            # 读取配置文件失败，忽略错误，继续使用环境变量
+            pass
+
+    return config
+
+
+def get_host() -> str:
+    """从环境变量或配置文件获取host，如果没有则返回默认值"""
+    # 首先尝试从环境变量获取
+    host = os.environ.get('MODELING_HOST')
+    if host:
+        return host
+
+    # 如果环境变量没有，尝试从配置文件读取
+    config = load_config_from_file()
+    host = config.get('MODELING_HOST')
+    if host:
+        return host
+
+    # 都没有则返回默认值
+    return 'localhost'
+
+
+def get_cookie() -> str:
+    """从环境变量或配置文件获取Cookie，如果没有则抛出异常"""
+    # 首先尝试从环境变量获取
+    cookie = os.environ.get('MODELING_COOKIE')
+    if cookie:
+        return cookie
+
+    # 如果环境变量没有，尝试从配置文件读取
+    config = load_config_from_file()
+    cookie = config.get('MODELING_COOKIE')
+    if cookie:
+        return cookie
+
+    # 都没有则抛出异常
+    raise ValueError(
+        "错误：未配置Cookie\n"
+        "请通过以下方式之一配置：\n"
+        "1. 设置环境变量 MODELING_COOKIE\n"
+        "   例如：export MODELING_COOKIE='your_cookie_value'\n"
+        "2. 在 ~/.6aspec/modeling_env 文件中配置\n"
+        "   例如：MODELING_COOKIE=your_cookie_value"
+    )
+
+
+def send_create_entity_request(
+        design_data: str,
+        host: Optional[str] = None,
+        port: int = 9300,
+        cookie: Optional[str] = None
+) -> requests.Response:
+    """发送创建实体请求"""
+    if host is None:
+        host = get_host()
+
+    if cookie is None:
+        cookie = get_cookie()
+
+    url = f"http://{host}:{port}/ajax/Mysoft.Map6.Modeling.Handlers.EntityHandler/CreateEntity"
+
+    headers = {
+        'Accept': 'application/json, text/plain, */*',
+        'Accept-Language': 'zh-CN,zh;q=0.9',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Origin': f'http://{host}:{port}',
+        'Pragma': 'no-cache',
+        'Referer': f'http://{host}:{port}/modeling/entity/importField?func=08de639b-1271-4b5b-8cdb-e7e67fe64bb8&appCode=8906',
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36',
+        'X-Requested-With': 'XMLHttpRequest',
+        'work-mode': 'design',
+        'Cookie': cookie
+    }
+
+    data = {
+        'designData': design_data
+    }
+
+    response = requests.post(url, headers=headers, data=data)
+    return response
+
+
+# ==================== 主流程 ====================
+
+def main():
+    parser = argparse.ArgumentParser(description='从Markdown文档创建实体表的完整流程')
+    parser.add_argument('markdown_file', type=str, help='Markdown文档路径')
+    parser.add_argument('-a', '--application', type=str, required=True, help='应用ID（必填）')
+    parser.add_argument('-g', '--function-guid', type=str, required=True, help='functionGUID（必填）')
+    parser.add_argument('-H', '--host', type=str, help='服务器地址（默认从环境变量MODELING_HOST获取，否则使用localhost）')
+    parser.add_argument('-p', '--port', type=int, default=9300, help='服务器端口（默认：9300）')
+    parser.add_argument('-c', '--cookie', type=str, help='Cookie值（默认从环境变量MODELING_COOKIE获取）')
+    parser.add_argument('-v', '--verbose', action='store_true', help='显示详细响应信息')
+
+    args = parser.parse_args()
+
+    # 步骤1：读取并解析Markdown文档
+    print("=" * 60)
+    print("步骤1：解析Markdown文档...")
+    print("=" * 60)
+
+    md_path = Path(args.markdown_file)
+    if not md_path.exists():
+        print(f"错误：文件不存在: {args.markdown_file}")
+        return 1
+
+    try:
+        with open(md_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except Exception as e:
+        print(f"错误：读取文件失败: {e}")
+        return 1
+
+    try:
+        tables = parse_table_section(content)
+        print(f"✓ 成功解析 {len(tables)} 个表")
+        for i, table in enumerate(tables, 1):
+            print(f"  {i}. {table['tableName']} - {table['tableNameCN']}")
+    except Exception as e:
+        print(f"错误：解析失败: {e}")
+        return 1
+
+    # 步骤2：转换为实体JSON
+    print("\n" + "=" * 60)
+    print("步骤2：转换为实体JSON格式...")
+    print("=" * 60)
+
+    try:
+        entities = convert_tables_to_entities(tables, args.application, args.function_guid)
+        print(f"✓ 成功转换 {len(entities)} 个实体")
+    except Exception as e:
+        print(f"错误：转换失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+    # 步骤3：批量发送HTTP请求创建表
+    print("\n" + "=" * 60)
+    print("步骤3：批量创建实体表...")
+    print("=" * 60)
+
+    total = len(entities)
+    success_count = 0
+    fail_count = 0
+
+    print(f"检测到 {total} 个实体，开始批量发送...\n")
+
+    for index, entity in enumerate(entities, 1):
+        try:
+            entity_name = entity.get('entity', {}).get('name', f'实体#{index}')
+            print(f"[{index}/{total}] 处理实体: {entity_name}")
+
+            design_data = json.dumps(entity, ensure_ascii=False)
+
+            response = send_create_entity_request(
+                design_data=design_data,
+                host=args.host,
+                port=args.port,
+                cookie=args.cookie
+            )
+
+            if response.status_code == 200:
+                try:
+                    response_json = response.json()
+                    if response_json.get('isBusinessLogicError', False):
+                        fail_count += 1
+                        error_msg = response_json.get('exception', {}).get('message', '未知错误')
+                        print(f"  ✗ 失败: {error_msg}")
+                        if args.verbose:
+                            print(f"  响应: {json.dumps(response_json, ensure_ascii=False, indent=2)}")
+                    elif 'entityId' in response_json:
+                        success_count += 1
+                        entity_id = response_json.get('entityId', '')
+                        if args.verbose:
+                            print(f"  ✓ 成功: entityId={entity_id}")
+                            print(f"  响应: {json.dumps(response_json, ensure_ascii=False, indent=2)}")
+                        else:
+                            print(f"  ✓ 成功: entityId={entity_id}")
+                    else:
+                        if 'exception' in response_json:
+                            fail_count += 1
+                            error_msg = response_json.get('exception', {}).get('message', '未知错误')
+                            print(f"  ✗ 失败: {error_msg}")
+                        else:
+                            success_count += 1
+                            print(f"  ✓ 成功")
+                        if args.verbose:
+                            print(f"  响应: {json.dumps(response_json, ensure_ascii=False, indent=2)}")
+                except json.JSONDecodeError:
+                    fail_count += 1
+                    print(f"  ✗ 失败: 响应不是有效的JSON格式")
+                    if args.verbose:
+                        print(f"  响应: {response.text[:200]}")
+            else:
+                fail_count += 1
+                print(f"  ✗ 失败: HTTP状态码 {response.status_code}")
+                if args.verbose:
+                    try:
+                        response_json = response.json()
+                        print(f"  响应: {json.dumps(response_json, ensure_ascii=False, indent=2)}")
+                    except json.JSONDecodeError:
+                        print(f"  响应: {response.text[:200]}")
+
+        except ValueError as e:
+            print(f"  ✗ 错误: {str(e)}")
+            return 1
+        except requests.exceptions.RequestException as e:
+            fail_count += 1
+            print(f"  ✗ 请求失败: {e}")
+        except Exception as e:
+            fail_count += 1
+            print(f"  ✗ 处理失败: {e}")
+            if args.verbose:
+                import traceback
+                traceback.print_exc()
+
+        print()
+
+    # 输出最终结果
+    print("=" * 60)
+    print("批量处理完成:")
+    print(f"  总计: {total}")
+    print(f"  成功: {success_count}")
+    print(f"  失败: {fail_count}")
+    print("=" * 60)
+
+    return 0 if fail_count == 0 else 1
+
+
+if __name__ == '__main__':
+    exit(main())

package/.claude/commands/6aspec/brown/archive.md

@@ -0,0 +1,11 @@
+---
+name: "6aspec:brown: Archive"
+description: 归档已完成的需求
+category: Workflow
+tags: [workflow, requirement, archive]
+---
+
+1. Immediate response upon activation: brown field requirement workflow - **Archive** has been activated
+2. **Read and strictly follow the brown field constitution**: `.6aspec/rules/brown/brown_constitution.md`
+3. Read file: `.6aspec/rules/brown/brown_archive_sop.md`
+4. Strictly follow the SOP defined in that file