codegen.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import io
import os
import sys
import argparse

from sqlalchemy.schema import MetaData
from sqlalchemy.engine import create_engine

from sqlacodegen.codegen import CodeGenerator

from tornado.options import define

abs_file = os.path.abspath(sys.argv[0])
ROOT_PATH = abs_file[:abs_file.rfind('/')]
define('ROOT_PATH', ROOT_PATH)

sys.path.insert(0, '/Users/leeyi/workspace/py3/trest')

from trest.utils import func
from trest.db.dbalchemy import DBConfigParser


class ModelGenerator(CodeGenerator):
    template = '''\
#!/usr/bin/env python
# -*- coding: utf-8 -*-
{imports}
from trest.db import Model as Base


{models}
'''
    def render(self, outfile):
        rendered_models = []
        for model in self.models:
            if isinstance(model, self.class_model):
                rendered_models.append(self.render_class(model))
            elif isinstance(model, self.table_model):
                rendered_models.append(self.render_table(model))

        imports = self.render_imports()
        imports = imports.replace('from sqlalchemy.ext.declarative import declarative_base', '')
        output = self.template.format(
            imports=imports,
            metadata_declarations=self.render_metadata_declarations(),
            models=self.model_separator.join(rendered_models).rstrip('\n'))
        # print(output, file=outfile)
        fout = open(outfile, 'w', encoding='utf8')
        # &#20889;&#20837;&#25991;&#20214;&#20869;&#23481;
        fout.write(output)
        # &#20851;&#38381;&#25991;&#20214;
        fout.close()


class ServiceGenerator:
    template = '''\
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from trest.utils import utime
from trest.logger import SysLogger
from trest.config import settings
from trest.exception import JsonError
from applications.common.models.{classname_underline} import {classname}


class {classname}Service(object):
    @staticmethod
    def page_list(where, page, per_page):
        """&#21015;&#34920;&#35760;&#24405;
        Arguments:
            where dict -- &#26597;&#35810;&#26465;&#20214;
            page int -- &#24403;&#21069;&#39029;
            per_page int -- &#27599;&#39029;&#35760;&#24405;&#25968;

        return:
            Paginate &#23545;&#35937; | None
        """
        query = {classname}.Q

        if 'id' in where.keys():
            query = query.filter({classname}.id == where['id'])
        if 'title' in where.keys():
            query = query.filter({classname}.title == where['title'])
        if 'status' in where.keys():
            query = query.filter({classname}.status == where['status'])
        else:
            query = query.filter({classname}.status != -1)

        pagelist_obj = query.paginate(page=page, per_page=per_page)

        if pagelist_obj is None:
            raise JsonError('&#26242;&#26080;&#25968;&#25454;')
        return pagelist_obj

    @staticmethod
    def get(id):
        """&#33719;&#21462;&#21333;&#26465;&#35760;&#24405;

        [description]

        Arguments:
            id int -- &#20027;&#38190;

        return:
            {classname} Model &#23454;&#20363; | None
        """
        if not id:
            raise JsonError('ID&#19981;&#33021;&#20026;&#31354;')
        obj = {classname}.Q.filter({classname}.id == id).first()
        return obj

    @staticmethod
    def update(id, param):
        """&#26356;&#26032;&#35760;&#24405;

        [description]

        Arguments:
            id int -- &#20027;&#38190;
            param dict -- [description]

        return:
            True | JsonError
        """
        columns = [i for (i, _) in {classname}.__table__.columns.items()]
        param = {{k:v for k,v in param.items() if k in columns}}

        if 'updated_at' in columns:
            param['updated_at'] = utime.timestamp(3)

        if not id:
            raise JsonError('ID &#19981;&#33021;&#20026;&#31354;')

        try:
            {classname}.Update.filter({classname}.id == id).update(param)
            {classname}.session.commit()
            return True
        except Exception as e:
            {classname}.session.rollback()
            SysLogger.error(e)
            raise JsonError('update error')

    @staticmethod
    def insert(param):
        """&#25554;&#20837;

        [description]

        Arguments:
            id int -- &#20027;&#38190;
            param dict -- [description]

        return:
            True | JsonError
        """
        columns = [i for (i, _) in {classname}.__table__.columns.items()]
        param = {{k:v for k,v in param.items() if k in columns}}
        if 'created_at' in columns:
            param['created_at'] = utime.timestamp(3)
        try:
            obj = {classname}(**param)
            {classname}.session.add(obj)
            {classname}.session.commit()
            return True
        except Exception as e:
            {classname}.session.rollback()
            SysLogger.error(e)
            raise JsonError('insert error')
'''

    def render(self, classname, appname = 'admin'):
        fname = func.hump2underline(classname)
        app = f'{ROOT_PATH}/applications/{appname}'
        app_s = f'{app}/services'
        sfile = f'{app_s}/{fname}.py'
        if os.path.exists(sfile):
            return
        if not os.path.exists(app):
            os.mkdir(app)
        if not os.path.exists(app_s):
            os.mkdir(app_s)

        fout = open(sfile, 'w', encoding='utf8')

        output = self.template.format(
            classname_underline=fname,
            appname=appname,
            classname=classname
        )

        # &#20889;&#20837;&#25991;&#20214;&#20869;&#23481;
        fout.write(output)
        # &#20851;&#38381;&#25991;&#20214;
        fout.close()


class AdminHandlerGenerator:
    template = '''\
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""{classname}&#25511;&#21046;&#22120;
"""
from trest.router import get
from trest.router import put
from trest.router import post
from trest.router import delete
from trest.exception import JsonError

from applications.admin.utils import required_permissions
from applications.admin.utils import admin_required_login

from applications.admin.services.{classname_underline} import {classname}Service

from .common import CommonHandler


class {classname}Handler(CommonHandler):

    @post('{classname_underline}')
    @admin_required_login
    @required_permissions()
    def {classname_underline}_post(self, *args, **kwargs):
        param = self.params()
        {classname}Service.insert(param)
        return self.success()

    @get('{classname_underline}/(?P<id>[0-9]+)')
    @admin_required_login
    @required_permissions()
    def {classname_underline}_get(self, id):
        """&#33719;&#21462;&#21333;&#20010;&#35760;&#24405;
        """
        resp_data = {classname}Service.get(id)
        return self.success(data=resp_data)

    @put('{classname_underline}/(?P<id>[0-9]+)')
    @admin_required_login
    @required_permissions()
    def {classname_underline}_put(self, id, *args, **kwargs):
        param = self.params()
        {classname}Service.update(id, param)
        return self.success(data=param)

    @delete('{classname_underline}/(?P<id>[0-9]+)')
    @admin_required_login
    @required_permissions()
    def {classname_underline}_delete(self, id, *args, **kwargs):
        param = {{
            'status':-1
        }}
        {classname}Service.update(id, param)
        return self.success()


class {classname}ListHandler(CommonHandler):
    @get(['{classname_underline}','{classname_underline}/(?P<category>[a-zA-Z0-9_]*)'])
    @admin_required_login
    @required_permissions()
    def {classname_underline}_list_get(self, category = '', *args, **kwargs):
        """&#21015;&#34920;&#12289;&#25628;&#32034;&#35760;&#24405;
        """
        page = int(self.get_argument('page', 1))
        per_page = int(self.get_argument('limit', 10))
        id = self.get_argument('id', None)
        title = self.get_argument('title', None)
        status = self.get_argument('status', None)

        param = {{}}
        if category:
            param['category'] = category
        if id:
            param['id'] = id
        if title:
            param['title'] = title
        if status:
            param['status'] = status

        resp_data = {classname}Service.page_list(param, page, per_page)
        return self.success(data=resp_data)
'''

    def render(self, classname, appname = 'admin'):
        fname = func.hump2underline(classname)
        outfile = f'{ROOT_PATH}/applications/{appname}/handlers/{fname}.py'
        if os.path.exists(outfile):
            return
        output = self.template.format(
            classname_underline=fname,
            classname=classname
        )
        fout = open(outfile, 'w', encoding='utf8')
        # &#20889;&#20837;&#25991;&#20214;&#20869;&#23481;
        fout.write(output)
        # &#20851;&#38381;&#25991;&#20214;
        fout.close()


class HandlerGenerator:
    template = '''\
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""{classname}&#25511;&#21046;&#22120;
"""
import tornado

from trest.router import get
from trest.router import put
from trest.router import post
from trest.router import delete
from trest.exception import JsonError


from applications.{appname}.services.{classname_underline} import {classname}Service

from .common import CommonHandler


class {classname}Handler(CommonHandler):

    @post('{classname_underline}')
    @tornado.web.authenticated
    def {classname_underline}_post(self, *args, **kwargs):
        param = self.params()
        {classname}Service.insert(param)
        return self.success()

    @get('{classname_underline}/(?P<id>[0-9]+)')
    @tornado.web.authenticated
    def {classname_underline}_get(self, id):
        """&#33719;&#21462;&#21333;&#20010;&#35760;&#24405;
        """
        resp_data = {classname}Service.get(id)
        return self.success(data=resp_data)

    @put('{classname_underline}/(?P<id>[0-9]+)')
    @tornado.web.authenticated
    def {classname_underline}_put(self, id, *args, **kwargs):
        param = self.params()
        {classname}Service.update(id, param)
        return self.success(data=param)

    @delete('{classname_underline}/(?P<id>[0-9]+)')
    @tornado.web.authenticated
    def {classname_underline}_delete(self, id, *args, **kwargs):
        param = {{
            'status':-1
        }}
        {classname}Service.update(id, param)
        return self.success()


class {classname}ListHandler(CommonHandler):
    @get(['{classname_underline}','{classname_underline}/(?P<category>[a-zA-Z0-9_]*)'])
    @tornado.web.authenticated
    def {classname_underline}_list_get(self, category = '', *args, **kwargs):
        """&#21015;&#34920;&#12289;&#25628;&#32034;&#35760;&#24405;
        """
        page = int(self.get_argument('page', 1))
        per_page = int(self.get_argument('limit', 10))
        id = self.get_argument('id', None)
        title = self.get_argument('title', None)
        status = self.get_argument('status', None)

        param = {{}}
        if category:
            param['category'] = category
        if id:
            param['id'] = id
        if title:
            param['title'] = title
        if status:
            param['status'] = status

        resp_data = {classname}Service.page_list(param, page, per_page)
        return self.success(data=resp_data)
'''

    def render(self, classname, appname):
        fname = func.hump2underline(classname)
        app = f'{ROOT_PATH}/applications/{appname}'
        app_s = f'{app}/handlers'
        sfile = f'{app_s}/{fname}.py'
        if os.path.exists(sfile):
            return
        if not os.path.exists(app):
            os.mkdir(app)
        if not os.path.exists(app_s):
            os.mkdir(app_s)

        fout = open(sfile, 'w', encoding='utf8')

        output = self.template.format(
            classname_underline=fname,
            appname=appname,
            classname=classname
        )

        # &#20889;&#20837;&#25991;&#20214;&#20869;&#23481;
        fout.write(output)
        # &#20851;&#38381;&#25991;&#20214;
        fout.close()


def get_metadata(tables):
    # Use reflection to fill in the metadata
    engines = DBConfigParser.parser_engines()
    engine = create_engine(engines['default']['master'][0])
    metadata = MetaData(engine)
    schema = None
    noviews = True
    # tables = None

    metadata.reflect(engine, schema, noviews, tables)
    return metadata

def create_models(tables = None):
    try:
        outfile = f'{ROOT_PATH}/applications/common/models/{tables[0]}.py'
        # if os.path.exists(outfile):
        #     return
        metadata = get_metadata(tables)

        noindexes = True
        noconstraints = True
        nojoined = True
        noinflect = True
        noclasses = False
        nocomments = False
        # Write the generated model code to the specified file or standard output
        generator = ModelGenerator(metadata, noindexes, noconstraints, nojoined, noinflect, noclasses, nocomments=nocomments)
        # print('generator ', type(generator), generator)
        generator.render(outfile)
    except Exception as e:
        raise

def create_services(tables, appname = 'admin'):
    try:
        generator = ServiceGenerator()
        for t in tables:
            generator.render(func.underline2hump(t, True), appname)
    except Exception as e:
        raise

def create_handlers(tables, appname = 'admin'):
    try:
        generator = AdminHandlerGenerator() if appname == 'admin' else HandlerGenerator()
        for t in tables:
            generator.render(func.underline2hump(t, True), appname)
    except Exception as e:
        raise


if __name__ == "__main__":
    appname = 'ishici'

    # &#21019;&#24314;&#21629;&#20196;&#34892;&#35299;&#26512;&#22120;&#21477;&#26564;&#65292;&#24182;&#33258;&#23450;&#20041;&#25551;&#36848;&#20449;&#24687;
    parser = argparse.ArgumentParser(description="test the argparse package")

    # &#23450;&#20041;&#21487;&#36873;&#21442;&#25968;appname
    parser.add_argument("--appname", "-a", help="appname must is a string")
    # &#23450;&#20041;&#21487;&#36873;&#21442;&#25968;module
    parser.add_argument("--module", "-m", help="multiple modules are separated by commas")

    args = parser.parse_args()  # &#36820;&#22238;&#19968;&#20010;&#21629;&#21517;&#31354;&#38388;
    param = vars(args)
    appname = param['appname']
    modules = []

    if appname == 'admin':
        metadata = get_metadata(None)
        # print(dir(metadata))
        for table in metadata.sorted_tables:
            create_models([table.name])
            create_services([table.name], appname)
            create_handlers([table.name], appname)
    else:
        modules = [m.strip() for m in param['module'].split(',') if m]
        create_services(modules, appname)
        create_handlers(modules, appname)
        try:
            [create_models([m]) for m in modules]
        except Exception as e:
            pass

    print(f'create {appname} app, {modules} module success')