public void CorrectlyGeneratesEnemyTeams_FromRandomizedConfiguration([Values(new [] { FighterType.Goblin, FighterType.Fairy }, new [] { FighterType.Warrior, FighterType.ShieldGuy })] IEnumerable <FighterType> enemyTypes)
        {
            List <FighterType> enemyTypesList = enemyTypes.ToList();

            TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Barbarian, 5), new EnemyConfiguration(FighterType.ShieldGuy, 2), new EnemyConfiguration(FighterType.ShieldGuy, 3));
            SubRegion         subRegion         = new SubRegion(WorldSubRegion.Fields, 1, new[] { new ChanceEvent <int>(2, 1) }, enemyTypesList, new BattlefieldConfiguration(bossConfiguration));

            SubRegion[] subRegions = { subRegion };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            _regionManager = GetRegionManager();

            _humanFighter1.SetMove(_runawayMove);
            _humanFighter1.SetMoveTarget(_humanFighter1);

            _humanFighter2.SetMove(_doNothingMove);

            _chanceService.PushWhichEventsOccur(0, 0, 1); //first roll determines there will be 2 enemies, then the next 2 specify 1 of each type
            _regionManager.Battle(_battleManager, _humanTeam);

            Team enemyTeam = _battleManager.GetAllEnemyTeams()[0];

            Assert.IsTrue(enemyTypesList[0].IsCorrectType(enemyTeam.Fighters[0]));
            Assert.IsTrue(enemyTypesList[1].IsCorrectType(enemyTeam.Fighters[1]));
        }
Exemple #2
0
        public void GetTeamByConfiguration_ReturnsAppropriateTeam([Values(FighterType.Fairy, FighterType.Goblin, FighterType.Warrior)] FighterType firstFighterType,
                                                                  [Range(1, 3)] int numberFirstFighters,
                                                                  [Values(1, 2)] int enemyLevel,
                                                                  [Values(FighterType.Ogre, FighterType.Golem)] FighterType secondFighterType)
        {
            List <EnemyConfiguration> enemyConfigurations = new List <EnemyConfiguration>();

            int i;

            for (i = 0; i < numberFirstFighters; ++i)
            {
                enemyConfigurations.Add(new EnemyConfiguration(firstFighterType, enemyLevel));
            }
            enemyConfigurations.Add(new EnemyConfiguration(secondFighterType, enemyLevel));

            TeamConfiguration configuration = new TeamConfiguration(enemyConfigurations.ToArray());

            Team returnedTeam = _teamFactory.GetTeam(configuration);

            Assert.AreEqual(numberFirstFighters + 1, returnedTeam.Fighters.Count);

            Assert.IsTrue(returnedTeam.Fighters.TrueForAll(f => f.Level == enemyLevel));

            for (i = 0; i < numberFirstFighters; ++i)
            {
                Assert.IsTrue(firstFighterType.IsCorrectType(returnedTeam.Fighters[i]));
            }
            Assert.IsTrue(secondFighterType.IsCorrectType(returnedTeam.Fighters[i]));
        }
        public void PrintsDefaultIntroString_UponEnteringRegion_NullOrEmptyIntroSuppliedToSubRegion([Values("", null)] string introMessage)
        {
            TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1));
            SubRegion         subRegion         = new SubRegion(WorldSubRegion.Fields, 1, new[] { new ChanceEvent <int>(1, 1) }, new[] { FighterType.Egg }, new BattlefieldConfiguration(bossConfiguration),
                                                                regionIntro: introMessage);

            SubRegion[] subRegions = { subRegion };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            _teamFactory.PushTeams(_oneEnemyTeam);
            _regionManager = GetRegionManager();

            _humanFighter1.SetMove(_runawayMove);
            _humanFighter1.SetMoveTarget(_humanFighter1);

            _humanFighter2.SetMove(_doNothingMove);

            _regionManager.Battle(_battleManager, _humanTeam);

            MockOutputMessage[] outputs = _output.GetOutputs();

            MockOutputMessage output = outputs[0];

            Assert.AreEqual($"You have entered the {WorldRegion.Fields} region\n", output.Message);

            output = outputs[1];

            Assert.AreEqual($"You have entered the {WorldSubRegion.Fields} sub region\n", output.Message);
        }
        public void CorrectlyPrintsIntro_UponEnteringRegion(
            [Values("Welcome to the Jungle!", "flee, for you have entered the graveyard!")] string regionIntroMessage,
            [Values("Welcome to a smaller subset of the jungle", "Spooky ghosts watch your every step")] string subRegionIntroMessage)
        {
            TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1));
            SubRegion         subRegion         = new SubRegion(WorldSubRegion.Fields, 1, new [] { new ChanceEvent <int>(1, 1) }, new[] { FighterType.Egg }, new BattlefieldConfiguration(bossConfiguration, null),
                                                                regionIntro: subRegionIntroMessage);

            SubRegion[] subRegions = { subRegion };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions, regionIntroMessage);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            _teamFactory.PushTeams(_oneEnemyTeam);
            _regionManager = GetRegionManager();

            _humanFighter1.SetMove(_runawayMove);
            _humanFighter1.SetMoveTarget(_humanFighter1);

            _humanFighter2.SetMove(_doNothingMove);

            _regionManager.Battle(_battleManager, _humanTeam);

            MockOutputMessage[] outputs = _output.GetOutputs();

            MockOutputMessage output = outputs[0];

            Assert.AreEqual(regionIntroMessage + "\n", output.Message);

            output = outputs[1];

            Assert.AreEqual(subRegionIntroMessage + "\n", output.Message);
        }
Exemple #5
0
        /// <summary>
        /// Create TFS Team if not exists
        /// </summary>
        /// <returns></returns>
        public TeamFoundationTeam CreateTeam()
        {
            // Check team already exists
            var teams        = _tfsTeamService.QueryTeams(_projectInfo.Uri.ToString());
            var existingTeam = teams.FirstOrDefault(t => t.Name == _softwareProjectName);

            if (existingTeam != null)
            {
                Console.WriteLine($"Team '{existingTeam.Name}' already exists.");
                return(existingTeam);
            }

            //Create TFS Team
            TeamFoundationTeam team = _tfsTeamService.CreateTeam(
                _projectInfo.Uri.ToString(), _softwareProjectName, _softwareProjectDescription, null);

            //Set the IterationPaths and BacklogIterationPath for the TFS Team
            var teamConfiguration     = _teamSettingsConfigurationService.GetTeamConfigurations(new[] { team.Identity.TeamFoundationId });
            TeamConfiguration tconfig = teamConfiguration.FirstOrDefault();
            TeamSettings      ts      = tconfig.TeamSettings;

            ts.IterationPaths       = new string[] { $"{_projectInfo.Name}\\{_softwareProjectName}\\Sprint 1" };
            ts.BacklogIterationPath = $"{_projectInfo.Name}\\{_softwareProjectName}";
            TeamFieldValue tfv = new TeamFieldValue();

            tfv.IncludeChildren = true;
            tfv.Value           = ts.BacklogIterationPath;
            ts.TeamFieldValues  = new TeamFieldValue[] { tfv };
            _teamSettingsConfigurationService.SetTeamSettings(tconfig.TeamId, ts);

            Console.WriteLine($"Team '{team.Name}' created.");

            return(team);
        }
        public void CorrectlySetsBattleMoves_UponEnteringRegion()
        {
            BattleMove superAttack = new AttackBattleMove("foo", TargetType.SingleEnemy, 80, 20, 5);
            BattleMove fastAttack  = new AttackBattleMove("bar", TargetType.SingleEnemy, 100, 0, 0, 2);

            Assert.False(_humanFighter1.AllSpecialMoves.Contains(superAttack));
            Assert.False(_humanFighter1.AllSpecialMoves.Contains(fastAttack));

            TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1));
            SubRegion         subRegion         = new SubRegion(WorldSubRegion.Fields, 1, new [] { new ChanceEvent <int>(1, 1), }, new[] { FighterType.Egg }, new BattlefieldConfiguration(bossConfiguration, null));

            SubRegion[] subRegions = { subRegion };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new[] { superAttack, fastAttack }, subRegions);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            _teamFactory.PushTeams(_oneEnemyTeam);
            _regionManager = GetRegionManager();

            _humanFighter1.SetMove(_runawayMove);
            _humanFighter1.SetMoveTarget(_humanFighter1);

            _humanFighter2.SetMove(_doNothingMove);

            _regionManager.Battle(_battleManager, _humanTeam);

            Assert.True(_humanFighter1.AllSpecialMoves.Contains(superAttack));
            Assert.True(_humanFighter1.AllSpecialMoves.Contains(fastAttack));
        }
        public void CorrectlyGeneratesEnemyTeams_FromBattlefieldConfiguration([Values(new[] { FighterType.Goblin, FighterType.Fairy }, new[] { FighterType.Warrior, FighterType.ShieldGuy })] IEnumerable <FighterType> enemyTypes)
        {
            List <FighterType> enemyTypesList = enemyTypes.ToList();

            TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Barbarian, 5), new EnemyConfiguration(FighterType.ShieldGuy, 2), new EnemyConfiguration(FighterType.ShieldGuy, 3));

            ShadeGroupingConfiguration shadeGroupingConfig = new ShadeGroupingConfiguration(3, 1);

            BellType[] bellTypes = { BellType.Silver, BellType.Copper };
            BellTerrainConfiguration bellConfig   = new BellTerrainConfiguration(bellTypes);
            BattlefieldConfiguration battleConfig = new BattlefieldConfiguration(shadeGroupingConfig, bellConfig);

            List <ScriptedBattlefieldConfiguration> scriptedBattlefieldConfigurations = new List
                                                                                        <ScriptedBattlefieldConfiguration>
            {
                new ScriptedBattlefieldConfiguration(battleConfig, 0)
            };

            SubRegion subRegion = new SubRegion(WorldSubRegion.Fields,
                                                1,
                                                new[] { new ChanceEvent <int>(2, 1) },
                                                enemyTypesList,
                                                new BattlefieldConfiguration(bossConfiguration),
                                                scriptedBattlefieldConfigurations);

            SubRegion[] subRegions = { subRegion };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            _regionManager = GetRegionManager();

            _humanFighter1.SetMove(_runawayMove);
            _humanFighter1.SetMoveTarget(_humanFighter1);

            _humanFighter2.SetMove(_doNothingMove);

            _regionManager.Battle(_battleManager, _humanTeam);

            Team            enemyTeam     = _battleManager.GetAllEnemyTeams()[0];
            List <IFighter> enemyFighters = enemyTeam.Fighters;

            Assert.AreEqual(3, enemyFighters.Count);
            Assert.True(enemyFighters.TrueForAll(ef => ef is Shade));

            List <TerrainInteractable> terrainInteractables = _battleManager.GetAllTerrainInteractableLists()[0];

            Assert.NotNull(terrainInteractables);
            Assert.AreEqual(2, terrainInteractables.Count);

            List <Bell> bells = terrainInteractables.OfType <Bell>().ToList();

            Assert.AreEqual(bellTypes.Length, bells.Count);
            for (var i = 0; i < bellTypes.Length; ++i)
            {
                Assert.AreEqual(bellTypes[i], bells[i].BellType);
            }
        }
 protected override void Seed(Slackish.Data.SlackishContext context)
 {
     TenantConfiguration.Seed(context);
     TeamConfiguration.Seed(context);
     ChannelConfiguration.Seed(context);
     UserConfiguration.Seed(context);
     ProfileConfiguration.Seed(context);
 }
        public void CorrectlyExecutesCutscene_SubRegionCompleted()
        {
            const MagicType firstBossEggType  = MagicType.Fire;
            const MagicType secondBossEggType = MagicType.Ice;

            ColorString[] firstSceneLines  = { new ColorString("foo"), new ColorString("bar") };
            SingleScene   firstSingleScene = new SingleScene(firstSceneLines);

            ColorString[] secondSceneLines  = { new ColorString("baz"), new ColorString("fwee") };
            SingleScene   secondSingleScene = new SingleScene(secondSceneLines);

            SingleScene[] scenes          = { firstSingleScene, secondSingleScene };
            Cutscene      regionACutscene = new Cutscene(scenes);

            TeamConfiguration firstBossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, firstBossEggType));
            SubRegion         subRegionA             = new SubRegion(WorldSubRegion.Fields, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(firstBossConfiguration), regionCompletedCutscene: regionACutscene);

            TeamConfiguration secondBossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, secondBossEggType));
            SubRegion         subRegionB = new SubRegion(WorldSubRegion.DesertCrypt, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(secondBossConfiguration));

            SubRegion[] subRegions = { subRegionA, subRegionB };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            AreaMap <Region, WorldRegion> regionMap = new AreaMap <Region, WorldRegion>(fakeFieldsRegion, new MapPath <Region, WorldRegion>(fakeFieldsRegion));

            AreaMap <SubRegion, WorldSubRegion> subRegionMap = new AreaMap <SubRegion, WorldSubRegion>(subRegionA, new MapPath <SubRegion, WorldSubRegion>(subRegionA, subRegionB));

            _mapManager.SetRegionalMap(regionMap);
            _mapManager.SetSubRegionalMap(WorldRegion.Fields, subRegionMap);

            _regionManager = GetRegionManager();

            TestEnemyFighter target = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);

            target.SetHealth(1, 0);

            _humanFighter1.SetMove(_basicAttackMove, 1);
            _humanFighter1.SetMove(_runawayMove, 1);
            _humanFighter1.SetMoveTarget(target);

            _humanFighter2.SetMove(_doNothingMove);

            _chanceService.PushAttackHitsNotCrit();

            _regionManager.Battle(_battleManager, _humanTeam);

            List <MockOutputMessage> outputs = _output.GetOutputs().ToList();

            List <ColorString> allCutsceneLines = firstSceneLines.Concat(secondSceneLines).ToList();

            foreach (ColorString cutsceneLine in allCutsceneLines)
            {
                Assert.NotNull(outputs.FirstOrDefault(output => output.Message == cutsceneLine.Value + "\n" && output.Color == cutsceneLine.Color));
            }
        }
        public void CorrectlyMovesToNextSubRegion_OnlyOneNextSubRegion()
        {
            const MagicType firstBossEggType  = MagicType.Fire;
            const MagicType secondBossEggType = MagicType.Ice;

            TeamConfiguration firstBossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, firstBossEggType));
            SubRegion         subRegionA             = new SubRegion(WorldSubRegion.Fields, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(firstBossConfiguration));

            const string      secondRegionIntro       = "Who wants donuts?!?";
            TeamConfiguration secondBossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, secondBossEggType));
            SubRegion         subRegionB = new SubRegion(WorldSubRegion.DesertCrypt, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(secondBossConfiguration), regionIntro: secondRegionIntro);

            SubRegion[] subRegions = { subRegionA, subRegionB };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            AreaMap <Region, WorldRegion> regionMap = new AreaMap <Region, WorldRegion>(fakeFieldsRegion, new MapPath <Region, WorldRegion>(fakeFieldsRegion));

            AreaMap <SubRegion, WorldSubRegion> subRegionMap = new AreaMap <SubRegion, WorldSubRegion>(subRegionA, new MapPath <SubRegion, WorldSubRegion>(subRegionA, subRegionB));

            _mapManager.SetRegionalMap(regionMap);
            _mapManager.SetSubRegionalMap(WorldRegion.Fields, subRegionMap);

            _regionManager = GetRegionManager();

            TestEnemyFighter target = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);

            target.SetHealth(1, 0);

            _humanFighter1.SetMove(_basicAttackMove, 1);
            _humanFighter1.SetMove(_runawayMove, 1);
            _humanFighter1.SetMoveTarget(target);

            _humanFighter2.SetMove(_doNothingMove);

            _chanceService.PushAttackHitsNotCrit();

            _regionManager.Battle(_battleManager, _humanTeam);

            MockOutputMessage[] outputs = _output.GetOutputs();

            Assert.NotNull(outputs.FirstOrDefault(o => o.Message == secondRegionIntro + "\n"));

            List <Team> enemyTeams = _battleManager.GetAllEnemyTeams();

            Assert.AreEqual(2, enemyTeams.Count);

            Egg secondBoss = enemyTeams[1].Fighters[0] as Egg;

            Assert.NotNull(secondBoss);
            Assert.AreEqual(secondBossEggType, secondBoss.MagicType);

            Assert.AreEqual(WorldSubRegion.DesertCrypt, subRegionMap.CurrentArea.AreaId);
        }
Exemple #11
0
 private TeamModel Map(TeamConfiguration teamConfiguration)
 {
     return(new TeamModel
     {
         Id = teamConfiguration.TeamId,
         Name = teamConfiguration.TeamName,
         CurrentIterationPath = teamConfiguration.TeamSettings.CurrentIterationPath,
         IterationPaths = teamConfiguration.TeamSettings.IterationPaths
     });
 }
        public void CorrectlyGeneratesEmptyListOfTerrainInteractables_FromNullInput()
        {
            TeamConfiguration        teamInfo          = new TeamConfiguration(new EnemyConfiguration(FighterType.Goblin, 1), new EnemyConfiguration(FighterType.Fairy, 1));
            BattlefieldConfiguration battlefieldConfig = new BattlefieldConfiguration(teamInfo);

            BattleFieldInfo returnedBattleFieldInfo = _factory.GetBattleFieldSetUp(battlefieldConfig);

            Assert.NotNull(returnedBattleFieldInfo.TerrainInteractables);
            Assert.AreEqual(0, returnedBattleFieldInfo.TerrainInteractables.ToList().Count);
        }
Exemple #13
0
 public MetadataConfiguration(TeamConfiguration teamConfiguration)
 {
     changeDataCaptureAttribute = teamConfiguration.ChangeDataCaptureAttribute;
     recordSourceAttribute      = teamConfiguration.RecordSourceAttribute;
     loadDateTimeAttribute      = teamConfiguration.LoadDateTimeAttribute;
     expiryDateTimeAttribute    = teamConfiguration.ExpiryDateTimeAttribute;
     eventDateTimeAttribute     = teamConfiguration.EventDateTimeAttribute;
     recordChecksumAttribute    = teamConfiguration.RecordChecksumAttribute;
     etlProcessAttribute        = teamConfiguration.EtlProcessAttribute;
     sourceRowIdAttribute       = teamConfiguration.RowIdAttribute;
 }
Exemple #14
0
 public TeamModel GetTeam(Guid collectionId, int projectId)
 {
     using (var server = GetServer())
     {
         TfsTeamProjectCollection collection = server.GetTeamProjectCollection(collectionId);
         WorkItemStore            wiStore    = collection.GetService <WorkItemStore>();
         Project project = wiStore.Projects.GetById(projectId);
         TeamSettingsConfigurationService configurationService = collection.GetService <TeamSettingsConfigurationService>();
         TeamConfiguration config = configurationService.GetTeamConfigurationsForUser(new[] { project.Uri.ToString() }).FirstOrDefault();
         //TODO config can be null
         return(Map(config));
     }
 }
        private TeamSettings CreateTargetTeamSettings(TeamConfiguration sourceTCfU)
        {
            ///////////////////////////////////////////////////
            TeamSettings newTeamSettings = sourceTCfU.TeamSettings;
            newTeamSettings.BacklogIterationPath = newTeamSettings.BacklogIterationPath.Replace(me.Source.Config.Project, me.Target.Config.Project);
            List<string> newIterationPaths = new List<string>();
            foreach (var ip in newTeamSettings.IterationPaths)
            {
                newIterationPaths.Add(ip.Replace(me.Source.Config.Project, me.Target.Config.Project));
            }
            newTeamSettings.IterationPaths = newIterationPaths.ToArray();

            ///////////////////////////////////////////////////
            return newTeamSettings;
        }
Exemple #16
0
 private ITfsTeam CreateTfsTeamFromTeamConfiguration(TeamConfiguration teamConfiguration)
 {
     return(new TfsTeam(tfsCredentials)
     {
         IsDefaultTeam = teamConfiguration.IsDefaultTeam,
         ProjectUri = teamConfiguration.ProjectUri,
         TeamId = teamConfiguration.TeamId,
         TeamName = teamConfiguration.TeamName,
         TeamSettings = teamConfiguration.TeamSettings,
         TeamConfiguration = teamConfiguration,
         TeamSettingsConfigurationService = teamSettingsConfigurationService,
         TeamService = this.tfsTeamProjectCollection.GetService <TfsTeamService>(),
         ProjectDetails = projectDetail
     });
 }
        public void CorrectNumberOfBattlesBeforeBoss([Range(1, 3)] int numberBattles)
        {
            TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Barbarian, 5), new EnemyConfiguration(FighterType.ShieldGuy, 2), new EnemyConfiguration(FighterType.ShieldGuy, 3));
            SubRegion         subRegion         = new SubRegion(WorldSubRegion.Fields, numberBattles, new[] { new ChanceEvent <int>(1, 1) }, new[] { FighterType.Egg },
                                                                new BattlefieldConfiguration(bossConfiguration));

            SubRegion[] subRegions = { subRegion };

            Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);

            _regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);

            for (int i = 0; i < numberBattles; ++i)
            {
                Team team = GetSingleEnemyTeam();
                _teamFactory.PushTeams(team);
                _chanceService.PushWhichEventOccurs(0);
            }

            _regionManager = GetRegionManager();

            IFighter target = TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);

            target.PhysicalDamage(target.MaxHealth);

            _humanFighter1.SetMove(_basicAttackMove, numberBattles);
            _humanFighter1.SetMoveTarget(target);
            _chanceService.PushAttackHitsNotCrit(numberBattles);
            _humanFighter1.SetMove(_runawayMove);

            _humanFighter2.SetMove(_doNothingMove);

            _chanceService.PushWhichEventsOccur(0, 0, 0, 0, 0, 0); //used for when the bosses are selecting their moves

            _regionManager.Battle(_battleManager, _humanTeam);

            List <Team> enemyTeams = _battleManager.GetAllEnemyTeams();

            Assert.AreEqual(numberBattles + 1, enemyTeams.Count);

            Team bossTeam = enemyTeams[numberBattles];

            Assert.AreEqual(3, bossTeam.Fighters.Count);

            Assert.True(bossTeam.Fighters.Exists(f => f is Barbarian && f.Level == 5));
            Assert.True(bossTeam.Fighters.Exists(f => f is ShieldGuy && f.Level == 2));
            Assert.True(bossTeam.Fighters.Exists(f => f is ShieldGuy && f.Level == 3));
        }
Exemple #18
0
        public AreaManager(ProjectDetail projectDetail, ITfsCredentials tfsCredentials)
        {
            this.projectDetail = projectDetail;

            this.tfsTeamProjectCollection = TfsApi.Administration.TfsTeamProjectCollectionFactory.GetTeamProjectCollection(this.projectDetail.CollectionUri, tfsCredentials);

            this.teamConfig = this.tfsTeamProjectCollection.GetService<TeamSettingsConfigurationService>();

            this.commonStructureService = (ICommonStructureService4)this.tfsTeamProjectCollection.GetService(typeof(ICommonStructureService4));

            this.projectInfo = this.commonStructureService.GetProjectFromName(this.projectDetail.ProjectName);

            foreach (TeamConfiguration item in this.teamConfig.GetTeamConfigurationsForUser(new[] { this.projectInfo.Uri }))
            {
                this.teamConfiguration = item;
                break;
            }
        }
Exemple #19
0
        public AreaManager(ProjectDetail projectDetail, ITfsCredentials tfsCredentials)
        {
            this.projectDetail = projectDetail;

            this.tfsTeamProjectCollection = TfsApi.Administration.TfsTeamProjectCollectionFactory.GetTeamProjectCollection(this.projectDetail.CollectionUri, tfsCredentials);

            this.teamConfig = this.tfsTeamProjectCollection.GetService <TeamSettingsConfigurationService>();

            this.commonStructureService = (ICommonStructureService4)this.tfsTeamProjectCollection.GetService(typeof(ICommonStructureService4));

            this.projectInfo = this.commonStructureService.GetProjectFromName(this.projectDetail.ProjectName);

            foreach (TeamConfiguration item in this.teamConfig.GetTeamConfigurationsForUser(new[] { this.projectInfo.Uri }))
            {
                this.teamConfiguration = item;
                break;
            }
        }
        /// <summary>
        /// Commit the changes to memory, save the configuration settings to disk and create a backup.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SaveConfigurationFileToolStripMenuItem_Click(object sender, EventArgs e)
        {
            #region root path file
            // Update the paths in memory
            GlobalParameters.OutputPath        = textBoxOutputPath.Text;
            GlobalParameters.ConfigurationPath = textBoxConfigurationPath.Text;

            var localEnvironment = (KeyValuePair <TeamWorkingEnvironment, string>)comboBoxEnvironments.SelectedItem;
            GlobalParameters.WorkingEnvironment           = localEnvironment.Key.environmentKey;
            GlobalParameters.WorkingEnvironmentInternalId = localEnvironment.Key.environmentInternalId;

            // Save the paths from memory to disk.
            UpdateRootPathFile();
            #endregion

            // Make sure the new paths as updated are available upon save for backup etc.
            // Check if the paths and files are available, just to be sure.
            FileHandling.InitialisePath(GlobalParameters.ConfigurationPath);
            FileHandling.InitialisePath(GlobalParameters.OutputPath);
            TeamConfiguration.CreateDummyEnvironmentConfigurationFile(GlobalParameters.ConfigurationPath + GlobalParameters.ConfigFileName + '_' + GlobalParameters.WorkingEnvironment + GlobalParameters.FileExtension);
            ValidationSetting.CreateDummyValidationFile(GlobalParameters.ConfigurationPath + GlobalParameters.ValidationFileName + '_' + GlobalParameters.WorkingEnvironment + GlobalParameters.FileExtension);
            JsonExportSetting.CreateDummyJsonConfigurationFile(GlobalParameters.ConfigurationPath + GlobalParameters.JsonExportConfigurationFileName + '_' + GlobalParameters.WorkingEnvironment + GlobalParameters.FileExtension);

            // Create a file backup for the configuration file
            try
            {
                TeamUtility.CreateFileBackup(GlobalParameters.ConfigurationPath + GlobalParameters.ConfigFileName + '_' + GlobalParameters.WorkingEnvironment + GlobalParameters.FileExtension);
                richTextBoxInformation.Text = "A backup of the current configuration was made at " + DateTime.Now + " in " + textBoxConfigurationPath.Text + ".\r\n";
            }
            catch (Exception)
            {
                richTextBoxInformation.Text = "TEAM was unable to create a backup of the configuration file.";
            }


            // Update the in-memory variables for use throughout the application, to commit the saved changes for runtime use.
            // This is needed before saving to disk, as the EnvironmentConfiguration Class retrieves the values from memory.
            UpdateConfigurationInMemory();


            // Save the information
            LocalTeamEnvironmentConfiguration.SaveConfigurationFile();
            parentFormMain.RevalidateFlag = true;
        }
Exemple #21
0
        private static BattlefieldConfiguration GetBossConfigurationForBossRegion(WorldSubRegion subRegion)
        {
            TeamConfiguration teamInfo;
            TerrainInteractablesConfiguration fieldInfo = null;

            switch (subRegion)
            {
            case WorldSubRegion.Fields:
                //teamInfo = new TeamConfiguration(new EnemyConfiguration(FighterType.MegaChicken, 1));
                teamInfo = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, MagicType.Fire), new EnemyConfiguration(FighterType.Egg, 1, MagicType.Ice));
                break;

            case WorldSubRegion.DesertIntro:
                //teamInfo = new TeamConfiguration(new EnemyConfiguration(FighterType.Barbarian, 1));
                teamInfo = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, MagicType.Fire), new EnemyConfiguration(FighterType.Egg, 1, MagicType.Ice));
                break;

            //TODO: needs to be filled out
            case WorldSubRegion.DesertCrypt:
            case WorldSubRegion.TavernOfHeroes:
            case WorldSubRegion.AncientLibrary:
            case WorldSubRegion.Oasis:
            case WorldSubRegion.CliffsOfAThousandPushups:
            case WorldSubRegion.TempleOfDarkness:
            case WorldSubRegion.VillageCenter:
            case WorldSubRegion.BeastTemple:
            case WorldSubRegion.Coliseum:
            case WorldSubRegion.CasinoIntro:
            case WorldSubRegion.CavesIntro:
            case WorldSubRegion.DarkCastleIntro:
                teamInfo = new TeamConfiguration(new EnemyConfiguration(FighterType.MegaChicken, 1), new EnemyConfiguration(FighterType.ShieldGuy, 1));
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(subRegion), subRegion, null);
            }

            var ret = new BattlefieldConfiguration(teamInfo, fieldInfo);

            return(ret);
        }
        public void CorrectlyGeneratesBattlefield_TeamConfiguration_NoTerrainConfiguration()
        {
            TeamConfiguration        teamInfo          = new TeamConfiguration(new EnemyConfiguration(FighterType.Goblin, 1), new EnemyConfiguration(FighterType.Fairy, 1));
            BattlefieldConfiguration battlefieldConfig = new BattlefieldConfiguration(teamInfo);

            BattleFieldInfo returnedBattleFieldInfo = _factory.GetBattleFieldSetUp(battlefieldConfig);

            List <IFighter> fighters = returnedBattleFieldInfo.EnemyTeam.Fighters;

            Assert.AreEqual(2, fighters.Count);

            IFighter firstFighter = fighters[0];

            Assert.True(firstFighter is Goblin, $"first fighter should be a Goblin but was {firstFighter.GetType()}");
            Assert.True(firstFighter.Level == 1, "first fighter should be level 1");

            IFighter secondFighter = fighters[1];

            Assert.True(secondFighter is Fairy, $"second fighter should be a fairy but was {secondFighter.GetType()}");
            Assert.True(secondFighter.Level == 1, "second fighter should be level 1");
        }
Exemple #23
0
        private void ProcessMessageByTeam(SlackMessageSubject subject, SlackMessage slackMessage,
                                          TeamConfiguration teamConfiguration)
        {
            var passingAttachments = slackMessage.Attachments
                                     .Where(_ => PassFilter(_, subject, teamConfiguration)).ToArray();

            if (passingAttachments.Any())
            {
                var messageToPost = new SlackMessage
                {
                    Attachments = passingAttachments
                                  .Select(_ => TransformMessage(_, subject, teamConfiguration.MessageTransformation))
                                  .ToArray()
                };

                PostMessageToSlack(JsonConvert.SerializeObject(messageToPost), teamConfiguration.SlackUrl);
            }
            else
            {
                _logger.Log(LogLevel.Information, "Failed to pass the filter.");
            }
        }
Exemple #24
0
 public BuildCompletedFilter(TeamConfiguration configuration, VstsClient vstsClient)
 {
     _configuration = configuration;
     _vstsClient    = vstsClient;
 }
Exemple #25
0
 private bool ConfigurationIsForTeamProjectInScope(TeamConfiguration teamConfiguration)
 {
     return string.Compare(projectDetail.ProjectName, teamConfiguration.TeamName, true) == 0;
 }
Exemple #26
0
        private static bool PassFilter(MessageAttachment attachment, SlackMessageSubject subject, TeamConfiguration configuration)
        {
            var attachmentFilter = AttachmentFilterFactory.GetAttachmentFilter(subject, configuration, _configuration);

            return(attachmentFilter != null && attachmentFilter.PassFilter(attachment));
        }
        /// <summary>
        /// This method will load an existing configuration file and display the values on the form, or create a new dummy one if not available.
        /// </summary>
        /// <param name="chosenFile"></param>
        private void LocalInitialiseConnections(string chosenFile)
        {
            // If the config file does not exist yet, create it by calling the EnvironmentConfiguration Class.
            if (!File.Exists(chosenFile))
            {
                TeamConfiguration.CreateDummyEnvironmentConfigurationFile(chosenFile);
            }

            // Open the configuration file
            var configList = new Dictionary <string, string>();
            var fs         = new FileStream(chosenFile, FileMode.Open, FileAccess.Read);
            var sr         = new StreamReader(fs);

            try
            {
                string textline;
                while ((textline = sr.ReadLine()) != null)
                {
                    if (textline.IndexOf(@"/*", StringComparison.Ordinal) == -1 && textline.Trim() != "")
                    {
                        var line = textline.Split('|');
                        configList.Add(line[0], line[1]);
                    }
                }

                sr.Close();
                fs.Close();

                // Databases
                if (configList["MetadataConnectionId"] != null)
                {
                    var metadataKey = TeamConfiguration.ConnectionDictionary[configList["MetadataConnectionId"]];
                    comboBoxMetadataConnection.SelectedIndex = comboBoxMetadataConnection.FindStringExact(metadataKey.ConnectionKey);
                }

                Enum.TryParse(configList["EnvironmentMode"], out EnvironmentModes environmentMode);
                if (environmentMode == EnvironmentModes.PhysicalMode)
                {
                    radioButtonPhysicalMode.Checked = true;
                }
                if (environmentMode == EnvironmentModes.VirtualMode)
                {
                    radioButtonVirtualMode.Checked = true;
                }


                //DWH settings
                textBoxHubTablePrefix.Text                    = configList["HubTablePrefix"];
                textBoxSatPrefix.Text                         = configList["SatTablePrefix"];
                textBoxLinkTablePrefix.Text                   = configList["LinkTablePrefix"];
                textBoxLinkSatPrefix.Text                     = configList["LinkSatTablePrefix"];
                textBoxDWHKeyIdentifier.Text                  = configList["KeyIdentifier"];
                textBoxEventDateTime.Text                     = configList["EventDateTimeStamp"];
                textBoxLDST.Text                              = configList["LoadDateTimeStamp"];
                textBoxExpiryDateTimeName.Text                = configList["ExpiryDateTimeStamp"];
                textBoxChangeDataCaptureIndicator.Text        = configList["ChangeDataIndicator"];
                textBoxRecordSource.Text                      = configList["RecordSourceAttribute"];
                textBoxETLProcessID.Text                      = configList["ETLProcessID"];
                textBoxETLUpdateProcessID.Text                = configList["ETLUpdateProcessID"];
                textBoxStagingAreaPrefix.Text                 = configList["StagingAreaPrefix"];
                textBoxPSAPrefix.Text                         = configList["PersistentStagingAreaPrefix"];
                textBoxPresentationLayerLabels.Text           = configList["PresentationLayerLabels"];
                textBoxTransformationLabels.Text              = configList["TransformationLabels"];
                textBoxSourceRowId.Text                       = configList["RowID"];
                textBoxRecordChecksum.Text                    = configList["RecordChecksum"];
                textBoxCurrentRecordAttributeName.Text        = configList["CurrentRecordAttribute"];
                textBoxAlternativeRecordSource.Text           = configList["AlternativeRecordSource"];
                textBoxHubAlternativeLDTSAttribute.Text       = configList["AlternativeHubLDTS"];
                textBoxSatelliteAlternativeLDTSAttribute.Text = configList["AlternativeSatelliteLDTS"];
                textBoxLogicalDeleteAttributeName.Text        = configList["LogicalDeleteAttribute"];

                //Checkbox setting based on loaded configuration
                CheckBox myConfigurationCheckBox;

                if (configList["AlternativeRecordSourceFunction"] == "False")
                {
                    myConfigurationCheckBox                = checkBoxAlternativeRecordSource;
                    myConfigurationCheckBox.Checked        = false;
                    textBoxAlternativeRecordSource.Enabled = false;
                }
                else
                {
                    myConfigurationCheckBox         = checkBoxAlternativeRecordSource;
                    myConfigurationCheckBox.Checked = true;
                }

                if (configList["AlternativeHubLDTSFunction"] == "False")
                {
                    myConfigurationCheckBox                    = checkBoxAlternativeHubLDTS;
                    myConfigurationCheckBox.Checked            = false;
                    textBoxHubAlternativeLDTSAttribute.Enabled = false;
                }
                else
                {
                    myConfigurationCheckBox         = checkBoxAlternativeHubLDTS;
                    myConfigurationCheckBox.Checked = true;
                }

                if (configList["AlternativeSatelliteLDTSFunction"] == "False")
                {
                    myConfigurationCheckBox         = checkBoxAlternativeSatLDTS;
                    myConfigurationCheckBox.Checked = false;
                    textBoxSatelliteAlternativeLDTSAttribute.Enabled = false;
                }
                else
                {
                    myConfigurationCheckBox         = checkBoxAlternativeSatLDTS;
                    myConfigurationCheckBox.Checked = true;
                }


                //Radiobutton setting for prefix / suffix
                RadioButton myTableRadioButton;

                if (configList["TableNamingLocation"] == "Prefix")
                {
                    myTableRadioButton         = tablePrefixRadiobutton;
                    myTableRadioButton.Checked = true;
                }
                else
                {
                    myTableRadioButton         = tableSuffixRadiobutton;
                    myTableRadioButton.Checked = true;
                }

                //Radiobutton settings for on key location
                RadioButton myKeyRadioButton;

                if (configList["KeyNamingLocation"] == "Prefix")
                {
                    myKeyRadioButton         = keyPrefixRadiobutton;
                    myKeyRadioButton.Checked = true;
                }
                else
                {
                    myKeyRadioButton         = keySuffixRadiobutton;
                    myKeyRadioButton.Checked = true;
                }

                //Radiobutton settings for PSA Natural Key determination
                RadioButton myPsaBusinessKeyLocation;

                if (configList["PSAKeyLocation"] == "PrimaryKey")
                {
                    myPsaBusinessKeyLocation         = radioButtonPSABusinessKeyPK;
                    myPsaBusinessKeyLocation.Checked = true;
                }
                else
                {
                    myPsaBusinessKeyLocation         = radioButtonPSABusinessKeyIndex;
                    myPsaBusinessKeyLocation.Checked = true;
                }

                // Also commit the values to memory
                UpdateConfigurationInMemory();

                richTextBoxInformation.AppendText(@"The file " + chosenFile + " was uploaded successfully.\r\n");
            }
            catch (Exception ex)
            {
                richTextBoxInformation.AppendText("\r\n\r\nAn error occurred while loading the configuration file. The original error is: '" + ex.Message + "'");
            }
        }
Exemple #28
0
 private ITfsTeam CreateTfsTeamFromTeamConfiguration(TeamConfiguration teamConfiguration)
 {
     return new TfsTeam(tfsCredentials)
     {
         IsDefaultTeam = teamConfiguration.IsDefaultTeam,
         ProjectUri = teamConfiguration.ProjectUri,
         TeamId = teamConfiguration.TeamId,
         TeamName = teamConfiguration.TeamName,
         TeamSettings = teamConfiguration.TeamSettings,
         TeamConfiguration = teamConfiguration,
         TeamSettingsConfigurationService = teamSettingsConfigurationService,
         TeamService = this.tfsTeamProjectCollection.GetService<TfsTeamService>(),
         ProjectDetails = projectDetail
     };
 }
Exemple #29
0
        public static IAttachmentFilter GetAttachmentFilter(SlackMessageSubject subject, TeamConfiguration teamConfiguration, SlackFilterConfiguration configuration)
        {
            switch (subject)
            {
            case SlackMessageSubject.BuildCompleted:
                return(new BuildCompletedFilter(teamConfiguration, new VstsClient(configuration)));

            case SlackMessageSubject.PullRequestCreated:
                return(new PullRequestCreatedFilter(teamConfiguration));

            case SlackMessageSubject.ReleaseCompleted:
                return(new ReleaseCompletedFilter(teamConfiguration, new VstsClient(configuration)));

            default:
                return(new MessageWithNoFilter());
            }
        }
Exemple #30
0
 public PullRequestCreatedFilter(TeamConfiguration configuration)
 {
     _configuration = configuration;
 }
Exemple #31
0
        public FormMain()
        {
            InitializeComponent();

            // Set the version of the build for everything
            const string versionNumberForTeamApplication = "v1.6.3";

            Text = "TEAM - Taxonomy for ETL Automation Metadata " + versionNumberForTeamApplication;

            GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, $"The TEAM root path is {GlobalParameters.RootPath}."));
            GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, $"The TEAM script path is {GlobalParameters.ScriptPath}."));

            richTextBoxInformation.AppendText("Initialising the application.\r\n\r\n");

            // Root paths (mandatory TEAM directories)
            // Make sure the application and custom location directories exist as per the start-up default.
            try
            {
                LocalTeamEnvironmentConfiguration.InitialiseEnvironmentPaths();
            }
            catch (Exception ex)
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, $"An error was encountered while creating the standard TEAM paths: \r\n\r\n{ex}"));
            }

            #region Load the root path configuration settings (user defined paths and working environment)

            // Load the root file, to be able to locate the (customisable) configuration file.
            // This file contains the configuration directory, the output directory and the working environment.
            string rootPathFileName = GlobalParameters.CorePath + GlobalParameters.PathFileName + GlobalParameters.FileExtension;
            try
            {
                LocalTeamEnvironmentConfiguration.LoadRootPathFile(rootPathFileName, GlobalParameters.ConfigurationPath, GlobalParameters.OutputPath);
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information,
                                                                       $"The core configuration file {rootPathFileName} has been loaded."));
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error,
                                                                       $"The core configuration file {rootPathFileName} could not be loaded. Is there a Configuration directory in the TEAM installation location?"));
            }

            // Environments file
            string environmentFile = GlobalParameters.CorePath + GlobalParameters.JsonEnvironmentFileName + GlobalParameters.JsonExtension;
            try
            {
                TeamEnvironmentCollection.LoadTeamEnvironmentCollection(environmentFile);
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information,
                                                                       $"The environment file {environmentFile} has been loaded."));
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error,
                                                                       $"The environment file {environmentFile} could not be loaded. Does the file exists in the designated (root) location?"));
            }

            #endregion

            #region Check if user configured paths exists (now that they have been loaded from the root file), and create dummy Configuration and Validation files if necessary
            // Configuration Path
            try
            {
                FileHandling.InitialisePath(GlobalParameters.ConfigurationPath);
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, $"The user defined configuration path {GlobalParameters.ConfigurationPath} is available."));
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, "The directories required to operate TEAM are not available and can not be created. Do you have administrative privileges in the installation directory to create these additional directories?"));
            }

            // Output Path
            try
            {
                FileHandling.InitialisePath(GlobalParameters.OutputPath);
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, $"The user defined output path {GlobalParameters.OutputPath} is available."));
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, "The directories required to operate TEAM are not available and can not be created. Do you have administrative privileges in the installation directory to create these additional directories?"));
            }

            // Create a dummy configuration file if it does not exist.
            var configurationFileName =
                GlobalParameters.ConfigurationPath +
                GlobalParameters.ConfigFileName + '_' +
                GlobalParameters.WorkingEnvironment +
                GlobalParameters.FileExtension;

            try
            {
                if (!File.Exists(configurationFileName))
                {
                    TeamConfiguration.CreateDummyEnvironmentConfigurationFile(configurationFileName);
                    GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, $"A new configuration file {configurationFileName} was created."));
                }
                else
                {
                    GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, $"The existing configuration file {configurationFileName} was detected."));
                }
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, $"An issue was encountered creating or detecting the configuration paths for {configurationFileName}."));
            }

            // Create a default validation file if the file does not exist as expected.
            var validationFileName =
                GlobalParameters.ConfigurationPath +
                GlobalParameters.ValidationFileName + '_' +
                GlobalParameters.WorkingEnvironment +
                GlobalParameters.FileExtension;

            try
            {
                ValidationSetting.CreateDummyValidationFile(validationFileName);
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, $"An issue was encountered creating or detecting the configuration paths for {validationFileName}."));
            }

            // Create a default json configuration file if the file does not exist as expected.
            var jsonConfigurationFileName =
                GlobalParameters.ConfigurationPath +
                GlobalParameters.JsonExportConfigurationFileName + '_' +
                GlobalParameters.WorkingEnvironment +
                GlobalParameters.FileExtension;

            try
            {
                JsonExportSetting.CreateDummyJsonConfigurationFile(jsonConfigurationFileName);
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, $"An issue was encountered creating or detecting the configuration paths for {jsonConfigurationFileName}."));
            }
            #endregion

            // Load the connections file for the respective environment.
            var connectionFileName =
                GlobalParameters.ConfigurationPath +
                GlobalParameters.JsonConnectionFileName + '_' +
                GlobalParameters.WorkingEnvironment +
                GlobalParameters.JsonExtension;

            TeamConfiguration.ConnectionDictionary = TeamConnectionFile.LoadConnectionFile(connectionFileName);

            #region Load configuration file
            // Load the available configuration file into memory.
            var configurationFile = GlobalParameters.ConfigurationPath + GlobalParameters.ConfigFileName + '_' + GlobalParameters.WorkingEnvironment + GlobalParameters.FileExtension;
            try
            {
                // Load the configuration file.
                TeamConfiguration.LoadTeamConfigurationFile(configurationFile);
                GlobalParameters.EnvironmentMode = TeamConfiguration.EnvironmentMode;
                // Retrieve the events into the main event log.
                GlobalParameters.TeamEventLog.MergeEventLog(TeamConfiguration.ConfigurationSettingsEventLog);
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, $"The user configuration settings ({configurationFile}) have been loaded."));
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, $"An issue was encountered loading the user configuration file ({configurationFile})."));
            }
            #endregion

            //FormBase.EnvironmentVersion.GetEnvironmentVersionsFromFile(Path.GetDirectoryName(configurationFile));

            TeamVersionList.LoadVersionList(GlobalParameters.CorePath + GlobalParameters.VersionFileName + GlobalParameters.JsonExtension);

            // Load the pattern definition file.
            try
            {
                GlobalParameters.PatternDefinitionList = LoadPatternDefinition.DeserializeLoadPatternDefinition(GlobalParameters.LoadPatternPath + GlobalParameters.LoadPatternDefinitionFile);
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Information, "The pattern definition file was loaded successfully."));
            }
            catch
            {
                GlobalParameters.TeamEventLog.Add(Event.CreateNewEvent(EventTypes.Error, "An issue was encountered loading the pattern definition file."));
            }

            // Report the events (including errors) back to the user
            int errorCounter = 0;
            foreach (Event individualEvent in GlobalParameters.TeamEventLog)
            {
                if (individualEvent.eventCode == (int)EventTypes.Error)
                {
                    errorCounter++;
                }
            }

            if (errorCounter > 0)
            {
                richTextBoxInformation.AppendText(
                    $"{errorCounter} error(s) have been found at startup. Please check the Event Log in the menu.\r\n\r\n");
            }

            TestConnections();

            //Startup information
            richTextBoxInformation.AppendText("\r\nApplication initialised - the Taxonomy of ETL Automation Metadata (TEAM). \r\n");
            richTextBoxInformation.AppendText("Welcome to version " + versionNumberForTeamApplication + ".\r\n\r\n");

            labelWorkingEnvironment.Text = GlobalParameters.WorkingEnvironment; //+"("+GlobalParameters.WorkingEnvironmentInternalId+")";
            labelEnvironmentMode.Text    = GlobalParameters.EnvironmentMode.ToString();
        }
 private void ReadAndMapAllSettings()
 {
     SlackConfiguration.Initialize(m_appSettings, this);
     TeamConfiguration.Initialize(m_appSettings, this);
     ZoomConfiguration.Initialize(m_appSettings, this);
 }
 public Team GetTeam(TeamConfiguration configuration)
 {
     return(_teams.Count > 0 ? _teams.Dequeue() : _realTeamFactory.GetTeam(configuration));
 }