fastcodedog 0.1.0__tar.gz

fastcodedog-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: fastcodedog
+Version: 0.1.0
+Summary: 
+License: MIT
+Author: taohoo
+Author-email: taohoo@163.com
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: autopep8 (>=2.2.0)
+Requires-Dist: fastapi (>=0.100.0)
+Requires-Dist: fastoauth (>=0.1.0)
+Requires-Dist: inflect (>=7.2.1)
+Requires-Dist: json5 (>=0.9.25)
+Requires-Dist: psycopg2[binary] (>=2.9.5)
+Requires-Dist: pydantic (>=1.10.10)
+Requires-Dist: pyopenssl (>=24.0.0)
+Requires-Dist: python-jose (>=3.3.0)
+Requires-Dist: python-multipart (>=0.0.9)
+Requires-Dist: redis (>=5.0.5)
+Requires-Dist: sqlalchemy (>=2.0.23)
+Requires-Dist: uvicorn (>=0.30.0)
+Description-Content-Type: text/markdown
+
+基于pdm文件，自动生成fastapi工程。
+包括sqlalchemy的model，crud。
+fastapi的schema，api。

fastcodedog-0.1.0/README.md

@@ -0,0 +1,3 @@
+基于pdm文件，自动生成fastapi工程。
+包括sqlalchemy的model，crud。
+fastapi的schema，api。

fastcodedog-0.1.0/fastcodedog/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

fastcodedog-0.1.0/fastcodedog/api/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

fastcodedog-0.1.0/fastcodedog/api/api.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+from fastcodedog.context.context_instance import ctx_instance
+from fastcodedog.crud.param import Param
+from fastcodedog.generation.file import File
+from fastcodedog.generation.function_block import FunctionBlock
+from fastcodedog.generation.variable import Variable
+from fastcodedog.util.case_converter import camel_to_snake
+from .app_function import AppFunction
+from .oauth import enable_api_oauth2
+from ..util.inflect_wrapper import plural
+
+
+class Api(File):
+    def __init__(self, crud, path, package, desc=None):
+        super().__init__(path, package, desc)
+        self.code = crud.code
+        self.crud = crud
+        self.schema = self.crud.schema
+        self.model = self.schema.model
+        self.schema_additional = ctx_instance.schema_additional_package.shcema_additionals.get(self.code)
+
+        # 需要计算属性
+        self.response_model = None
+        self.response_model_list = None
+        self.validate_response_function = None  # 可用于判断是否有多个返回值
+        self.extra_function_params = {}  # 额外请求参数，比如session，每个请求中都隐含
+        self.extra_function_params_when_get = {}  # get请求的额外参数，比如response_model, session
+        self.extra_function_params_when_get_list = {}  # get请求列表的额外参数，比如skip, limit, response_model, session
+
+        # 计算属性
+        self._init_import_stmt()
+        self._init_variable()  # 会同步计算response_model、response_model_list和validate_response_model
+        self._init_properties()
+        # 检查是否启用oauth2
+        enable_api_oauth2(self)
+        self._init_method()
+
+    def _init_method(self):
+        for function_block in self.crud.function_blocks.values():
+            method = self.get_app_method(function_block.option)
+            model_id_name = camel_to_snake(self.model.class_name) + '_id'
+            url = f'/{plural(camel_to_snake(self.model.class_name))}' if function_block.return_list else f'/{camel_to_snake(self.model.class_name)}'
+            if not function_block.return_list and model_id_name in function_block.params.keys():
+                url += '/{' + model_id_name + '}'
+            if function_block.query_name:
+                url += '/' + camel_to_snake(function_block.query_name)
+            elif function_block.schema_additional_name:
+                url += '/' + camel_to_snake(function_block.schema_additional_name)
+            elif function_block.sub_object_name:
+                url += '/' + camel_to_snake(function_block.sub_object_name)
+            app_func = AppFunction(function_block.name, self, method, url)
+            app_func.params = {k: v for k, v in function_block.params.items() if
+                               k not in self.extra_function_params.keys()}
+            for k, v in function_block.params.items():
+                if k in self.extra_function_params.keys():
+                    continue
+                app_func.params[k] = Param(k, parent=self, default=v.default, nullable=v.nullable,
+                                           type=v.type if not v.schema_class_block else v.schema_class_block.name)
+
+            app_func.content = f'crud.{function_block.name}(' + ', '.join(
+                [f'{k}={v.code}' for k, v in function_block.params.items()]) + ')'
+            if function_block.return_list:
+                app_func.reponse_model = self.response_model_list
+                app_func.params.update(self.extra_function_params_when_get_list)
+                if self.validate_response_function:
+                    app_func.content = f'return [response_model.from_orm({camel_to_snake(self.model.class_name)}) for {camel_to_snake(self.model.class_name)} in {app_func.content}]'
+                else:
+                    app_func.content = f'return {app_func.content}'
+            elif method != 'delete':
+                app_func.reponse_model = self.response_model
+                app_func.params.update(self.extra_function_params_when_get)
+                if self.validate_response_function:
+                    app_func.content = f'return response_model.from_orm({app_func.content})'
+                else:
+                    app_func.content = f'return {app_func.content}'
+            else:
+                app_func.params.update(self.extra_function_params)
+            app_func.content += '\n'
+            self.function_blocks[app_func.name] = app_func
+            ...
+
+    def get_app_method(self, option):
+        if option == 'get':
+            return 'get'
+        if option == 'create':
+            return 'post'
+        if option == 'update':
+            return 'put'
+        if option == 'delete':
+            return 'delete'
+
+    def _init_properties(self):
+        # 要先初始化_init_variable，确保validate_response_function已经被正确设置
+        self.extra_function_params['session'] = Param('session', parent=self, type='Session',
+                                                      default='Depends(get_session)')
+        if self.validate_response_function:
+            self.extra_function_params_when_get['response_model'] = Param('response_model', parent=self,
+                                                                          type='BaseModel',
+                                                                          default=f'Depends({self.validate_response_function})')
+        self.extra_function_params_when_get.update(self.extra_function_params)
+        # self.extra_function_params_when_get_list['skip'] = Param('skip', parent=self, type='int', default=0)
+        # self.extra_function_params_when_get_list['limit'] = Param('limit', parent=self, type='int', default=50)
+        self.extra_function_params_when_get_list.update(self.extra_function_params_when_get)
+
+    def _init_variable(self):
+        self.variables['app'] = Variable('app', parent=self, default='FastAPI()')
+        response_class_blocks = []
+        for class_block in self.schema.class_blocks.values():
+            if class_block.method == 'response':
+                response_class_blocks.append(class_block)
+        # 所有的schema_additional
+        if self.schema_additional:
+            for class_block in self.schema_additional.class_blocks.values():
+                if class_block.method == 'response':
+                    response_class_blocks.append(class_block)
+        if len(response_class_blocks) == 1:
+            self.response_model = response_class_blocks[0].name
+            self.response_model_list = f'list[{response_class_blocks[0].name}]'
+        elif len(response_class_blocks) > 1:
+            self.response_model = f'ALL_{self.model.class_name.upper()}_RESPONSE_MODEL'
+            self.response_model_list = f'ALL_{self.model.class_name.upper()}_LIST_RESPONSE_MODEL'
+            self.variables[self.response_model] = Variable(self.response_model, parent=self, type='Union',
+                                                           default=f'Union[{", ".join([response_class_block.name for response_class_block in response_class_blocks])}]')
+            self.variables[self.response_model_list] = Variable(self.response_model_list, parent=self, type='Union',
+                                                                default=f'Union[{", ".join(["list[" + response_class_block.name + "]" for response_class_block in response_class_blocks])}]')
+            self._add_validate_response_model_function(response_class_blocks)
+
+    def _add_validate_response_model_function(self, response_class_blocks):
+        function_name = f'validate_{self.model.class_name.lower()}_response_model'
+        function = FunctionBlock(function_name, parent=self)
+        request_allow = [f"'{camel_to_snake(response_class_block.name)}'" for response_class_block in
+                         response_class_blocks]
+        param_default = f"Query(None, description=\"指定返回的数据类型，默认为'{camel_to_snake(self.model.class_name)}'\", enum=[{', '.join(request_allow)}])"
+        function.params['response_model'] = Param('response_model', parent=function, type='str', default=param_default)
+        function.content = f"""if response_model and response_model not in [{', '.join(request_allow)}]:
+    raise HTTPException(status_code=400,
+        detail="Invalid response_model. Must in {', '.join(request_allow)}.")
+"""
+        for class_block in response_class_blocks:
+            function.content += f"if response_model == '{camel_to_snake(class_block.name)}':\n"
+            function.content += f"    return {class_block.name}\n"
+        function.content += f"return {self.model.class_name}\n"
+
+        self.validate_response_function = function_name
+        self.function_blocks[function_name] = function
+
+    def _init_import_stmt(self):
+        self.import_stmt.add_import('fastapi', 'FastAPI')
+        self.import_stmt.add_import('fastapi', 'Depends')
+        self.import_stmt.add_import('pydantic', 'BaseModel')
+        self.import_stmt.add_import(ctx_instance.base.package, ctx_instance.base.class_name)
+        self.import_stmt.add_import(f'{ctx_instance.project_package}.db', 'Session')
+        self.import_stmt.add_import(f'{ctx_instance.project_package}.db', 'get_session')
+        self.import_stmt.add_import(from_=None, import_=self.crud.package, as_='crud')
+        response_model_count = 0
+        # 所有的schema
+        for class_block in self.schema.class_blocks.values():
+            if class_block.method in ['response', 'create', 'update']:
+                self.import_stmt.add_import(self.schema.package, class_block.name)
+                for attribute in class_block.attributes.values():
+                    if attribute.nullable:
+                        self.import_stmt.add_import('typing', 'Optional')
+                if class_block.method == 'response':
+                    response_model_count += 1
+        # 所有的schema_additional
+        if self.schema_additional:
+            for class_block in self.schema_additional.class_blocks.values():
+                self.import_stmt.add_import(self.schema_additional.package, class_block.name)
+                for attribute in class_block.attributes.values():
+                    if attribute.nullable:
+                        self.import_stmt.add_import('typing', 'Optional')
+                if class_block.method == 'response':
+                    response_model_count += 1
+        if response_model_count > 1:
+            self.import_stmt.add_import('typing', 'Union')
+            self.import_stmt.add_import('fastapi', 'Query')
+            self.import_stmt.add_import('fastapi', 'HTTPException')

fastcodedog-0.1.0/fastcodedog/api/api_package.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+import os
+
+from fastcodedog.api.api import Api
+from fastcodedog.api.config import Config
+from fastcodedog.api.db import Db
+from fastcodedog.api.main import Main
+from fastcodedog.api.oauth import OAuth
+from fastcodedog.context.context_instance import ctx_instance
+from fastcodedog.generation.package import Package
+from fastcodedog.util.case_converter import camel_to_snake
+
+
+class ApiPackage(Package):
+    def __init__(self):
+        self.package = f'{ctx_instance.project_package}.api'
+        self.dir = os.path.join(ctx_instance.project_dir, 'api')
+
+        self.config_dir = os.path.join(ctx_instance.project_dir, 'config')
+
+        # 固定的文件
+        self.config = Config(os.path.join(self.config_dir, 'config.py'), f'{ctx_instance.project_package}.config')
+        self.db = Db(os.path.join(ctx_instance.project_dir, 'db.py'), f'{ctx_instance.project_package}.db')
+        self.main = Main(os.path.join(ctx_instance.project_dir, 'main.py'), f'{ctx_instance.project_package}.main')
+        self.oauth = OAuth(os.path.join(self.dir, 'oauth', 'oauth.py'),
+                           f'{self.package}.oauth.oauth') if ctx_instance.oauth2.enabled else None
+        # 计算属性
+        self.apis = {}
+
+        for code, crud in ctx_instance.crud_package.cruds.items():
+            table = crud.schema.model.table
+            path = os.path.join(self.dir, table.module, self.get_file_name(table))
+            package = f'{self.package}.{table.module}.{camel_to_snake(self.get_class_name(table))}'
+            api = Api(crud, path, package)
+            self.apis[code] = api
+
+        for api in self.apis.values():
+            self.main.add_api(api)
+        if self.oauth:
+            self.main.add_api(self.oauth, as_='oauth_app')
+
+    def save(self):
+        self.config.save()
+        self.db.save()
+        for api in self.apis.values():
+            api.save()
+        self.main.save()
+        if self.oauth:
+            self.oauth.save()

fastcodedog-0.1.0/fastcodedog/api/app_function.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+from fastcodedog.generation.function_block import FunctionBlock
+from fastcodedog.util.indent import add_indent
+
+
+class AppFunction(FunctionBlock):
+    def __init__(self, name, parent, method, url, reponse_model=None, response_model_exclude_none=True, params=None):
+        super().__init__(name, parent, params)
+        self.method = method
+        self.url = url
+        self.reponse_model = reponse_model
+        self.response_model_exclude_none = response_model_exclude_none
+
+    def serialize(self, indent=''):
+        app_params = [f"'{self.url}'"]
+        if self.reponse_model:
+            app_params.append(f'response_model={self.reponse_model}')
+            if self.response_model_exclude_none:
+                app_params.append('response_model_exclude_none=True')
+        content = f'@app.{self.method}({", ".join(app_params)})\n'
+        content += super().serialize()
+        return add_indent(content, indent)

fastcodedog-0.1.0/fastcodedog/api/config.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+
+from fastcodedog.generation.file import File
+from fastcodedog.generation.function_block import FunctionBlock
+from fastcodedog.generation.variable import Variable
+
+
+class Config(File):
+    def __init__(self, path, package, desc=None):
+        super().__init__(path, package, desc)
+        self.config_file = path[:-3] + '.ini'
+        self.config_content = self._get_config_content()
+        self._init_import_stmt()
+        self._init_funciton()
+        self._init_variables()
+
+    def _init_variables(self):
+        self.variables['_all_configs_'] = Variable('_all_configs_', self, type=dict, default={})
+        self.variables['listion_port'] = Variable('listion_port', self, type='function',
+                                                  default="get_config('app', 'port', 8000)")
+        self.variables['db_url'] = Variable('db_url', self, type='function',
+                                            default="get_config('database', 'url', None)")
+
+    def _init_funciton(self):
+        func = FunctionBlock('get_config', self)
+        func.params['section'] = Variable('section', func)
+        func.params['key'] = Variable('key', func)
+        func.params['default'] = Variable('default', func, default=None)
+        func.content = f"""c_key = f'{{section}}.{{key}}'
+if c_key not in _all_configs_:
+    confif_file = os.path.join(os.path.dirname(__file__), 'config.ini')
+    config = configparser.ConfigParser()
+    config.read(confif_file)
+    _all_configs_[c_key] = None
+    if section in config and config.get(section, key):
+        _all_configs_[c_key] = config.get(section, key)
+if c_key in _all_configs_ and _all_configs_[c_key] is not None:
+    return _all_configs_[c_key]
+return default
+"""
+        self.function_blocks['get_config'] = func
+
+    def _init_import_stmt(self):
+        self.import_stmt.add_import(from_=None, import_='configparser')
+        self.import_stmt.add_import(from_=None, import_='os')
+
+    def _get_config_content(self):
+        return """[app]
+port=8000
+
+[database]
+url=postgresql://ccuser:Cc_12345678@192.168.44.128:15432/ccdb
+"""
+
+    def serialize(self):
+        content = self.annotation_stmt.serialize()
+        content += self.import_stmt.serialize()
+        content += '\n'
+        content += self.serialize_function_blocks()
+        content += self.serialize_variable_stmt()
+        content += self.serialize_class_blocks()
+        return content
+
+    def save(self):
+        super().save()
+        # 写一份配置文件
+        with open(self.config_file, 'w', encoding='utf-8') as f:
+            f.write(self.config_content)

fastcodedog-0.1.0/fastcodedog/api/db.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+from fastcodedog.generation.file import File
+from fastcodedog.generation.function_block import FunctionBlock
+from fastcodedog.generation.variable import Variable
+
+
+class Db(File):
+    def __init__(self, path, package, desc=None):
+        super().__init__(path, package, desc)
+        self._init_import_stmt()
+        self._init_funciton()
+        self._init_variables()
+
+    def _init_import_stmt(self):
+        self.import_stmt.add_import('sqlalchemy', 'create_engine')
+        self.import_stmt.add_import('sqlalchemy.orm', 'sessionmaker')
+        self.import_stmt.add_import('.config.config', 'db_url')
+
+    def _init_variables(self):
+        self.variables['engine'] = Variable('engine', self, type='function', default="create_engine(db_url)")
+        self.variables['Session'] = Variable('Session', self, type='function', default="sessionmaker(bind=engine)")
+
+    def _init_funciton(self):
+        func = FunctionBlock('get_session', self)
+        func.content = f"""session = Session()
+try:
+    yield session
+finally:
+    session.close()
+        """
+        self.function_blocks[func.name] = func

fastcodedog-0.1.0/fastcodedog/api/main.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+from fastcodedog.context.context_instance import ctx_instance
+from fastcodedog.generation.file import File
+from fastcodedog.generation.variable import Variable
+from fastcodedog.util.case_converter import camel_to_snake
+
+
+class Main(File):
+    def __init__(self, path, package, desc=None):
+        super().__init__(path, package, desc)
+
+        self.script_lines = []
+        self.main_content = """if __name__ == "__main__":
+            uvicorn.run(app, host="0.0.0.0", port=8000)
+        """
+        self._init_import_stmt()
+        self._init_variables()
+        self._init_script_lines()
+        self._init_extended_apps()
+
+    def _init_extended_apps(self):
+        for api_name, api_package in ctx_instance.extended_apps.items():
+            self.import_stmt.add_import(api_package, 'app', f'{api_name}_app')
+            self.script_lines.append(f'app.include_router({api_name}_app.router)')
+
+    def _init_script_lines(self):
+        self.script_lines.extend("""@app.exception_handler(SQLAlchemyError)
+async def sqlalchemy_exception_handler(request, exc):
+    raise HTTPException(
+        status_code=HTTP_500_INTERNAL_SERVER_ERROR,
+        detail=f"Database operation failed: {exc}",
+    )
+""".splitlines())
+        self.script_lines.append('logging.basicConfig()')
+        self.script_lines.append("logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)")
+
+    def _init_variables(self):
+        self.variables['app'] = Variable('app', self, default='FastAPI()')
+
+    def _init_import_stmt(self):
+        self.import_stmt.add_import(None, 'uvicorn')
+        self.import_stmt.add_import(None, 'logging')
+        self.import_stmt.add_import('fastapi', 'FastAPI')
+        self.import_stmt.add_import('fastapi', 'HTTPException')
+        self.import_stmt.add_import('sqlalchemy.exc', 'SQLAlchemyError')
+        self.import_stmt.add_import('starlette.status', 'HTTP_500_INTERNAL_SERVER_ERROR')
+
+    def add_api(self, api, as_=None):
+        if not as_:
+            as_ = f'{camel_to_snake(api.model.class_name)}_app'
+        self.import_stmt.add_import(api.package, 'app', as_)
+        self.script_lines.append(f'app.include_router({as_}.router)')
+
+    def serialize(self):
+        content = super().serialize()
+        for line in self.script_lines:
+            content += line + '\n'
+        content += '\n'
+        content += self.main_content
+        return content

fastcodedog-0.1.0/fastcodedog/api/oauth.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from fastcodedog.api.app_function import AppFunction
+from fastcodedog.context.context_instance import ctx_instance
+from fastcodedog.crud.param import Param
+from fastcodedog.generation.file import File
+from fastcodedog.generation.variable import Variable
+
+
+def enable_api_oauth2(cls):
+    if ctx_instance.oauth2.enabled:
+        cls.import_stmt.add_import('fastapi.security', 'OAuth2PasswordBearer')
+        cls.import_stmt.add_import('typing', 'Annotated')
+        cls.variables['oauth2_scheme '] = Variable('oauth2_scheme ', cls,
+                                                   default="OAuth2PasswordBearer(tokenUrl='/oauth/token')")
+        cls.extra_function_params['token'] = Param('token', parent=cls, type='Annotated[str, Depends(oauth2_scheme)]',
+                                                   nullable=False)
+        cls.extra_function_params_when_get['token'] = Param('token', parent=cls,
+                                                            type='Annotated[str, Depends(oauth2_scheme)]',
+                                                            nullable=False)
+        cls.extra_function_params_when_get_list['token'] = Param('token', parent=cls,
+                                                                 type='Annotated[str, Depends(oauth2_scheme)]',
+                                                                 nullable=False)
+
+
+class OAuth(File):
+    def __init__(self, path, package, desc=None):
+        desc = """
+OAuth2.SECRET_KEY =
+OAuth2.EXPIRE_SECONDS = 60*60*2
+OAuth2.REDIS_URL = 'redis://localhost:6379/oauth2'
+"""
+        super().__init__(path, package, desc)
+
+        self.user_model = ctx_instance.model_package.models.get(ctx_instance.oauth2.user_table)
+        self.tenant_model = ctx_instance.model_package.models.get(
+            ctx_instance.tenant.tenant_table_code) if ctx_instance.tenant.enabled else None
+        self.param_session = Param('session', parent=self, type='Session', default='Depends(get_session)')
+        self.param_token = Param('token', parent=self, type='Annotated[str, Depends(oauth2_scheme)]', nullable=False)
+        self._init_import_stmt()
+        self._init_variables()
+        self._init_functions()
+
+    def _init_functions(self):
+        self._init_login_function()
+        self._init_remove_token_function()
+        self._init_refresh_token_function()
+        self._init_read_user_me_function()
+
+    def _init_read_user_me_function(self):
+        app_func = AppFunction('read_users_me', self, 'get', '/oauth/me')
+        app_func.params['token'] = self.param_token
+        app_func.content = 'return OAuth2.get_token_user(token)\n'
+        self.function_blocks[app_func.name] = app_func
+
+    def _init_refresh_token_function(self):
+        app_func = AppFunction('refresh_token', self, 'post', '/oauth/refresh_token', reponse_model='Token')
+        app_func.params['token'] = self.param_token
+        app_func.content = 'return OAuth2.refresh_token(token)\n'
+        self.function_blocks[app_func.name] = app_func
+
+    def _init_remove_token_function(self):
+        app_func = AppFunction('remove_token', self, 'post', '/oauth/logout')
+        app_func.params['token'] = self.param_token
+        app_func.content = 'OAuth2.remove_token(token)\n'
+        app_func.content += 'return {}\n'
+        self.function_blocks[app_func.name] = app_func
+
+    def _init_login_function(self):
+        app_func = AppFunction('login_for_access_token', self, 'post', '/oauth/token', reponse_model='Token')
+        app_func.params['form_data'] = Param('form_data', parent=self,
+                                             type='Annotated[OAuth2PasswordRequestForm, Depends()]', nullable=False)
+        app_func.params['session'] = self.param_session
+        app_func.content = 'username = form_data.username\n'
+        app_func.content += 'password = form_data.password\n'
+        if ctx_instance.tenant.enabled:
+            app_func.content += "if username.find('@') == -1:\n"
+            app_func.content += '    raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username. Must contain \'@\'")\n'
+            app_func.content += 'domain = username.split(\'@\')[1]\n'
+            app_func.content += 'username = username.split(\'@\')[0]\n'
+            app_func.content += (f'user = session.query({self.user_model.class_name})'
+                                 f'.join({self.tenant_model.class_name}, {self.user_model.class_name}.{ctx_instance.tenant.tenant_column}=={self.tenant_model.class_name}.id)'
+                                 f'.filter({self.user_model.class_name}.{ctx_instance.oauth2.user_name_field}==username)'
+                                 f'.filter({self.user_model.class_name}.{ctx_instance.oauth2.user_password_field}==password)'
+                                 f'.filter({self.tenant_model.class_name}.domain==domain)'
+                                 f'.first()\n')
+        else:
+            app_func.content += (f'user = session.query({self.user_model.class_name})'
+                                 f'.filter({self.user_model.class_name}.{ctx_instance.oauth2.user_name_field}==username)'
+                                 f'.filter({self.user_model.class_name}.{ctx_instance.oauth2.user_password_field}==password)'
+                                 f'.first()\n')
+        app_func.content += 'if user:\n'
+        token_content = ', '.join([f'"{k}": user.{k}' for k in self.user_model.table.get_primary_keys()])
+        token_content += f', "{ctx_instance.oauth2.user_name_field}": username'
+        if ctx_instance.tenant.enabled:
+            token_content += f', "{ctx_instance.tenant.tenant_column}": user.{ctx_instance.tenant.tenant_column}'
+        token_content = '{' + token_content + '}'
+        app_func.content += f'    return OAuth2.create_access_token({token_content})\n'
+        app_func.content += 'raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username or password")\n'
+        self.function_blocks[app_func.name] = app_func
+
+    def _init_variables(self):
+        self.variables['app'] = Variable('app', self, default="FastAPI()")
+        self.variables['oauth2_scheme '] = Variable('oauth2_scheme ', self,
+                                                    default="OAuth2PasswordBearer(tokenUrl='/oauth/token')")
+
+    def _init_import_stmt(self):
+        self.import_stmt.add_import('typing', 'Annotated')
+        self.import_stmt.add_import('fastoauth', 'OAuth2')
+        self.import_stmt.add_import('fastoauth', 'Token')
+        self.import_stmt.add_import('fastapi', 'Depends')
+        self.import_stmt.add_import('fastapi', 'FastAPI')
+        self.import_stmt.add_import('fastapi', 'HTTPException')
+        self.import_stmt.add_import('fastapi', 'status')
+        self.import_stmt.add_import('fastapi.security', 'OAuth2PasswordBearer')
+        self.import_stmt.add_import('fastapi.security', 'OAuth2PasswordRequestForm')
+        self.import_stmt.add_import(f'{ctx_instance.project_package}.db', 'Session')
+        self.import_stmt.add_import(f'{ctx_instance.project_package}.db', 'get_session')
+        self.import_stmt.add_import(self.user_model.package, self.user_model.class_name)
+        if self.tenant_model:
+            self.import_stmt.add_import(self.tenant_model.package, self.tenant_model.class_name)

fastcodedog-0.1.0/fastcodedog/cli.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+import sys
+
+from fastcodedog.api.api_package import ApiPackage
+from fastcodedog.context.context_instance import ctx_instance
+from fastcodedog.crud.crud_package import CrudPackage
+from fastcodedog.diagram.diagram import Diagram
+from fastcodedog.model.model_package import ModelPackage
+from fastcodedog.schema.schema_additional_package import SchemaAdditionalPackage
+from fastcodedog.schema.schema_package import SchemaPackage
+
+
+def main():
+    if len(sys.argv) == 1:
+        raise ValueError('缺少参数，请传入json5配置文件或者pdm文件')
+    ctx_instance.load_config(*(sys.argv[1:]))
+    ctx_instance.diagram = Diagram()
+    ctx_instance.diagram.load()
+    ctx_instance.model_package = ModelPackage()
+    ctx_instance.model_package.save()
+    ctx_instance.schema_package = SchemaPackage()
+    ctx_instance.schema_package.save()
+    ctx_instance.schema_additional_package = SchemaAdditionalPackage()
+    ctx_instance.schema_additional_package.save()
+    ctx_instance.crud_package = CrudPackage()
+    ctx_instance.crud_package.save()
+    ctx_instance.api_package = ApiPackage()
+    ctx_instance.api_package.save()
+
+
+if __name__ == '__main__':
+    """    
+$env:PYTHONPATH = "."
+python fastcodedog/cli.py fastcodegen/test/fastframe.diagram.json5 fastcodegen/test/fastframe.model.json5
+"""
+    main()
+

fastcodedog-0.1.0/fastcodedog/context/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

fastcodedog-0.1.0/fastcodedog/context/base.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+from .contextbase import ContextBase
+
+
+class Base(ContextBase):
+    def __init__(self):
+        super().__init__()
+        self.class_name = None
+        self.package = None

fastcodedog-0.1.0/fastcodedog/context/context.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+from .base import Base
+from .contextbase import ContextBase
+from .modules import Modules
+from .oauth2 import OAuth2
+from .schema import Schema
+from .tenant import Tenant
+
+
+class Context(ContextBase):
+    def __init__(self):
+        super().__init__()
+        self.pdm_files = []
+        self.project_name = None
+        self.author = None
+        self.project_package = None
+        self.project_dir = None
+        # diagram的配置，这些配置也会在后续的生成代码中使用
+        self.modules = Modules()
+        self.tenant = Tenant()
+        # model的配置
+        self.base = Base()
+        # schema的配置
+        self.schema = Schema()
+        self.response_schemas = {}
+        self.create_schemas = {}
+        self.update_schemas = {}
+        # crud的配置
+        self.queries = {}
+        # api的配置
+        self.extended_apps = {}
+        self.oauth2 = OAuth2()