static void Main(string[] args)
{
string content = new WebClient().DownloadString(String.Format(urlFormat, numero_scrutin));
var htmlDoc = new HtmlDocument();
htmlDoc.LoadHtml(content);
var resultsByGroup = htmlDoc.DocumentNode.SelectNodes("//div").Where(node => node.HasClass("TTgroupe") && node.HasClass("topmargin-lg"));
Dictionary <string, GroupResults> results = new Dictionary <string, GroupResults>();
foreach (var group in resultsByGroup)
{
string groupName = Decode(group.ChildNodes.Where(c => c.HasClass("agroupe")).First().GetAttributeValue("name", "unknown")).Replace("Groupe de la ", "").Replace("Groupe du ", "").Replace("Groupe ", "");
if (!results.ContainsKey(groupName))
{
var groupe = new GroupResults(groupName);
results.Add(groupName, groupe);
groupe.Contre = ExtractDeputes(group, groupName, "Contre");
groupe.NonVotants = ExtractDeputes(group, groupName, "Non-votants");
groupe.Pour = ExtractDeputes(group, groupName, "Pour");
groupe.Abstention = ExtractDeputes(group, groupName, "Abstention");
}
}
string json = JsonConvert.SerializeObject(results.Values);
}
private static void SetEnvironmentSummary(this GroupResults result)
{
var all = result.Groups.SelectMany(g => g.Services.SelectMany(s => s.Results));
var groupedByEnvironment = all.GroupBy(r => r.Environment);
foreach (var e in groupedByEnvironment)
{
if (e.Any(x => x.Status == StatusType.Down))
{
result.Environments.Add(
new GroupResult
{
Environment = e.Key,
Status = StatusType.Down
});
}
else
{
result.Environments.Add(
new GroupResult
{
Environment = e.Key,
Status = StatusType.Up
});
}
}
Cleanup(result);
}
public async Task <OperationResult <GroupResults> > GetGroupResults(int testId)
{
var scheduledTest = await dbContext.ScheduledTests.Include(x => x.TestTemplate).FirstOrDefaultAsync(x => x.Id == testId);
if (scheduledTest == null)
{
return(new BadRequestError());
}
if (scheduledTest.TestTemplate.AuthorId != userContext.UserId)
{
return(new AuthorizationError());
}
var testEndedResult = await HasTestComeToEnd(testId);
if (!testEndedResult.Succeeded)
{
return(testEndedResult.Error);
}
var query = from UserTest in dbContext.UserTests.Where(x => x.ScheduledTestId == testId)
from User in dbContext.Users.Where(x => x.Id == UserTest.UserId)
from UserAnswer in dbContext.UserAnswers.Where(ua => ua.ScheduledTestId == UserTest.ScheduledTestId && ua.UserId == UserTest.UserId).DefaultIfEmpty()
from Answer in dbContext.Answers.Where(an => an.QuestionId == UserAnswer.QuestionId).DefaultIfEmpty()
select new { UserTest, UserId = User.Id, User.UserName, UserAnswer, Answer };
var queryResults = await query.ToArrayAsync();
var allAnswers = await dbContext.TestItems.Include(x => x.Question).ThenInclude(x => x.Answer)
.Where(x => x.TestTemplateId == scheduledTest.TestTemplateId)
.Select(x => x.Question.Answer)
.ToArrayAsync();
float maxTestScore = allAnswers.Select(x => x.MaxScore).Aggregate((x, y) => x + y);
var userIdTestAnswer = new Dictionary <int, TestAnswers>();
foreach (var queryResult in queryResults)
{
var userId = queryResult.UserId;
if (!userIdTestAnswer.ContainsKey(userId))
{
userIdTestAnswer.Add(userId, new TestAnswers(scheduledTest, queryResult.UserTest, queryResult.UserName, dateTimeProvider));
}
userIdTestAnswer[userId].AddAnswerPair(queryResult.UserAnswer, queryResult.Answer);
}
var testResults = userIdTestAnswer.Select(x => x.Value.GetTestResult()).ToList();
var groupResults = new GroupResults(scheduledTest.Id,
scheduledTest.TestTemplate.Name,
maxTestScore,
testResults,
testEndedResult.Data);
return(groupResults);
}
public GroupResultsDto MapToGroupResultsDto(GroupResults results)
{
return(new GroupResultsDto
{
Ended = results.Ended,
MaxTestScore = results.MaxTestScore,
TestId = results.ScheduledTestId,
TestName = results.TestName,
Results = results.Results.Select(MapToUserTestResultDto).ToList()
});
}
private static Group GetOrAddGroup(this GroupResults groupResults, string name)
{
Group group = groupResults.Groups.FirstOrDefault(g => g.Name == name);
if (group == null)
{
group = new Group {
Name = name
};
groupResults.Groups.Add(group);
}
return(group);
}
public void ShouldReturnEmptyPaginationForNoGroups()
{
// Arrange
var groupResults = new GroupResults()
{
Groups = new List <Group>()
};
// Act
_service.DoPagination(groupResults, 0, 0);
// Assert
groupResults.Pagination.Should().BeEquivalentTo(new Pagination());
}
public static GroupResults AsGroupResults(this GenericResults results)
{
var groupResults = new GroupResults {
Date = results.Date
};
foreach (var genericResult in results.Results)
{
groupResults.GetOrAddGroup(genericResult.Group)
.GetOrAddService(genericResult.Name)
.GetOrAddResult(genericResult.Environment, genericResult.Status);
}
groupResults.SetEnvironmentSummary();
return(groupResults);
}
private GroupsController SetUpController(int numGroups)
{
var listOfGroups = BuildGroupList(numGroups);
var bigGroupResults = new GroupResults {
Groups = listOfGroups
};
_repository.Setup(o =>
o.Get <GroupResults>(
It.IsAny <string>(),
It.IsAny <List <Query> >()))
.ReturnsAsync(StockportWebapp.Http.HttpResponse.Successful((int)HttpStatusCode.OK, bigGroupResults));
var mockTime = new Mock <ITimeProvider>();
var viewHelper = new ViewHelpers(mockTime.Object);
return(new GroupsController(_processedRepository.Object, _repository.Object, _groupEmailBuilder.Object, _eventEmailBuilder.Object, _filteredUrl.Object, _logger.Object, _configuration.Object, _markdownWrapper.Object, viewHelper, datetimeCalculator, null, _groupsService.Object, _cookiesHelper.Object, new StockportWebapp.FeatureToggling.FeatureToggles()));
}
public void IfSpecifiedPageNumIsImpossibleThenActualPageNumWillBeAdjustedAccordingly(
int specifiedPageNumber,
int numItems,
int expectedPageNumber)
{
var groupResults = new GroupResults();
var groups = new List <Group>();
for (var i = 0; i < numItems; i++)
{
groups.Add(new GroupBuilder().Build());
}
groupResults.Groups = groups;
_service.DoPagination(groupResults, specifiedPageNumber, MaxNumberOfItemsPerPage);
groupResults.Pagination.CurrentPageNumber.Should().Be(expectedPageNumber);
}
public void DoPagination(GroupResults groupResults, int currentPageNumber, int pageSize)
{
if ((groupResults != null) && groupResults.Groups.Any())
{
var paginatedGroups = PaginationHelper.GetPaginatedItemsForSpecifiedPage(
groupResults.Groups,
currentPageNumber,
"groups",
pageSize,
_configuration.GetGroupsDefaultPageSize("stockportgov"));
groupResults.Groups = paginatedGroups.Items;
groupResults.Pagination = paginatedGroups.Pagination;
groupResults.Pagination.CurrentUrl = groupResults.CurrentUrl;
}
else
{
groupResults.Pagination = new Pagination();
}
}
public void PaginationShouldResultInCorrectNumItemsOnPageAndCorrectNumPages(
int totalNumItems,
int requestedPageNumber,
int expectedNumItemsOnPage,
int expectedNumPages)
{
var groupResults = new GroupResults();
var groups = new List <Group>();
for (var i = 0; i < totalNumItems; i++)
{
groups.Add(new GroupBuilder().Build());
}
groupResults.Groups = groups;
_service.DoPagination(groupResults, requestedPageNumber, MaxNumberOfItemsPerPage);
groupResults.Groups.Count.Should().Be(expectedNumItemsOnPage);
groupResults.Pagination.TotalPages.Should().Be(expectedNumPages);
}
/// <summary>
/// Adds missing information in per environment in case results are missing due to exceptions
/// </summary>
/// <param name="result"></param>
private static void Cleanup(GroupResults result)
{
var allEnvironments = result.Groups
.SelectMany(g => g.Services.SelectMany(s => s.Results.Select(r => r.Environment))).Distinct();
foreach (var group in result.Groups)
{
foreach (var service in group.Services)
{
foreach (var e in allEnvironments)
{
if (service.Results.All(r => r.Environment != e))
{
service.Results.Add(new GroupResult()
{
Environment = e, Status = StatusType.Unknown
});
}
}
}
}
}
//TODO:: look at the Tags lowercase potential issue
public async Task <HttpResponse> GetGroupResults(GroupSearch groupSearch, string slugs)
{
var groupResults = new GroupResults();
var builder = new QueryBuilder <ContentfulGroup>().ContentTypeIs("group").Include(1);
if (groupSearch.Longitude != 0 && groupSearch.Latitude != 0)
{
builder = builder.FieldEquals("fields.mapPosition[near]",
groupSearch.Latitude +
"," +
groupSearch.Longitude +
(groupSearch.Location.ToLower() == Defaults.Groups.Location ? ",10" : ",3.2"));
}
var subCategoriesArray = groupSearch.SubCategories.Split(',');
var subCategoriesList = subCategoriesArray.Where(c => !string.IsNullOrWhiteSpace(c));
if (!string.IsNullOrEmpty(slugs))
{
var slugsList = slugs.Split(',');
builder = builder.FieldIncludes("fields.slug", slugsList);
}
var entries = await GetAllEntriesAsync(_client, builder);
if (entries == null)
{
return(HttpResponse.Failure(HttpStatusCode.NotFound, "No groups found"));
}
var groupsWithNoCoordinates = new List <Group>();
var noCoordinatesEntries = entries;
if (groupSearch.Location.ToLower() == Defaults.Groups.Location)
{
var noCoordinatesBuilder = new QueryBuilder <ContentfulGroup>().ContentTypeIs("group").Include(1);
if (!string.IsNullOrEmpty(slugs))
{
noCoordinatesEntries = entries;
}
else
{
noCoordinatesEntries = await GetAllEntriesAsync(_client, noCoordinatesBuilder);
}
groupsWithNoCoordinates = noCoordinatesEntries.Select(g => _groupFactory.ToModel(g))
.Where(_ => _.MapPosition.Lat == 0 && _.MapPosition.Lon == 0)
.Where(g => g.CategoriesReference.Any(c =>
string.IsNullOrEmpty(groupSearch.Category) || c.Slug.ToLower() == groupSearch.Category.ToLower()))
.Where(g => string.IsNullOrWhiteSpace(groupSearch.Tags) || g.Tags.Contains(groupSearch.Tags.ToLower()))
.Where(g => _dateComparer.DateNowIsNotBetweenHiddenRange(g.DateHiddenFrom, g.DateHiddenTo))
.Where(g => groupSearch.GetInvolved == string.Empty || (g.Volunteering && groupSearch.GetInvolved == "yes"))
.Where(g => groupSearch.Organisation == string.Empty ||
(g.Organisation != null && g.Organisation.Slug == groupSearch.Organisation))
.Where(g => !subCategoriesList.Any() ||
g.SubCategories.Any(c => subCategoriesList.Contains(c.Slug)))
.ToList();
groupsWithNoCoordinates = groupsWithNoCoordinates.OrderBy(g => g.Name).Distinct().ToList();
}
var groups =
entries.Select(g => _groupFactory.ToModel(g))
.Where(g => g.CategoriesReference.Any(c => string.IsNullOrEmpty(groupSearch.Category) || c.Slug.ToLower() == groupSearch.Category.ToLower()))
.Where(g => string.IsNullOrWhiteSpace(groupSearch.Tags) || g.Tags.Contains(groupSearch.Tags.ToLower()))
.Where(g => _dateComparer.DateNowIsNotBetweenHiddenRange(g.DateHiddenFrom, g.DateHiddenTo))
.Where(g => groupSearch.GetInvolved == string.Empty || (g.Volunteering && groupSearch.GetInvolved == "yes"))
.Where(g => groupSearch.Organisation == string.Empty || (g.Organisation != null && g.Organisation.Slug == groupSearch.Organisation))
.Where(g => !subCategoriesList.Any() || g.SubCategories.Any(c => subCategoriesList.Contains(c.Slug)))
.Where(_ => _.MapPosition.Lat != 0 && _.MapPosition.Lon != 0)
.ToList();
if (groupsWithNoCoordinates.Count > 0)
{
groups.AddRange(groupsWithNoCoordinates);
}
switch (!string.IsNullOrEmpty(groupSearch.Order) ? groupSearch.Order.ToLower() : "name a-z")
{
case "name a-z":
groups = groups.OrderBy(g => g.Name).ToList();
break;
case "name z-a":
groups = groups.OrderByDescending(g => g.Name).ToList();
break;
case "nearest":
break;
default:
groups = groups.OrderBy(g => g.Name).ToList();
break;
}
//if(!string.IsNullOrEmpty(category))
groupResults.Groups = groups;
groupResults.AvailableSubCategories = groups.SelectMany(g => g.SubCategories ?? new List <GroupSubCategory>()).ToList();
var groupCategoryResults = await GetGroupCategories();
if (!string.IsNullOrEmpty(groupSearch.Category) && groupCategoryResults.All(g => !string.Equals(g.Slug, groupSearch.Category, StringComparison.CurrentCultureIgnoreCase)))
{
return(HttpResponse.Failure(HttpStatusCode.NotFound, "No categories found"));
}
groupResults.Categories = groupCategoryResults;
return(HttpResponse.Successful(groupResults));
}
