public void InsertSteamIdentity()
{
// arrange
// act
var result = _steamIdentityService.Upsert(SteamIdentity()).GetAwaiter().GetResult();
// assert
var steamIdentities = _steamIdentityService.FindAll().GetAwaiter().GetResult();
steamIdentities.Should().HaveCount(1);
}
public async Task <IActionResult> EditWhiteList(int serverId)
{
if (!await RightsHandler.HasRightsToThisPavlovServer(HttpContext.User,
await _userservice.getUserFromCp(HttpContext.User), serverId, _service, _pavlovServerService))
{
return(Forbid());
}
var server = await _pavlovServerService.FindOne(serverId);
var steamIds = (await _steamIdentityService.FindAll()).ToArray();
var selectedSteamIds = (await _whitelistService.FindAllFrom(server)).ToArray();
if (server.Shack)
{
steamIds = steamIds.Where(x => !string.IsNullOrEmpty(x.OculusId)).ToArray();
}
//service
var model = new PavlovServerWhitelistViewModel
{
Shack = server.Shack,
steamIds = selectedSteamIds.Select(x => x.SteamIdentityId).ToList(),
pavlovServerId = server.Id
};
ViewBag.SteamIdentities = steamIds.ToList();
return(View("WhiteList", model));
}
public void SteamIdentitiesToReturn()
{
// arrange
var user = InsertUserAndSteamIdentity(_steamIdentityService, _userManager);
var pavlovServers = InsertToPavlovServer(user, _sshServerSerivce, _pavlovServerService,
_serverSelectedModsService, false);
// act
var steamIdentities = _serverSelectedModsService
.SteamIdentitiesToReturn(new List <string> {
user.Id.ToString()
}, pavlovServers.First(),
_steamIdentityService.FindAll().GetAwaiter().GetResult().ToList()).GetAwaiter().GetResult();
var steamIdentitiesInserted =
_serverSelectedModsService.FindAllFrom(pavlovServers.First()).GetAwaiter().GetResult();
// assert
steamIdentities.Should().HaveCount(1);
steamIdentitiesInserted.Should().HaveCount(1);
}
private void CreateAndInitializeATeamWithAMember(out LiteDbUser user, out SteamIdentity steamIdentity,
out Team team)
{
user = ServerSelectedModServiceTests.InsertUserAndSteamIdentity(_steamIdentityService, _userManager);
steamIdentity = _steamIdentityService.FindAll().GetAwaiter().GetResult().First();
team = CreateTeam(_teamService);
_teamSelectedSteamIdentityService.Insert(new TeamSelectedSteamIdentity
{
Team = team,
SteamIdentity = steamIdentity,
RoleOverwrite = ""
});
}
public async Task <IActionResult> EditTeam(Team team)
{
if (team == null)
{
return(BadRequest("please set a Team"));
}
var user = await _userService.getUserFromCp(HttpContext.User);
var servers = await _teamService.FindAllTeamsWhereTheUserHasRights(HttpContext.User, user);
if (team.Id != 0)
{
if (!servers.Select(x => x.Id).Contains(team.Id))
{
return(Forbid());
}
}
team.AllSteamIdentities = (await _steamIdentityService.FindAll()).ToList();
team.TeamSelectedSteamIdentities = (await _teamSelectedSteamIdentityService.FindAllFrom(team.Id)).ToList();
return(View("Team", team));
}
public async Task <IActionResult> PartialViewPerGameMode(string gameMode, Match match, bool shack)
{
var user = await _userservice.getUserFromCp(HttpContext.User);
var servers = await _matchService.FindAllMatchesWhereTheUserHasRights(HttpContext.User, user);
if (match.Id != 0 && !servers.Select(x => x.Id).Contains(match.Id))
{
return(Forbid());
}
var selectedSteamIdentitiesRaw =
(await _matchSelectedSteamIdentitiesService.FindAllSelectedForMatch(match.Id)).ToList();
var selectedTeam0SteamIdentitiesRaw =
(await _matchSelectedTeamSteamIdentitiesService.FindAllSelectedForMatchAndTeam(match.Id, 0)).ToList();
var selectedTeam1SteamIdentitiesRaw =
(await _matchSelectedTeamSteamIdentitiesService.FindAllSelectedForMatchAndTeam(match.Id, 1)).ToList();
var Teams = (await _teamService.FindAll()).ToList();
var steamIdentities = new List <SteamIdentity>();
if (shack)
{
steamIdentities = (await _steamIdentityService.FindAll()).Where(x => !string.IsNullOrEmpty(x.OculusId)).ToList();
}
else
{
steamIdentities = (await _steamIdentityService.FindAll()).ToList();
}
var selectedSteamIdentities =
(await _steamIdentityService.FindAList(selectedSteamIdentitiesRaw.Select(x => x.SteamIdentityId)
.ToList())).ToList();
var selectedTeam0SteamIdentities =
(await _steamIdentityService.FindAList(selectedTeam0SteamIdentitiesRaw.Select(x => x.SteamIdentityId)
.ToList())).ToList();
var selectedTeam1SteamIdentities =
(await _steamIdentityService.FindAList(selectedTeam1SteamIdentitiesRaw.Select(x => x.SteamIdentityId)
.ToList())).ToList();
foreach (var selectedSteamIdentity in selectedSteamIdentities)
{
steamIdentities.Remove(steamIdentities.FirstOrDefault(x => x.Id == selectedSteamIdentity.Id));
}
var gotAnswer = GameModes.HasTeams.TryGetValue(gameMode, out var hasTeams);
var idUsed = "Id";
if (shack)
{
idUsed = "OculusId";
}
if (gotAnswer)
{
if (hasTeams)
{
var gotAnswer2 = GameModes.OneTeam.TryGetValue(gameMode, out var oneTeam);
if (gotAnswer2)
{
if (oneTeam)
{
return(PartialView("SteamIdentityPartialView", new SteamIdentityMatchViewModel
{
SelectedSteamIdentities = selectedSteamIdentities,
AllSteamIdentities = steamIdentities,
IdUsed = idUsed
}));
}
return(PartialView("TeamPartailView", new SteamIdentityMatchTeamViewModel
{
selectedTeam0 = match.Team0?.Id,
selectedTeam1 = match.Team1?.Id,
AvailableTeams = Teams,
SelectedSteamIdentitiesTeam0 = selectedTeam0SteamIdentities,
SelectedSteamIdentitiesTeam1 = selectedTeam1SteamIdentities,
IdUsed = idUsed
}));
}
BadRequest("internal error!");
}
else
{
return(PartialView("SteamIdentityPartialView", new SteamIdentityMatchViewModel
{
SelectedSteamIdentities = selectedSteamIdentities,
AllSteamIdentities = steamIdentities
}));
}
}
else
{
return(BadRequest("There is no gameMode like that!"));
}
return(BadRequest("There is no gameMode like that!"));
}
