private async Task DeleteAchievement()
{
if (_achievementId != 0)
{
bool result = await UserDialogs.Instance.ConfirmAsync(
ConstantsHelper.AchievementDeleteMessage,
ConstantsHelper.Warning,
ConstantsHelper.Ok,
ConstantsHelper.Cancel);
if (result)
{
var achievementToDelete = App.AchievementRepository.Value
.GetAchievementAsync(_achievementId);
foreach (var step in AchievementSteps)
{
var stepToDelete = AchievementStepRepository.GetAchievementStepAsync(step.Id);
AchievementStepRepository.DeleteAchievementStep(stepToDelete);
}
AchievementRepository.DeleteAchievement(achievementToDelete);
await NavigationService.NavigateBackAsync();
}
}
}
public GameAchievementFileLoad_Tests()
{
var resourcePath = @"RepositoryTests\Resources\basic-achievements.csv";
var gameState = new GameState();
achievementRepo = new AchievementRepository(resourcePath, gameState);
}
public AchievementService(Game Game)
{
game = Game;
playerRepo = new PlayerRepository();
achievementRepo = new AchievementRepository();
playerGameRepo = new PlayerGameRepository();
}
private async Task SaveAchievement()
{
var model = AchievementRepository.GetAchievementAsync(_achievementId);
model.Description = Description;
model.Title = Title;
model.GeneralTimeSpent = GeneralTimeSpent;
model.AchievementSteps = AchievementSteps.ToAchievementStepViewModels();
AchievementRepository.Save(model);
if (_stepsToDelete.Any())
{
foreach (var stepViewModel in _stepsToDelete)
{
var stepToDelete = AchievementStepRepository.GetAchievementStepAsync(stepViewModel.Id);
AchievementStepRepository.DeleteAchievementStep(stepToDelete);
}
_stepsToDelete.Clear();
}
if (GeneralTimeSpent >= 10000)
{
// TODO: make custom alert (at top of screen with animation)
await UserDialogs.Instance.AlertAsync("Achieved");
model.AchievedDate = DateTime.Now;
}
await NavigationService.NavigateBackAsync();
}
public void SaveGame()
{
//kaimyoResult = GetKaimyoFromScore();
AchievementRepository arepos = GetComponent <AchievementRepository>();
arepos.SaveAchievement(score, kaimyoResult, aquiredTokuAchievementIdList);
}
public async Task TestAchievementRepositoryReturnsList()
{
var achievementsRepository = new AchievementRepository();
var actual = await achievementsRepository.GetAll().ConfigureAwait(false);
Assert.IsNotNull(actual);
Assert.IsTrue(actual.Any());
}
/// <summary>
/// Creates a new unit of work for the various database repositories
/// </summary>
public UnitOfWork()
{
_entityContext = new JustPressPlayDBEntities();
_achievementRepo = new AchievementRepository(this);
_questRepo = new QuestRepository(this);
_userRepo = new UserRepository(this);
_systemRepo = new SystemRepository(this);
}
public StatsViewModel(DialogService dialogService)
{
_dialogService = dialogService;
_gameRepo = new GameRepository();
_playerRepo = new PlayerRepository();
_achievementRepo = new AchievementRepository();
_oneDriveService = new OneDriveService();
Setup();
}
public async Task Handle(AchievementCompletedEvent notification, CancellationToken cancellationToken)
{
using (var connection = this._dbConnectionFactory.OpenConnection())
{
var achievementCompletionRepository = new AchievementRepository();
await achievementCompletionRepository.CompletedAsync(connection, notification.AggregateId,
notification.CompletedOn);
}
}
public async Task Handle(AchievementCreatedEvent notification, CancellationToken cancellationToken)
{
using (var connection = this._dbConnectionFactory.OpenConnection())
{
var achievementRepository = new AchievementRepository();
await achievementRepository.CreateNewAsync(connection, notification.AggregateId, notification.Name,
notification.RunningNumberId);
}
}
static void Main(string[] args)
{
var archievementRepository = new AchievementRepository();
foreach (var entry in _achivements)
{
archievementRepository.Create(entry.Key, entry.Value);
}
}
public void Setup()
{
_gameRepo = new GameRepository();
_playerRepo = new PlayerRepository();
_achievementRepo = new AchievementRepository();
totalGames = _gameRepo.GetTotalGames();
GetPlayersData();
GetOverallData();
}
public HomeController(ContactRepository contactRepository, PrivateInformationRepository privateInformationRepository, AchievementRepository achievementRepository, AdditionalInformationRepository additionalInformationRepository, EducationRepository educationRepository, EmploymentHistoryRepository employmentHistoryRepository, ProjectsRepository projectsRepository, TechnologyRepository technologyRepository)
{
_contactRepository = contactRepository;
_privateInformationRepository = privateInformationRepository;
_achievementRepository = achievementRepository;
_additionalInformationRepository = additionalInformationRepository;
_educationRepository = educationRepository;
_employmentHistoryRepository = employmentHistoryRepository;
_projectsRepository = projectsRepository;
_technologyRepository = technologyRepository;
}
internal void AddAchievements()
{
foreach (Player player in game.players)
{
foreach (Achievement achievement in player.achievements)
{
AchievementRepository achievementRepo = new AchievementRepository();
achievementRepo.AddAchievement(achievement);
}
}
}
public UnitOfWork(ApplicationContext applicationContext)
{
_dbContext = applicationContext;
Achievements = new AchievementRepository(applicationContext);
Comments = new CommentRepository(applicationContext);
Posts = new PostRepository(applicationContext);
PostTags = new PostTagsRepository(applicationContext);
Tags = new TagRepository(applicationContext);
UserAchievements = new UserAchievementsRepository(applicationContext);
Users = new UserRepository(applicationContext);
AuthorizedUsers = new AuthorizedUsersRepository(applicationContext);
Votes = new VoteRepository(applicationContext);
}
void Start()
{
gameManager = FindObjectOfType <GameManager>();
listView.SetActive(true);
summaryView.SetActive(false);
achiRepos = gameManager.GetComponent <AchievementRepository>();
achieve = achiRepos.LoadAchievement();
List <int> achievedIdList = achieve.achievedIdList;
AssginTiles(achievedIdList);
SetSummary();
}
/// <summary>
/// Client used to access the Guild Wars 2 REST API.
/// </summary>
/// <param name="apiKey">Official API key provided from ArenaNet.</param>
public GW2Client(string apiKey = null)
{
Achievements = new AchievementRepository();
Items = new ItemRepository();
Misc = new MiscRepository();
PvE = new PvERepository();
PvP = new PvPRepository();
Skills = new SkillRepository();
ApiKey = apiKey;
Account = new AccountRepository(ApiKey);
Characters = new CharacterRepository(ApiKey);
Commerce = new CommerceRepository(ApiKey);
Guilds = new GuildRepository(ApiKey);
}
public GameConsole()
{
gameState = new GameState
{
Running = true
};
var rewardsRepo = new RewardRepository(@".\Resources\Dat\rewards.csv");
var achievementsRepo = new AchievementRepository(@".\Resources\Dat\achievements.csv", gameState);
var gameItemsRepo = new GameItemRepository(@".\Resources\Dat\gameItems.csv");
var storeInventoryRepo = new StoryInventoryRepository(@".\Resources\Dat\storeInventory.csv");
gateway = new DataGateway(rewardsRepo, gameItemsRepo, achievementsRepo, storeInventoryRepo);
commandsGroup = new TopCommandGroupFactory().Build();
gameState.Lobby = new LobbyRoom(gameState, new[] { "Welcome to the Lobby" }, GameMode.Lobby, commandsGroup);
gameState.Store = gameState.Store ?? new MinerStoreFactory(gameState, commandsGroup, gateway).Build();
gameState.ControlRoom = new ControlRoomFactory(gameState, commandsGroup).Build();
gameState.ClaimsOffice = new ClaimsOfficeRoomFactory(gameState, commandsGroup, gateway).Build();
gameState.SaveDirectory = @"c:\chipMiner\saves";
gameState.GameTime.Start();
IsVisible = true;
IsFocused = true;
StartGame();
hud = new HudConsole(gameState)
{
Position = new Point(0, 0)
};
input = new InputConsole(this, gameState)
{
Position = new Point(1, 34)
};
output = new OutputConsole(this, 83)
{
Position = new Point(1, 1)
};
events = new GameEventsConsole(this, 83)
{
Position = new Point(85, 1)
};
Children.Add(hud);
Children.Add(input);
Children.Add(output);
Children.Add(events);
Global.FocusedConsoles.Set(input);
}
public override Task InitializeAsync(object navigationData)
{
_achievementId = (int)navigationData;
if (_achievementId == 0)
{
Title = Resmgr.Value.GetString(ConstantsHelper.CreateAchievement, CultureInfo.CurrentCulture);
}
else
{
var model = AchievementRepository.GetAchievementAsync(_achievementId);
GeneralTimeSpent = model.GeneralTimeSpent;
Title = model.Title;
Description = model.Description;
AchievementSteps = model.AchievementSteps.ToAchievementStepViewModels();
}
return(base.InitializeAsync(navigationData));
}
public Rmh_Repositories()
{
Achievements = new AchievementRepository();
CraftableItems = new CraftableItemRepository();
CraftLists = new CraftListRepository();
Items = new ItemRepository();
Dismantle = new DismantleRepository();
QuestItems = new QuestItemRepository();
Interactable = new InteractableRepository();
Enemies = new EnemyRepository();
Vendor = new NPCVendorRepository();
Quests = new QuestRepository();
Skills = new SkillRepository();
StatusEffects = new StatusEffectRepository();
Talents = new TalentRepository();
WorldMap = new WorldMapRepository();
LootTables = new LootTableRepository();
}
public void GetTest()
{
//var mockSet = new Mock<DbSet<Achievement>>();
//var mockContext = new Mock<ApplicationDbContext>();
//mockContext.Setup(m => m.Achievements).Returns(mockSet.Object);
//IRepository<Achievement, int> _repository = new AchievementRepository(mockContext.Object);
//System.Console.WriteLine("'tt");
//Achievement achievement = new Achievement(){Date = DateTime.Now, Title = "test", Description = "testdesc", ShowInCv = false};
//mockSet.Verify(m => m.Add(It.IsAny<Achievement>()), Times.Once);
////mockContext.Verify(m => m.SaveChanges(), Times.Once);
//mockContext.Verify(m => m.SaveChanges(), Times.Once());
// Arrange
var userContextMock = new Mock <ApplicationDbContext>();
var usersMock = new Mock <DbSet <Achievement> >();
//usersMock.Setup(x => x.Add(It.IsAny<Achievement>())).Returns((Achievement) u) => u);
usersMock.Setup(x => x.Add(It.IsAny <Achievement>())).Returns((Achievement u) => u);
userContextMock.Setup(x => x.Achievements).Returns(usersMock.Object);
IRepository <Achievement, int> _repository = new AchievementRepository(userContextMock.Object);
Achievement achievement = new Achievement()
{
Date = DateTime.Now, Title = "test", Description = "testdesc", ShowInCv = false
};
_repository.Add(achievement);
// Assert
Assert.NotNull(achievement);
usersMock.Verify(
x =>
x.Add(
It.Is <Achievement>(
u =>
u.Title == "test" && u.Description == "testdesc" && u.ShowInCv == false)), Times.Once);
userContextMock.Verify(x => x.SaveChanges(), Times.Once);
ApplicationDbContext context = new ApplicationDbContext();
}
public AchievementControllerTests()
{
IQueryable <Achievement> achievements = _achievements.AsQueryable();
_mockSet.As <IQueryable <Achievement> >().Setup(m => m.Provider).Returns(achievements.Provider);
_mockSet.As <IQueryable <Achievement> >().Setup(m => m.Expression).Returns(achievements.Expression);
_mockSet.As <IQueryable <Achievement> >().Setup(m => m.ElementType).Returns(achievements.ElementType);
_mockSet.As <IQueryable <Achievement> >().Setup(m => m.GetEnumerator()).Returns(() => achievements.GetEnumerator());
_mockSet.Setup(d => d.Add(It.IsAny <Achievement>())).Callback <Achievement>((s) => _achievements.Add(s));
_mockSet.Setup(d => d.Remove(It.IsAny <Achievement>())).Callback <Achievement>((s) => _achievements.Remove(s));
_dbMock.Setup(x => x.SaveChanges()).Returns(1).Verifiable();
_dbMock.Setup(x => x.Achievements).Returns(_mockSet.Object);
AchievementRepository repository = new AchievementRepository(_dbMock.Object);
_controller = new AchievementController(repository);
}
public async Task CompletingAchievement_ShouldCompleteProjection()
{
using (var connection = this._testInfrastructure.OpenDatabaseConnection())
{
// Arrange
var commandDispatcher = this._testInfrastructure.DiContainer.GetInstance <IMediator>();
var repository = new AchievementRepository();
var command = new CreateAchievementCommand("Test", 1, 5);
var newAchievement = await commandDispatcher.Send(command);
var command2 = new CompleteAchievementCommand(newAchievement.AchievementId);
// Act
var completedResponse = await commandDispatcher.Send(command2);
var projection = await repository.GetByIdAsync(connection, newAchievement.AchievementId);
// Assert
Assert.That(projection.CompletedOn, Is.Not.Null);
}
}
public async Task Creating_Achievement_ShouldCreateProjection()
{
using (var connection = this._testInfrastructure.OpenDatabaseConnection())
{
// Arrange
var commandDispatcher = this._testInfrastructure.DiContainer.GetInstance <IMediator>();
var repository = new AchievementRepository();
var command = new CreateAchievementCommand("Test", 1, 5);
// Act
var newAchievement = await commandDispatcher.Send(command);
var projection = await repository.GetByIdAsync(connection, newAchievement.AchievementId);
// Assert
Assert.That(newAchievement.AchievementId, Is.Not.EqualTo(Guid.Empty));
Assert.That(projection, Is.Not.Null);
Assert.That(projection.AchievementId, Is.EqualTo(newAchievement.AchievementId));
Assert.That(projection.Name, Is.EqualTo(command.Name));
}
}
public App()
{
InitializeComponent();
string dbPath = DependencyService.Get <IFileHelper>().GetLocalFilePath(ConstantsHelper.SqLiteDataBaseName);
NoteRepository = new NoteRepository(dbPath);
ToDoRepository = new ToDoRepository(dbPath);
AchievementRepository = new AchievementRepository(dbPath);
UserRepository = new UserRepository(dbPath);
BirthdaysRepository = new BirthdaysRepository(dbPath);
bool.TryParse(Settings.UsePin, out bool shouldUsePin);
if (shouldUsePin)
{
MainPage = new PinPage();
}
else
{
MainPage = new LoginPage();
}
MessagingCenter.Subscribe <object, string>(this, NotificationReceivedKey, OnMessageReceived);
}
public GetAchievementResponse GetAchievements(GetAchievementRequest request)
{
var user = UserRepository.RetrieveUser(request.SessionId);
if (user == null)
{
return(new GetAchievementResponse
{
Success = false,
ErrorMessage = "User not Found"
});
}
var currentAchievements = AchievementRepository.RetrieveUserAchievements(user.UserId);
var outstandingAchievements = AchievementRepository.RetrieveOutstandingUserAchievements(user.UserId);
return(new GetAchievementResponse
{
Success = true,
UsersAchievements = MapOutAchievements(currentAchievements),
RemainingAchievements = MapOutAchievements(outstandingAchievements)
});
}
public RegisterTagResponse RegisterTag(RegisterTagRequest request)
{
var tag = TagRepository.RetrieveTag(request.BeaconId,
request.BeaconMajorVersion,
request.BeaconMinorVersion);
if (tag == null || !tag.Active)
{
return(CreateFailedTagResponse("Tag not active"));
}
var user = UserRepository.RetrieveUser(request.SessionId);
if (user == null)
{
return(CreateFailedTagResponse("Session not Valid"));
}
var tagType = TagTypeRepository.RetrieveTagType(tag.TagTypeId);
if (tagType == null)
{
return(CreateFailedTagResponse("Invalid Tag Type"));
}
if (TagRepository.CheckTagIsNotWithinTimeout(user.UserId, tag.TagId, tagType.LockoutTimePeriod))
{
return(CreateFailedTagResponse("Tag seen within Timeout"));
}
var pointsScored = tagType.Points + tag.AdditionalPoints;
var achievements = AchievementRepository.RetrieveAvailableAchievements(user.UserId, tag.TagId);
var achievementNames = new List <string>();
if (achievements != null)
{
foreach (var achievement in achievements)
{
achievementNames.Add(achievement.AchievementName);
if (achievement.RewardPoints > 0)
{
TransactionRepository.CreateTransaction(user.UserId, achievement.RewardPoints, TransactionType.AchievementBonus);
}
}
}
TransactionRepository.CreateTransactionForUserAndTag(user.UserId, pointsScored, tag.TagId, TransactionType.Tag);
user = UserRepository.UpdateUser(user);
var top = UserRepository.RetrieveTopLeaderboard(3, user.UserId);
return(new RegisterTagResponse
{
PointsScored = pointsScored,
NewPointsTotal = TransactionRepository.GetUsersPoints(user.UserId),
UsablePoints = TransactionRepository.GetUsersUsablePoints(user.UserId),
Achievements = achievementNames.ToArray(),
Top10 = top.Select(LeaderboardResponseEntry.FromModel).ToArray(),
Ranking = 0,
LockoutTime = tagType.LockoutTimePeriod,
Success = true,
ErrorMessage = string.Empty
});
}
void ClearData()
{
AchievementRepository arepos = FindObjectOfType <AchievementRepository>();
arepos.ClearAchievement();
}
public ClubManagerEFCoreService(ClubManagerDbContext db) : base()
{
DbContext = db;
Achievements = new AchievementRepository(db);
Context = new HttpContextAccessor();
}
public AchievementController(AchievementRepository repo)
{
_repository = repo;
}
