public async Task <int> GetMapsCount(MapsFilterModel filterModel)
{
if (filterModel == null)
{
filterModel = new MapsFilterModel();
}
return(await _legacyContext.Maps.ApplyFilter(filterModel).CountAsync());
}
public async Task <List <MapDto> > GetMaps(MapsFilterModel filterModel)
{
if (filterModel == null)
{
filterModel = new MapsFilterModel();
}
var maps = await _legacyContext.Maps.ApplyFilter(filterModel).ToListAsync();
var results = maps.Select(m => m.ToDto(_options.MapRedirectBaseUrl)).ToList();
return(results);
}
// ReSharper disable once UnusedMember.Global
public async Task RunMapRedirectSync([TimerTrigger("0 0 * * * *")] TimerInfo myTimer, ILogger log)
{
log.LogDebug($"Start RunMapRedirectSync @ {DateTime.UtcNow}");
var stopWatch = new Stopwatch();
stopWatch.Start();
var gamesToSync = new Dictionary <GameType, string>
{
{ GameType.CallOfDuty4, "cod4" },
{ GameType.CallOfDuty5, "cod5" }
};
foreach (var game in gamesToSync)
{
var mapRedirectEntries = _mapRedirectRepository.GetMapEntriesForGame(game.Value);
var mapsFilterModel = new MapsFilterModel
{
GameType = game.Key
};
var mapDatabaseEntries = await _mapsRepository.GetMaps(mapsFilterModel);
log.LogDebug("Total maps retrieved from redirect for {game} is {redirectMapCount} and database is {databaseMapCount}", game, mapRedirectEntries.Count, mapDatabaseEntries.Count);
foreach (var mapDto in mapDatabaseEntries)
{
if (mapRedirectEntries.Any(mre => mre.MapName == mapDto.MapName))
{
var mapRedirectEntry = mapRedirectEntries.Single(mre => mre.MapName == mapDto.MapName);
var mapFiles = mapRedirectEntry.MapFiles.Where(file => file.EndsWith(".iwd") | file.EndsWith(".ff")).ToList();
if (mapFiles.Count != mapDto.MapFiles.Count)
{
log.LogDebug("Map {MapName} map file count differs", mapDto.MapName);
mapDto.MapFiles = mapFiles.Select(mf => new MapFileDto
{
FileName = mf
}).ToList();
await _mapsRepository.UpdateMap(mapDto);
}
}
else
{
if (!_defaultMaps.Contains(mapDto.MapName))
{
try
{
if (mapDto.TotalVotes > 0)
{
mapDto.MapFiles = new List <MapFileDto>();
await _mapsRepository.UpdateMap(mapDto);
}
else
{
log.LogDebug("Deleting {MapName} as it is not on the redirect", mapDto.MapName);
await _mapsRepository.DeleteMap(mapDto.MapId);
}
}
catch (Exception ex)
{
log.LogError(ex, "Error deleting map from database");
}
}
}
}
foreach (var mapRedirectEntry in mapRedirectEntries)
{
if (mapDatabaseEntries.All(mde => mde.MapName != mapRedirectEntry.MapName))
{
log.LogDebug("Map {MapName} is missing from the database", mapRedirectEntry.MapName);
var mapFiles = mapRedirectEntry.MapFiles.Where(file => file.EndsWith(".iwd") | file.EndsWith(".ff")).ToList();
var mapDto = new MapDto
{
GameType = game.Key,
MapName = mapRedirectEntry.MapName,
MapFiles = mapFiles.Select(mf => new MapFileDto
{
FileName = mf
}).ToList()
};
await _mapsRepository.CreateMap(mapDto);
}
}
}
stopWatch.Stop();
log.LogDebug($"Stop RunMapRedirectSync @ {DateTime.UtcNow} after {stopWatch.ElapsedMilliseconds} milliseconds");
}
public async Task <IActionResult> GetMapListAjax(GameType?id)
{
var reader = new StreamReader(Request.Body);
var requestBody = await reader.ReadToEndAsync();
var model = JsonConvert.DeserializeObject <DataTableAjaxPostModel>(requestBody);
if (model == null)
{
return(BadRequest());
}
var filterModel = new MapsFilterModel();
if (id != null)
{
filterModel.GameType = (GameType)id;
}
var recordsTotal = await _mapsRepository.GetMapsCount(filterModel);
filterModel.FilterString = model.Search?.Value;
var recordsFiltered = await _mapsRepository.GetMapsCount(filterModel);
filterModel.TakeEntries = model.Length;
filterModel.SkipEntries = model.Start;
if (model.Order == null)
{
filterModel.Order = MapsFilterModel.OrderBy.MapNameAsc;
}
else
{
var orderColumn = model.Columns[model.Order.First().Column].Name;
var searchOrder = model.Order.First().Dir;
switch (orderColumn)
{
case "mapName":
filterModel.Order = searchOrder == "asc" ? MapsFilterModel.OrderBy.MapNameAsc : MapsFilterModel.OrderBy.MapNameDesc;
break;
case "popularity":
filterModel.Order = searchOrder == "asc" ? MapsFilterModel.OrderBy.LikeDislikeAsc : MapsFilterModel.OrderBy.LikeDislikeDesc;
break;
case "gameType":
filterModel.Order = searchOrder == "asc" ? MapsFilterModel.OrderBy.GameTypeAsc : MapsFilterModel.OrderBy.GameTypeDesc;
break;
}
}
var mapDtos = await _mapsRepository.GetMaps(filterModel);
var portalMapDtos = mapDtos.Select(m => new PortalMapDto(m)).ToList();
return(Json(new
{
model.Draw,
recordsTotal,
recordsFiltered,
data = portalMapDtos
}));
}
public async Task <IActionResult> ServerInfo(Guid id)
{
var gameServer = await _gameServersRepository.GetGameServer(id);
var gameServerStatusDto = await _gameServerStatusRepository.GetStatus(id, TimeSpan.Zero);
var serversFilterModel = new GameServerStatusStatsFilterModel
{
ServerId = gameServer.ServerId,
Cutoff = DateTime.UtcNow.AddDays(-2),
Order = GameServerStatusStatsFilterModel.OrderBy.TimestampAsc
};
var gameServerStatusStatsDtos = await _gameServerStatusStatsRepository.GetGameServerStatusStats(serversFilterModel);
var mapTimelineDataPoints = new List <MapTimelineDataPoint>();
DateTime?timestamp = null;
string trackMap = null;
if (gameServerStatusStatsDtos.Any())
{
var lastItem = gameServerStatusStatsDtos.Last();
foreach (var item in gameServerStatusStatsDtos.Where(gss => gss.Timestamp > DateTime.UtcNow.AddDays(-1)))
{
if (trackMap == null)
{
trackMap = item.MapName;
timestamp = item.Timestamp.UtcDateTime;
}
else
{
if (item == lastItem)
{
mapTimelineDataPoints.Add(new MapTimelineDataPoint
{
MapName = trackMap,
Start = (DateTime)timestamp,
Stop = item.Timestamp.UtcDateTime
});
continue;
}
if (trackMap == item.MapName)
{
continue;
}
mapTimelineDataPoints.Add(new MapTimelineDataPoint
{
MapName = trackMap,
Start = (DateTime)timestamp,
Stop = item.Timestamp.UtcDateTime
});
timestamp = item.Timestamp.UtcDateTime;
trackMap = item.MapName;
}
}
}
MapDto map = null;
if (gameServerStatusDto != null)
{
map = await _mapsRepository.GetMap(gameServerStatusDto.GameType, gameServerStatusDto.Map);
}
var mapsFilterModel = new MapsFilterModel
{
GameType = gameServer.GameType,
MapNames = gameServerStatusStatsDtos.GroupBy(m => m.MapName).Select(m => m.Key).ToList()
};
var maps = await _mapsRepository.GetMaps(mapsFilterModel);
return(View(new ServerInfoViewModel
{
GameServer = gameServer,
GameServerStatus = gameServerStatusDto,
Map = map,
Maps = maps,
GameServerStatusStats = gameServerStatusStatsDtos,
MapTimelineDataPoints = mapTimelineDataPoints
}));
}
public static IQueryable <Data.Legacy.Models.Maps> ApplyFilter(this IQueryable <Data.Legacy.Models.Maps> maps, MapsFilterModel filterModel)
{
maps = maps.Include(m => m.MapFiles).Include(m => m.MapVotes).AsQueryable();
if (filterModel.GameType != GameType.Unknown)
{
maps = maps.Where(m => m.GameType == filterModel.GameType).AsQueryable();
}
if (!string.IsNullOrWhiteSpace(filterModel.FilterString))
{
maps = maps.Where(m => m.MapName.Contains(filterModel.FilterString)).AsQueryable();
}
if (filterModel.MapNames != null)
{
maps = maps.Where(m => filterModel.MapNames.Contains(m.MapName)).AsQueryable();
}
switch (filterModel.Order)
{
case MapsFilterModel.OrderBy.MapNameAsc:
maps = maps.OrderBy(m => m.MapName).AsQueryable();
break;
case MapsFilterModel.OrderBy.MapNameDesc:
maps = maps.OrderByDescending(m => m.MapName).AsQueryable();
break;
case MapsFilterModel.OrderBy.LikeDislikeAsc:
maps = maps.Where(m => m.MapVotes.Any()).OrderBy(m => m.MapVotes.Count(mv => mv.Like)).AsQueryable();
break;
case MapsFilterModel.OrderBy.LikeDislikeDesc:
maps = maps.Where(m => m.MapVotes.Any()).OrderByDescending(m => m.MapVotes.Count(mv => mv.Like)).AsQueryable();
break;
case MapsFilterModel.OrderBy.GameTypeAsc:
maps = maps.OrderBy(m => m.GameType).AsQueryable();
break;
case MapsFilterModel.OrderBy.GameTypeDesc:
maps = maps.OrderByDescending(m => m.GameType).AsQueryable();
break;
default:
throw new ArgumentOutOfRangeException();
}
maps = maps.Skip(filterModel.SkipEntries).AsQueryable();
if (filterModel.TakeEntries != 0)
{
maps = maps.Take(filterModel.TakeEntries).AsQueryable();
}
return(maps);
}
