コード例 #1
0
ファイル: Program.cs プロジェクト: sade-ce/letportal
        private async Task OnExecuteAsync()
        {
            var services    = new ServiceCollection();
            var toolsOption = GetToolsOptions(ConfigFilePath);

            ConventionPackDefault.Register();
            MongoDbRegistry.RegisterEntities();
            var dbType         = DatabseType.ToEnum <ConnectionType>(true);
            var databaseOption = new DatabaseOptions
            {
                ConnectionString = !string.IsNullOrEmpty(Connection)
                    ? Connection : GetDefaultConnectionString(dbType, App, toolsOption),
                ConnectionType = dbType
            };

            var runningCommand = GetAvailableCommands().FirstOrDefault(a => a.CommandName.ToLower() == Command.ToLower());

            if (runningCommand != null)
            {
                ToolsContext toolsContext       = null;
                var          storingConnections = toolsOption.GetByDatabaseType(dbType);
                switch (dbType)
                {
                case ConnectionType.MongoDB:
                    var mongoConnection        = new MongoConnection(databaseOption);
                    var mongoVersionContext    = new MongoVersionContext(databaseOption);
                    var versionMongoRepository = new VersionMongoRepository(mongoConnection);
                    mongoVersionContext.ConnectionType           = ConnectionType.MongoDB;
                    mongoVersionContext.DatabaseOptions          = databaseOption;
                    mongoVersionContext.ServiceManagementOptions = storingConnections.ServiceManagementConnection;
                    mongoVersionContext.IdentityDbOptions        = storingConnections.IdentityConnection;
                    var latestVersion = versionMongoRepository.GetAsQueryable().ToList().LastOrDefault();

                    var allVersions = Enumerable.Empty <IVersion>();
                    IServiceProvider serviceProvider = null;
                    if (IsPortal())
                    {
                        RegisterServicesForPortal(services, databaseOption);
                        serviceProvider = services.BuildServiceProvider();
                        allVersions     = Scanner.GetAllPortalVersions(serviceProvider);
                    }
                    else if (IsIdentity())
                    {
                        RegisterServicesForIdentity(services, databaseOption);
                        serviceProvider = services.BuildServiceProvider();
                        allVersions     = Scanner.GetAllIdentityVersions(serviceProvider);
                    }

                    toolsContext = new ToolsContext
                    {
                        LatestVersion     = latestVersion,
                        VersionContext    = mongoVersionContext,
                        VersionNumber     = VersionNumber,
                        Versions          = allVersions,
                        VersionRepository = versionMongoRepository,
                        PatchesFolder     = PatchesFolder,
                        AllowPatch        = !string.IsNullOrEmpty(PatchesFolder),
                        Services          = serviceProvider,
                        Arguments         = CombineArguments()
                    };
                    break;

                case ConnectionType.PostgreSQL:
                case ConnectionType.MySQL:
                case ConnectionType.SQLServer:

                    if (IsPortal())
                    {
#pragma warning disable CA2000 // Dispose objects before losing scope
                        var letportalContext = new PortalDbContext(databaseOption);
#pragma warning restore CA2000 // Dispose objects before losing scope
                        letportalContext.Database.EnsureCreated();

#pragma warning disable CA2000 // Dispose objects before losing scope
                        var letportalContextForRepo = new PortalDbContext(databaseOption);
#pragma warning restore CA2000 // Dispose objects before losing scope
                        var sqlEFVersionContext = new EFVersionContext(letportalContext)
                        {
                            ConnectionType  = dbType,
                            DatabaseOptions = databaseOption
                        };
                        var portalVersionRepository = new VersionEFRepository(letportalContextForRepo);
                        var latestVersionEF         = portalVersionRepository.GetAsQueryable().ToList().LastOrDefault();
                        sqlEFVersionContext.ServiceManagementOptions = storingConnections.ServiceManagementConnection;
                        sqlEFVersionContext.IdentityDbOptions        = storingConnections.IdentityConnection;

                        RegisterServicesForPortal(services, databaseOption);
                        var sqlServiceProvider = services.BuildServiceProvider();
                        IEnumerable <IVersion> allSQLVersions = Scanner.GetAllPortalVersions(sqlServiceProvider);
                        toolsContext = new ToolsContext
                        {
                            LatestVersion     = latestVersionEF,
                            VersionContext    = sqlEFVersionContext,
                            VersionNumber     = VersionNumber,
                            Versions          = allSQLVersions,
                            VersionRepository = portalVersionRepository,
                            Services          = sqlServiceProvider,
                            AllowPatch        = !string.IsNullOrEmpty(PatchesFolder),
                            Arguments         = CombineArguments()
                        };
                    }
                    else if (IsIdentity())
                    {
#pragma warning disable CA2000 // Dispose objects before losing scope
                        var letIdentityContext = new IdentityDbContext(databaseOption);
#pragma warning restore CA2000 // Dispose objects before losing scope
                        letIdentityContext.Database.EnsureCreated();

#pragma warning disable CA2000 // Dispose objects before losing scope
                        var letportalContextForRepo = new IdentityDbContext(databaseOption);
#pragma warning restore CA2000 // Dispose objects before losing scope
                        var sqlEFVersionContext = new EFVersionContext(letportalContextForRepo)
                        {
                            ConnectionType  = dbType,
                            DatabaseOptions = databaseOption
                        };
                        var portalVersionRepository = new VersionEFRepository(letportalContextForRepo);
                        var latestVersionEF         = portalVersionRepository.GetAsQueryable().ToList().LastOrDefault();
                        sqlEFVersionContext.ServiceManagementOptions = storingConnections.ServiceManagementConnection;
                        sqlEFVersionContext.IdentityDbOptions        = storingConnections.IdentityConnection;

                        RegisterServicesForIdentity(services, databaseOption);
                        var sqlServiceProvider = services.BuildServiceProvider();
                        IEnumerable <IVersion> allSQLVersions = Scanner.GetAllIdentityVersions(sqlServiceProvider);

                        toolsContext = new ToolsContext
                        {
                            LatestVersion     = latestVersionEF,
                            VersionContext    = sqlEFVersionContext,
                            VersionNumber     = VersionNumber,
                            Versions          = allSQLVersions,
                            VersionRepository = portalVersionRepository,
                            AllowPatch        = !string.IsNullOrEmpty(PatchesFolder),
                            Services          = sqlServiceProvider
                        };
                    }

                    break;
                }

                if (toolsContext != null)
                {
                    Console.WriteLine("");
                    await runningCommand.RunAsync(toolsContext);

                    toolsContext.Dispose();
                }

                Console.WriteLine("-----------------------++++++DONE++++++-------------------------");
            }
            else
            {
                Console.WriteLine("Oops! We don't find any matching command to execute. If you don't know how to run, please type '--help'");
            }

            Console.ReadLine();
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: weedkiller/let.portal
        private async Task OnExecuteAsync()
        {
            var toolsOption = GetToolsOptions(ConfigFilePath);

            LoadPlugins(toolsOption.RequiredPlugins);
            LoadPatchs(toolsOption.RequiredPatchs);
            toolPlugins     = GetInstalledPlugins(toolsOption.RequiredPlugins);
            portalPatches   = GetInstalledPortalPatchs(toolsOption.RequiredPatchs);
            identityPatches = GetInstalledIdentityPatchs(toolsOption.RequiredPatchs);
            bool isRunningPlugin = !IsPortal() && !IsIdentity();

            // Check if run with mode patch
            bool isPatchRunning = false;

            if (!isRunningPlugin && !string.IsNullOrEmpty(PatchName) && Command != "install")
            {
                throw new NotSupportedException("Sorry, we only support -pn with install command.");
            }
            else if (!isRunningPlugin && !string.IsNullOrEmpty(PatchName) && Command == "install")
            {
                isPatchRunning = true;
            }


            IToolPlugin toolPlugin = isRunningPlugin ? toolPlugins.First(a => a.AppName == App) : null;
            var         services   = new ServiceCollection();

            ConventionPackDefault.Register();
            MongoDbRegistry.RegisterEntities();
            var dbType         = DatabseType.ToEnum <ConnectionType>(true);
            var databaseOption =
                new DatabaseOptions
            {
                ConnectionString = !string.IsNullOrEmpty(Connection)
                        ? Connection
                            : (isRunningPlugin ?
                               toolPlugin.LoadDefaultDatabase().ConnectionString
                                    : GetDefaultConnectionString(dbType, App, toolsOption)),
                ConnectionType = dbType
            };

            var runningCommand = GetAvailableCommands().FirstOrDefault(a => a.CommandName.ToLower() == Command.ToLower());

            if (runningCommand != null)
            {
                ToolsContext toolsContext       = null;
                var          storingConnections = toolsOption.GetByDatabaseType(dbType);
                switch (dbType)
                {
                case ConnectionType.MongoDB:
                    var mongoConnection        = new MongoConnection(databaseOption);
                    var mongoVersionContext    = new MongoVersionContext(databaseOption);
                    var versionMongoRepository = new VersionMongoRepository(mongoConnection);
                    var patchMongoRepository   = new PatchVersionMongoRepository(mongoConnection);
                    mongoVersionContext.ConnectionType           = ConnectionType.MongoDB;
                    mongoVersionContext.DatabaseOptions          = databaseOption;
                    mongoVersionContext.PortalDatabaseOptions    = toolsOption.MongoStoringConnections.PortalConnection;
                    mongoVersionContext.ServiceManagementOptions = storingConnections.ServiceManagementConnection;
                    mongoVersionContext.IdentityDbOptions        = storingConnections.IdentityConnection;
                    var latestVersion = await versionMongoRepository.GetLastestVersion(App);

                    var allVersions = Enumerable.Empty <IVersion>();
                    IServiceProvider          serviceProvider          = null;
                    PatchVersion              latestPatchVersion       = null;
                    IPortalPatchFeatureTool   portalPatchFeatureTool   = null;
                    IIdentityPatchFeatureTool identityPatchFeatureTool = null;
                    if (IsPortal())
                    {
                        RegisterServicesForPortal(services, databaseOption);
                        if (isPatchRunning)
                        {
                            latestPatchVersion = await patchMongoRepository.GetLatestAsync(App, PatchName);

                            portalPatchFeatureTool = portalPatches.First(a => a.PatchName == PatchName);
                            portalPatchFeatureTool.RegisterServices(services, configuration);
                        }
                        serviceProvider = services.BuildServiceProvider();
                        allVersions     = Scanner.GetAllPortalVersions(serviceProvider);
                    }
                    else if (IsIdentity())
                    {
                        RegisterServicesForIdentity(services, databaseOption);
                        if (isPatchRunning)
                        {
                            latestPatchVersion = await patchMongoRepository.GetLatestAsync(App, PatchName);

                            identityPatchFeatureTool = identityPatches.First(a => a.PatchName == PatchName);
                            identityPatchFeatureTool.RegisterServices(services, configuration);
                        }
                        serviceProvider = services.BuildServiceProvider();
                        allVersions     = Scanner.GetAllIdentityVersions(serviceProvider);
                    }
                    else
                    {
                        var foundPlugin = toolPlugins.First(a => a.AppName.Equals(App, StringComparison.OrdinalIgnoreCase));
                        foundPlugin.RegisterServices(services, configuration);
                        serviceProvider = services.BuildServiceProvider();
                        allVersions     = foundPlugin.GetAllVersions(serviceProvider);
                    }
                    toolsContext = new ToolsContext
                    {
                        LatestVersion          = latestVersion,
                        LatestPatchVersion     = latestPatchVersion,
                        VersionContext         = mongoVersionContext,
                        VersionNumber          = VersionNumber,
                        Versions               = allVersions,
                        VersionRepository      = versionMongoRepository,
                        PatchesFolder          = PatchesFolder,
                        AllowPatch             = !string.IsNullOrEmpty(PatchesFolder),
                        Services               = serviceProvider,
                        PatchVersionRepository = patchMongoRepository,
                        CurrentPatchPortal     = portalPatchFeatureTool,
                        CurrentIdentityPortal  = identityPatchFeatureTool,
                        Arguments              = CombineArguments()
                    };

                    break;

                case ConnectionType.PostgreSQL:
                case ConnectionType.MySQL:
                case ConnectionType.SQLServer:

#pragma warning disable CA2000 // Dispose objects before losing scope
                    var letportalContext = new SaturnFullContext(databaseOption);
#pragma warning restore CA2000 // Dispose objects before losing scope
                    letportalContext.Database.EnsureCreated();

#pragma warning disable CA2000 // Dispose objects before losing scope
                    var letportalContextForRepo = new SaturnFullContext(databaseOption);
#pragma warning restore CA2000 // Dispose objects before losing scope
                    var sqlEFVersionContext = new EFVersionContext(letportalContext)
                    {
                        ConnectionType  = dbType,
                        DatabaseOptions = databaseOption
                    };
                    var patchEFRepository       = new PatchVersionEFRepository(letportalContextForRepo);
                    var portalVersionRepository = new VersionEFRepository(letportalContextForRepo);
                    var latestVersionEF         = await portalVersionRepository.GetLastestVersion(App);

                    sqlEFVersionContext.ServiceManagementOptions = storingConnections.ServiceManagementConnection;
                    sqlEFVersionContext.IdentityDbOptions        = storingConnections.IdentityConnection;
                    sqlEFVersionContext.PortalDatabaseOptions    = storingConnections.PortalConnection;
                    var sqlAllVersions = Enumerable.Empty <IVersion>();
                    IServiceProvider          sqlServiceProvider         = null;
                    PatchVersion              latestEFPatchVersion       = null;
                    IPortalPatchFeatureTool   portalEFPatchFeatureTool   = null;
                    IIdentityPatchFeatureTool identityEFPatchFeatureTool = null;

                    if (IsPortal())
                    {
                        RegisterServicesForPortal(services, databaseOption);
                        if (isPatchRunning)
                        {
                            latestEFPatchVersion = await patchEFRepository.GetLatestAsync(App, PatchName);

                            portalEFPatchFeatureTool = portalPatches.First(a => a.PatchName == PatchName);
                            portalEFPatchFeatureTool.RegisterServices(services, configuration);
                        }
                        sqlServiceProvider = services.BuildServiceProvider();
                        sqlAllVersions     = Scanner.GetAllPortalVersions(sqlServiceProvider);
                    }
                    else if (IsIdentity())
                    {
                        RegisterServicesForIdentity(services, databaseOption);
                        if (isPatchRunning)
                        {
                            latestEFPatchVersion = await patchEFRepository.GetLatestAsync(App, PatchName);

                            identityEFPatchFeatureTool = identityPatches.First(a => a.PatchName == PatchName);
                            identityEFPatchFeatureTool.RegisterServices(services, configuration);
                        }
                        sqlServiceProvider = services.BuildServiceProvider();
                        sqlAllVersions     = Scanner.GetAllIdentityVersions(sqlServiceProvider);
                    }
                    else
                    {
                        var foundPlugin = toolPlugins.First(a => a.AppName.Equals(App, StringComparison.OrdinalIgnoreCase));
                        foundPlugin.RegisterServices(services, configuration);
                        sqlServiceProvider = services.BuildServiceProvider();
                        sqlAllVersions     = foundPlugin.GetAllVersions(sqlServiceProvider);
                    }
                    toolsContext = new ToolsContext
                    {
                        LatestVersion          = latestVersionEF,
                        VersionContext         = sqlEFVersionContext,
                        VersionNumber          = VersionNumber,
                        Versions               = sqlAllVersions,
                        VersionRepository      = portalVersionRepository,
                        AllowPatch             = !string.IsNullOrEmpty(PatchesFolder),
                        Services               = sqlServiceProvider,
                        Arguments              = CombineArguments(),
                        PatchesFolder          = PatchesFolder,
                        PatchVersionRepository = patchEFRepository,
                        CurrentPatchPortal     = portalEFPatchFeatureTool,
                        CurrentIdentityPortal  = identityEFPatchFeatureTool
                    };

                    break;
                }

                if (toolsContext != null)
                {
                    Console.WriteLine("");
                    await runningCommand.RunAsync(toolsContext);

                    toolsContext.Dispose();
                }

                Console.WriteLine("-----------------------++++++DONE++++++-------------------------");
            }
            else
            {
                Console.WriteLine("Oops! We don't find any matching command to execute. If you don't know how to run, please type '--help'");
            }

            Console.ReadLine();
        }