示例#1
0
        public static void PerformControllerGenerate(TargetLanguage targetLanguage, TargetDatabaseConnector targetDatabaseConnector, string connectionString, string directory, string @namespace)
        {
            IModelGenerator generator = default;

            switch (targetLanguage)
            {
            case TargetLanguage.CSharp:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new CSharpControllerGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new CSharpControllerGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new CSharpControllerGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new CSharpControllerGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new CSharpControllerGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;
            }
            generator.Generate();
        }
示例#2
0
        public static void PerformRepositoryGenerate(TargetLanguage targetLanguage, TargetDatabaseConnector targetDatabaseConnector, string connectionString, string directory, string @namespace)
        {
            IServiceGenerator strategy = default;
            var generator = new UnitOfWorkGenerator();

            switch (targetLanguage)
            {
            case TargetLanguage.CSharp:
                strategy = new CSharpStrategy(connectionString, directory, @namespace);
                break;

            case TargetLanguage.VisualBasic:
                strategy = new VisualBasicStrategy(connectionString, directory, @namespace);
                break;

            case TargetLanguage.TypeScript:
                strategy = new TypeScriptStrategy(connectionString, directory, @namespace);
                break;
            }
            switch (targetDatabaseConnector)
            {
            case TargetDatabaseConnector.SQLServer:
                strategy.SetGenerator <SqlConnection, SqlParameter>((x) => $"[{x}]");
                break;

            case TargetDatabaseConnector.Oracle:
                strategy.SetGenerator <OracleConnection, OracleParameter>();
                break;

            case TargetDatabaseConnector.MySQL:
                strategy.SetGenerator <MySqlConnection, MySqlParameter>();
                break;

            case TargetDatabaseConnector.PostgreSQL:
                strategy.SetGenerator <NpgsqlConnection, NpgsqlParameter>();
                break;

            case TargetDatabaseConnector.SQLite:
                strategy.SetGenerator <SQLiteConnection, SQLiteParameter>();
                break;
            }
            generator.UseStrategy(strategy);
            generator.Generate();
        }
        public static void PerformModelGenerate(TargetLanguage targetLanguage, TargetDatabaseConnector targetDatabaseConnector, string connectionString, string directory, string @namespace)
        {
            switch (targetLanguage)
            {
            case TargetLanguage.CSharp:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new CSharpGenerator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();
                    return;

                case TargetDatabaseConnector.Oracle:
                    new CSharpGenerator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new CSharpGenerator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new CSharpGenerator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;

            case TargetLanguage.VisualBasic:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new VisualBasicGenerator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();
                    return;

                case TargetDatabaseConnector.Oracle:
                    new VisualBasicGenerator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new VisualBasicGenerator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new VisualBasicGenerator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;

            case TargetLanguage.TypeScript:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new TypeScriptGenerator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();

                    return;

                case TargetDatabaseConnector.Oracle:
                    new TypeScriptGenerator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new TypeScriptGenerator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new TypeScriptGenerator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;

            case TargetLanguage.PHP:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new PHPGenerator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();
                    return;

                case TargetDatabaseConnector.Oracle:
                    new PHPGenerator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new PHPGenerator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new PHPGenerator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;

            case TargetLanguage.Python:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new PythonGenerator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();
                    return;

                case TargetDatabaseConnector.Oracle:
                    new PythonGenerator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new PythonGenerator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new PythonGenerator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;

            case TargetLanguage.Python37:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new Python37Generator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();
                    return;

                case TargetDatabaseConnector.Oracle:
                    new Python37Generator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new Python37Generator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new Python37Generator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;

            case TargetLanguage.Java:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new JavaGenerator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();
                    return;

                case TargetDatabaseConnector.Oracle:
                    new JavaGenerator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new JavaGenerator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new JavaGenerator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;

            case TargetLanguage.CPP:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    new CPPGenerator <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]").GenerateAllTable();
                    return;

                case TargetDatabaseConnector.Oracle:
                    new CPPGenerator <OracleConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.MySQL:
                    new CPPGenerator <MySqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;

                case TargetDatabaseConnector.PostgreSQL:
                    new CPPGenerator <NpgsqlConnection>(connectionString, directory, @namespace).GenerateAllTable();
                    return;
                }
                break;
            }
        }
        public static void PerformStrategyGenerate(TargetLanguage targetLanguage, TargetDatabaseConnector targetDatabaseConnector, string connectionString, string directory, string @namespace)
        {
            switch (targetLanguage)
            {
            case TargetLanguage.CSharp:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    var strategy1  = new CSharpSingletonStrategy <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]");
                    var generator1 = new UnitOfWorkGenerator <SqlConnection>();
                    generator1.UseStrategy(strategy1);
                    generator1.Generate();
                    break;

                case TargetDatabaseConnector.Oracle:
                    var strategy2  = new CSharpSingletonStrategy <OracleConnection>(connectionString, directory, @namespace);
                    var generator2 = new UnitOfWorkGenerator <OracleConnection>();
                    generator2.UseStrategy(strategy2);
                    generator2.Generate();
                    break;

                case TargetDatabaseConnector.MySQL:
                    var strategy3  = new CSharpSingletonStrategy <MySqlConnection>(connectionString, directory, @namespace);
                    var generator3 = new UnitOfWorkGenerator <MySqlConnection>();
                    generator3.UseStrategy(strategy3);
                    generator3.Generate();
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    var strategy4  = new CSharpSingletonStrategy <NpgsqlConnection>(connectionString, directory, @namespace);
                    var generator4 = new UnitOfWorkGenerator <NpgsqlConnection>();
                    generator4.UseStrategy(strategy4);
                    generator4.Generate();
                    break;
                }
                break;

            case TargetLanguage.VisualBasic:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    var strategy1  = new VisualBasicSingletonStrategy <SqlConnection>(connectionString, directory, @namespace, (x) => $"[{x}]");
                    var generator1 = new UnitOfWorkGenerator <SqlConnection>();
                    generator1.UseStrategy(strategy1);
                    generator1.Generate();
                    break;

                case TargetDatabaseConnector.Oracle:
                    var strategy2  = new VisualBasicSingletonStrategy <OracleConnection>(connectionString, directory, @namespace);
                    var generator2 = new UnitOfWorkGenerator <OracleConnection>();
                    generator2.UseStrategy(strategy2);
                    generator2.Generate();
                    break;

                case TargetDatabaseConnector.MySQL:
                    var strategy3  = new VisualBasicSingletonStrategy <MySqlConnection>(connectionString, directory, @namespace);
                    var generator3 = new UnitOfWorkGenerator <MySqlConnection>();
                    generator3.UseStrategy(strategy3);
                    generator3.Generate();
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    var strategy4  = new VisualBasicSingletonStrategy <NpgsqlConnection>(connectionString, directory, @namespace);
                    var generator4 = new UnitOfWorkGenerator <NpgsqlConnection>();
                    generator4.UseStrategy(strategy4);
                    generator4.Generate();
                    break;
                }
                break;
            }
        }
示例#5
0
        public static void PerformModelGenerate(TargetLanguage targetLanguage, TargetDatabaseConnector targetDatabaseConnector, string connectionString, string directory, string @namespace)
        {
            IModelGenerator generator = default;

            switch (targetLanguage)
            {
            case TargetLanguage.CSharp:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new CSharpGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new CSharpGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new CSharpGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new CSharpGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new CSharpGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.VisualBasic:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new VisualBasicGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new VisualBasicGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new VisualBasicGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new VisualBasicGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new VisualBasicGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.TypeScript:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new TypeScriptGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new TypeScriptGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new TypeScriptGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new TypeScriptGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new TypeScriptGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.PHP:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new PHPGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new PHPGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new PHPGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new PHPGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new PHPGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.Python:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new PythonGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new PythonGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new PythonGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new PythonGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new PythonGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.Python37:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new Python37Generator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new Python37Generator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new Python37Generator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new Python37Generator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new Python37Generator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.Java:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new JavaGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new JavaGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new JavaGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new JavaGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new JavaGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.CPP:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new CPPGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new CPPGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new CPPGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new CPPGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new CPPGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;

            case TargetLanguage.Golang:
                switch (targetDatabaseConnector)
                {
                case TargetDatabaseConnector.SQLServer:
                    generator = new GolangGenerator <SqlConnection, SqlParameter>(connectionString, directory, @namespace, x => $"[{x}]");
                    break;

                case TargetDatabaseConnector.Oracle:
                    generator = new GolangGenerator <OracleConnection, OracleParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.MySQL:
                    generator = new GolangGenerator <MySqlConnection, MySqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.PostgreSQL:
                    generator = new GolangGenerator <NpgsqlConnection, NpgsqlParameter>(connectionString, directory, @namespace);
                    break;

                case TargetDatabaseConnector.SQLite:
                    generator = new GolangGenerator <SQLiteConnection, SQLiteParameter>(connectionString, directory, @namespace);
                    break;
                }
                break;
            }
            generator.Generate();
        }