public AccountsModule( MikiApp app, Config config, IDiscordClient discordClient, AccountService accountsService, AchievementService achievementService, AchievementEvents achievementEvents, TransactionEvents transactionEvents) { this.app = app; this.achievementService = achievementService; this.discordClient = discordClient; if (!string.IsNullOrWhiteSpace(config.ImageApiUrl)) { client = new HttpClient(config.ImageApiUrl); } else { Log.Warning("Image API can not be loaded in AccountsModule"); } discordClient.Events.MessageCreate.SubscribeTask(OnMessageCreateAsync); accountsService.OnLocalLevelUp += OnUserLevelUpAsync; accountsService.OnLocalLevelUp += OnLevelUpAchievementsAsync; transactionEvents.OnTransactionComplete += CheckCurrencyAchievementUnlocksAsync; achievementEvents.OnAchievementUnlocked .SubscribeTask(SendAchievementNotificationAsync); achievementEvents.OnAchievementUnlocked .SubscribeTask(CheckAchievementUnlocksAsync); }
private AchievementService CreateAchieveService() { var userId = Guid.Parse(User.Identity.GetUserId()); var service = new AchievementService(userId); return(service); }
private static AutoUpdateManager GetAutoUpdateManager() { // build up AutoUpdateManager - use DI instead? SteamCommunityManager steamCommunityManager = new SteamCommunityManager(new WebClientWrapper(), new SteamProfileXmlParser(), new GameXmlParser(), new AchievementXmlParser()); AchievementService achievementService = new AchievementService( new AchievementManager(new SteamRepository()), steamCommunityManager); UserService userService = new UserService(new AchievementManager(new SteamRepository())); // verify the log path DirectoryInfo logDirectory = new DirectoryInfo("logs"); if (!logDirectory.Exists) { logDirectory.Create(); } IAutoUpdateLogger autoUpdateLogger = new AutoUpdateLogger(logDirectory.FullName); // only keeps logs for the past 10 days autoUpdateLogger.Delete(DateTime.Now.AddDays(-10)); // the default writer saves output to a file, this will display it in the console as well autoUpdateLogger.Attach(Console.Out); AutoUpdateManager autoUpdateManager = new AutoUpdateManager(achievementService, userService, new FacebookPublisher(), autoUpdateLogger); return(autoUpdateManager); }
public TwitchBot(string _channelName) { //Init Client twitchClient = new TwitchClient(); twitchPubSub = new TwitchPubSub(); //Init Database this.db = new AppDbContextFactory().Create(); //Init access accessService = new AccessService(); //Init Twitch API api = new TwitchAPI(); api.Settings.ClientId = accessService.GetTwitchClientID(); api.Settings.AccessToken = accessService.GetTwitchAccessToken(); //Init services this.achievementService = new AchievementService(db); this.settingsService = new SettingsService(db); this.pokemonService = new PokemonService(db); userService = new UserService(db, api); chatOutputService = new ChatOutputService(twitchClient, _channelName); bossService = new BossService(userService, pokemonService, chatOutputService, settingsService); userfightService = new UserfightService(userService, chatOutputService); chatService = new ChatInputService(userService, chatOutputService, bossService, userfightService, achievementService); destinationChannelName = _channelName; Connect(); }
public DatadogRoutine( AccountService accounts, AchievementService achievements, IAsyncEventingExecutor <IDiscordMessage> commandPipeline, Config config, IDiscordClient discordClient) { if (string.IsNullOrWhiteSpace(config.DatadogHost)) { Log.Warning("Metrics are not being collected"); return; } DogStatsd.Configure(new StatsdConfig { StatsdServerName = config.DatadogHost, StatsdPort = 8125, Prefix = "miki" }); CreateAchievementsMetrics(achievements); CreateAccountMetrics(accounts); CreateEventSystemMetrics(commandPipeline); CreateDiscordMetrics(discordClient); Log.Message("Datadog set up!"); }
public async Task GetAchievementById_ShouldReturnAchievement_WhenAchievementExists() { // Arange var Id = Guid.NewGuid(); var CancellationToken = new CancellationToken(); var AchievementResult = new Achievement() { Id = Id, }; AchievementRepoMock.Setup(x => x.GetById(Id, CancellationToken)) .ReturnsAsync(AchievementResult).Verifiable(); UnitOfWorkMock.Setup(m => m.AchievementRepository).Returns(AchievementRepoMock.Object); AchievementService _AchievementService = new AchievementService(UnitOfWorkMock.Object, MapperMock.Object); // Act var Achievement = await _AchievementService.GetAchievementById(Id, CancellationToken); // Assert Assert.IsNotNull(Achievement); AchievementRepoMock.Verify(); Assert.AreEqual(AchievementResult.Id, Achievement.Id); }
public UsersControllerTests() { _fakeContext = new FakeCoursesContext(); _achievementValidator = new AchievementValidator(_fakeContext); _achievementService = new AchievementService(_fakeContext, _achievementValidator); _usersController = new UsersController(_fakeContext, _achievementService); }
public List <string> GetOptions(Player player) { var activeGame = _gameStore.ListGames().FirstOrDefault(a => a.GameName == player.ActiveGameSave.GameName); var achievementList = AchievementService.HasPlayerDoneAchievements(activeGame, player); var achievementButtonText = $"{Messages.Achievements} ({achievementList.Count(a => a.hasAchieved)}/{achievementList.Count})"; var list = new List <string> { "Return to Game", Messages.SaveGame, Messages.LoadGame, achievementButtonText, "Main Menu", }; var testFeatures = _configService.GetConfigOrDefault("TestFeatures", "false", true); if (bool.TryParse(testFeatures, out var enableTestFeatures) && enableTestFeatures) { list.Add(Messages.ShowData); list.Add(Messages.RefreshGames); } return(list); }
public ActionResult Index() { var userId = Guid.Parse(User.Identity.GetUserId()); var service = new AchievementService(userId); var model = service.GetAchievements(); return(View(model)); }
private ValueTask UnlockLewdAchievementAsync(IContext e, AchievementService service) { if (MikiRandom.Next(100) == 50) { var lewdAchievement = service.GetAchievementOrDefault(AchievementIds.LewdId); return(new ValueTask(service.UnlockAsync(e, lewdAchievement, e.GetAuthor().Id))); } return(default);
public BattleController(DataContext dataContext, GamingService gamingService, BattleMapper battleMapper, IOptions <GameSettings> gameSettingsOptions, LevelManager levelManager, AchievementService achievementService, NotificationManager notificationManager, AccountManager accountManager, BattleManager battleManager) { _dataContext = dataContext; _gamingService = gamingService; _battleMapper = battleMapper; _levelManager = levelManager; _achievementService = achievementService; _notificationManager = notificationManager; _accountManager = accountManager; _battleManager = battleManager; _gameSettingsOptions = gameSettingsOptions.Value; }
private static Publisher CreatePublisher() { var settings = Settings.Default; var logger = new AutoUpdateLogger(_logDirectory.FullName); var achievementManager = new AchievementManager(new SteamRepository()); var communityManager = new SteamCommunityManager(new WebClientWrapper(), new SteamProfileXmlParser(), new GameXmlParser(), new AchievementXmlParser()); var achievementService = new AchievementService(achievementManager, communityManager); var facebookClient = new FacebookClientService(settings.FacebookAppId, settings.FacebookAppSecret, settings.FacebookCanvasUrl); var autoUpdateManager = new AutoUpdateManager(achievementService, new UserService(achievementManager), facebookClient, logger); return(new Publisher(autoUpdateManager)); }
/// <summary> /// Determines whether the target object satisfiy the specification. /// </summary> /// <param name="target">The target object to be validated.</param> /// <returns><c>true</c> if this instance is satisfied by the specified target; otherwise, <c>false</c>.</returns> public override bool IsSatisfiedBy(Achievement target) { var achievementService = new AchievementService(); var otherAchievementWithSameName = achievementService.GetAchievementByName(target.Name); if (otherAchievementWithSameName != null && otherAchievementWithSameName != target) { NotSatisfiedReason = "There is another Achievement with the name '{0}'. Achievements should have unique name.".With(target.Name); return(false); } return(true); }
public ExecutionResult HandleMessage(string message, Player player) { if (message == Messages.Return) { return(MessageHandlerHelpers.ReturnToMainMenu(player)); } var games = _gameStore.ListGames(); List <string> optionsToSend = new List <string>(); optionsToSend.Add(Messages.Return); var gameAchievementList = games.Select(a => (AchievementService.HasPlayerDoneAchievements(a, player), a.GameName)).ToList(); gameAchievementList.ForEach(a => { optionsToSend.Add($"{a.GameName} ({a.Item1.Count(b => b.hasAchieved)}/{a.Item1.Count()})"); }); var selectedGame = games.FirstOrDefault(a => message.StartsWith(a.GameName)); if (selectedGame != null) { var achievmentListString = AchievementService.HasPlayerDoneAchievements(selectedGame, player).OrderBy(a => a.hasAchieved).Select(a => $"{(a.hasAchieved ? "UNLOCKED! " : "")}{a.achievement.Name} - {a.achievement.Description}").ToList(); var responseMessage = string.Join("\n\n", achievmentListString); var result = ExecutionResultHelper.SingleMessage(responseMessage, optionsToSend); result.MessagesToShow.Insert(0, new MessageResult { Message = "Achievements for game: " + selectedGame.GameName }); return(result); } else { player.PlayerFlag = PlayerFlag.ACHIEVEMENTS.ToString(); var messageToSend = $"You have completed a total of: {gameAchievementList.Sum(a => a.Item1.Count(b => b.hasAchieved))} out of {gameAchievementList.Sum(a => a.Item1.Count())}"; return(new ExecutionResult { MessagesToShow = new List <MessageResult> { new MessageResult { Message = messageToSend } }, OptionsToShow = optionsToSend }); } }
public ActionResult UpdateDevelopersAchievements() { var devService = new DeveloperService(); var devs = devService.GetAllDevelopers().ToList(); var achievementService = new AchievementService(); foreach (var dev in devs) { achievementService.UpdateDeveloperAchievements(dev); } return(View(devs)); }
public void UpdateDeveloperAchievements_NoAchievementsForDeveloper_EmptyList() { DependencyService.Register <IUnitOfWork>(new MemoryUnitOfWork()); DependencyService.Register <IAchievementRepository>(new MemoryAchievementRepository()); var target = new AchievementService(); var account = new Developer() { Username = "******", FullName = "test", Email = "*****@*****.**" }; account.AccountsAtIssuers.Add(new DeveloperAccountAtIssuer(0, "DeveloperWithoutAchievements")); target.UpdateDeveloperAchievements(account); Assert.AreEqual(0, account.Achievements.Count); }
public void SetUp() { _fileService = new Mock <IFileService>(); _achievementRepository = new Mock <IAchievementRepository>(); _userRepository = new Mock <IUserRepository>(); _userAchievementRepository = new Mock <IUserAchievementRepository>(); _unitOfWork = new Mock <IUnitOfWork>(); var myProfile = new AutoMapperProfile(); var configuration = new MapperConfiguration(cfg => cfg.AddProfile(myProfile)); _mapper = new Mapper(configuration); _achievementService = new AchievementService(_userRepository.Object, _userAchievementRepository.Object, _achievementRepository.Object, _fileService.Object, _mapper, _unitOfWork.Object); }
private void CreateAchievementsMetrics(AchievementService service) { if (service == null) { return; } service.OnAchievementUnlocked.Subscribe(res => { var(_, achievement) = res; DogStatsd.Increment( "achievements.gained", tags: new[] { $"achievement:{achievement.ResourceName}" }); }); }
public override void Execute() { if (ContentUpdated.EndsWith(BibaContentConstants.ACHIEVEMENT_SETTINGS_FILE)) { AchievementService.ReloadContent(); } if (ContentUpdated.EndsWith(BibaContentConstants.LOCALIZATION_SETTINGS_FILE)) { LocalizationService.ReloadContent(); } if (ContentUpdated.EndsWith(BibaContentConstants.SPECIAL_SCENE_SETTINGS_FILE)) { SpecialSceneService.ReloadContent(); } }
private async void SaveGame() { ContentDialogResult result = await _dialogService.ShowContentDialogAsync(new ConfirmDialogViewModel("End Game", "Are you sure you want to quit the game and log the stats?")); if (result == ContentDialogResult.Secondary) { return; } CalculateScores(); AchievementService achievementService = new AchievementService(game); achievementService.CheckForPersonalScores(); achievementService.CheckForEverScores(); try { _gameRepo.AddGame(game); int multiScore = colours.SingleOrDefault(c => c.name == "Multi")?.score ?? 0; foreach (Player player in game.players) { _playerGameRepo.AddPlayerGame(player, game, colours.SingleOrDefault(c => c.name == "Red").score, colours.SingleOrDefault(c => c.name == "White").score, colours.SingleOrDefault(c => c.name == "Blue").score, colours.SingleOrDefault(c => c.name == "Yellow").score, colours.SingleOrDefault(c => c.name == "Green").score, multiScore); } achievementService.CheckForFirsts(); achievementService.CheckForMileStones(); achievementService.AddAchievements(); ((App)Application.Current).rootFrame.Navigate(typeof(StandingsView), game); } catch (SQLiteException) { await _dialogService.ShowContentDialogAsync(new MessageDialogViewModel("Error", "Something went wrong, please try again")); } }
public ActionResult Index(string username) { var service = new DeveloperService(); var dev = service.GetDeveloperByUsername(username); if (dev == null) { return(View("SiteHome", (object)username)); } var achievementService = new AchievementService(); achievementService.UpdateDeveloperAchievements(dev); var viewModel = new DeveloperHomeViewModel(dev); return(View("DeveloperHome", viewModel)); }
public void UpdateDeveloperAchievements_ThereAreAchievementsForDeveloper_AchievementsFromProviders() { DependencyService.Register <IUnitOfWork>(new MemoryUnitOfWork()); DependencyService.Register <IAchievementRepository>(new MemoryAchievementRepository()); var target = new AchievementService(); var account = new Developer() { Username = "******", FullName = "test", Email = "*****@*****.**" }; account.AccountsAtIssuers.Add(new DeveloperAccountAtIssuer(0, "DeveloperWithAchievements")); target.UpdateDeveloperAchievements(account); Assert.AreEqual(2, account.Achievements.Count); Assert.AreEqual("Achievement One", account.Achievements [1].Name); Assert.AreEqual("Achievement Two", account.Achievements [0].Name); }
public async Task DeleteAchievement_ShouldReturnVoid_WhenAchievementExists() { // Arange var Id = Guid.NewGuid(); var CancellationToken = new CancellationToken(); AchievementRepoMock .Setup(x => x.Delete(It.IsAny <Guid>(), CancellationToken)) .Returns(() => throw new ArgumentNullException()).Verifiable(); UnitOfWorkMock.Setup(m => m.AchievementRepository).Returns(AchievementRepoMock.Object); AchievementService _AchievementService = new AchievementService(UnitOfWorkMock.Object, MapperMock.Object); // Act // Assert AchievementRepoMock.Verify(); Assert.ThrowsException <ArgumentNullException>(async() => await _AchievementService.DeleteAchievement(It.IsAny <Guid>(), CancellationToken)); }
private async void SaveGame() { if (!CheckForEndOfGame()) { ContentDialogResult result = await _dialogService.ShowContentDialogAsync(new ConfirmDialogViewModel("End Game", "You are about to quit an unfinished game. Are you sure you want to quit the game and log the stats?")); if (result == ContentDialogResult.Secondary) { return; } } CalculateScores(); AchievementService achievementService = new AchievementService(game); achievementService.CheckForPersonalScores(); achievementService.CheckForEverScores(); try { _gameRepo.AddGame(game); foreach (Player player in game.players) { _playerGameRepo.AddPlayerGame(player, game.id); } achievementService.CheckForFirsts(); achievementService.CheckForMileStones(); achievementService.AddAchievements(); ((App)Application.Current).rootFrame.Navigate(typeof(StandingsView), game); } catch (SQLiteException) { await _dialogService.ShowContentDialogAsync(new MessageDialogViewModel("Error", "Something went wrong, please try again")); } }
public ExecutionResult MainMenuMessage(List <DrawGame> games, Player player) { var filteredList = games.Where(a => a.Metadata?.Category != Messages.MiniGames).ToList(); if (filteredList == null) { filteredList = new List <DrawGame>(); } List <string> options = new List <string>(); options = filteredList.Select(a => a.GameName).ToList(); options.Add(Messages.MiniGames); options.Add(Messages.ContactUs); options.Add(Messages.LoadGame); options.Add($"{Messages.Achievements} - ({AchievementService.CountAchievementsCompletedForGames(games, player)}/{AchievementService.CountTotalAchievements(games)})"); var execResult = new ExecutionResult(); var messages = new List <MessageResult>(); messages.Add(new MessageResult { Message = "All characters in this game are 18+! All characters are random, and not based on any pre-existing characters. These games feature adult content, including mild fetishes." }); messages.Add(new MessageResult { Message = "Games Available:" }); messages.AddRange(filteredList.Select(a => new MessageResult { Message = a.GameName + " - " + a.Metadata?.Description })); messages.Add( new MessageResult { Message = "Enter a game to play!" }); execResult.OptionsToShow = options; execResult.MessagesToShow = messages; return(execResult); }
public void InitializeTest() { Stubs.Initialize(); Stubs.AchievementRepository.Add(new Achievement() { Id = 1L }); Stubs.AchievementRepository.Add(new Achievement() { Id = 2L }); Stubs.AchievementRepository.Add(new Achievement() { Id = 3L }); Stubs.AchievementRepository.Add(new Achievement() { Id = 4L }); Stubs.UnitOfWork.Commit(); m_target = new AchievementService(); }
public async Task GetAllAchievements_ShouldReturnCollectionOfAchievement_WhenAchievementExists() { // Arange var CancellationToken = new CancellationToken(); IEnumerable <Achievement> AchievementsResult = new List <Achievement> { new Achievement(), new Achievement(), new Achievement() }; AchievementRepoMock.Setup(x => x.GetAll(CancellationToken)) .ReturnsAsync(AchievementsResult).Verifiable(); UnitOfWorkMock.Setup(m => m.AchievementRepository).Returns(AchievementRepoMock.Object); AchievementService _AchievementService = new AchievementService(UnitOfWorkMock.Object, MapperMock.Object); // Act var Achievements = await _AchievementService.GetAllAchievements(CancellationToken); // Assert Assert.IsNotNull(Achievements); AchievementRepoMock.Verify(); Assert.AreEqual(AchievementsResult, Achievements); }
public ShopController(ShopItemManager shopItemManager, DataContext dataContext, AchievementService achievementService) { _shopItemManager = shopItemManager; _dataContext = dataContext; _achievementService = achievementService; }
public void UpdateNewUserAchievements() { Mock <IAchievementManager> achievementManagerMock = new Mock <IAchievementManager>(); Mock <ISteamCommunityManager> communityManagerMock = new Mock <ISteamCommunityManager>(); // expect User user = new User { FacebookUserId = 1234, SteamUserId = "user1" }; Data.User dataUser = new Data.User { FacebookUserId = 1234, SteamUserId = "user1" }; achievementManagerMock.Setup(rep => rep.GetUser(user.FacebookUserId)) .Returns(dataUser).Verifiable(); AchievementXmlParser achievementXmlParser = new AchievementXmlParser(); List <UserAchievement> userAchievements = achievementXmlParser.ParseClosed(File.ReadAllText("cssAchievements.xml")).ToList(); userAchievements.ForEach( userAchievement => userAchievement.Game = new Game { Id = 240, ImageUrl = "http://media.steampowered.com/steamcommunity/public/images/apps/10/af890f848dd606ac2fd4415de3c3f5e7a66fcb9f.jpg", Name = "Counter-Strike: Source", PlayedRecently = true, StatsUrl = String.Format("http://steamcommunity.com/id/{0}/games/?xml=1", user.SteamUserId), StoreUrl = "http://store.steampowered.com/app/10" }); communityManagerMock.Setup(rep => rep.GetAchievements(user.SteamUserId)) .Returns(new List <UserAchievement>()).Verifiable(); achievementManagerMock.Setup(rep => rep.GetUser(user.SteamUserId)) .Returns(dataUser).Verifiable(); achievementManagerMock.Setup(rep => rep.UpdateAchievements(It.IsAny <IEnumerable <Data.UserAchievement> >())) .Returns(5).Verifiable(); ICollection <Game> games = new GameXmlParser().Parse(File.ReadAllText("games.xml")); communityManagerMock.Setup(rep => rep.GetGames(user.SteamUserId)) .Returns(games).Verifiable(); Achievement[] dataAchievements = new[] { new Achievement { Description = "x", GameId = 1, Id = 1, } }; achievementManagerMock.Setup( rep => rep.GetUnpublishedAchievements(user.SteamUserId, DateTime.UtcNow.Date.AddDays(-2))) .Returns(dataAchievements).Verifiable(); achievementManagerMock.Setup( rep => rep.UpdateHidden(user.SteamUserId, It.IsAny <IEnumerable <int> >())) .Verifiable(); // execute IAchievementService service = new AchievementService(achievementManagerMock.Object, communityManagerMock.Object); service.UpdateNewUserAchievements(user); // verify achievementManagerMock.Verify(); communityManagerMock.Verify(); }
void OnGUI() { if (Time.time % 2 < 1) { success = callBack.GetResult (); } // For Setting Up ResponseBox. GUI.TextArea (new Rect (10, 5, 1100, 175), success); //======================================= Achievement Service====================================== if (GUI.Button (new Rect (50, 200, 200, 30), "Create Achievement")) { App42Log.SetDebug(true); achievementService = sp.BuildAchievementService(); // Initializing Achievement Service. achievementService.CreateAchievement (cons.achievementName, cons.description, callBack); } //==================================== Achievement Service========================================= if (GUI.Button (new Rect (260, 200, 200, 30), "Earn Achievement")) { App42Log.SetDebug(true); achievementService = sp.BuildAchievementService (); // Initializing Achievement Service. achievementService.EarnAchievement (cons.userName, cons.achievementName, cons.gameName, cons.description, callBack); } //==================================== Achievement Service======================================== if (GUI.Button (new Rect (470, 200, 200, 30), "GetAll Achievements ForUser")) { App42Log.SetDebug(true); achievementService = sp.BuildAchievementService (); // Initializing Achievement Service. achievementService.GetAllAchievementsForUser(cons.userName, callBack); } //===================================== Achievement Service======================================= if (GUI.Button (new Rect (680, 200, 200, 30), "GetAll Achievements ForUserInGame")) { App42Log.SetDebug(true); achievementService = sp.BuildAchievementService (); // Initializing Achievement Service. achievementService.GetAllAchievementsForUserInGame (cons.userName, cons.gameName, callBack); } //====================================== Achievement Service====================================== if (GUI.Button (new Rect (890, 200, 200, 30), "GetAll Achievements")) { App42Log.SetDebug(true); achievementService = sp.BuildAchievementService (); // Initializing Achievement Service. achievementService.GetAllAchievements (callBack); } //====================================== Achievement Service====================================== if (GUI.Button (new Rect (50, 250, 200, 30), "Get Achievement ByName")) { App42Log.SetDebug(true); achievementService = sp.BuildAchievementService (); // Initializing Achievement Service. achievementService.GetAchievementByName (cons.achievementName, callBack); } //======================================= Achievement Service===================================== if (GUI.Button (new Rect (260, 250, 200, 30), "GetUsers Achievement")) { App42Log.SetDebug(true); achievementService = sp.BuildAchievementService (); // Initializing Achievement Service. achievementService.GetUsersAchievement(cons.achievementName, cons.gameName, callBack); } }
public List <Achievement> GetMyAchievements() { return(AchievementService.GetMyAchievements()); }