public List <IssueDTO> GetIssues(IssueFilter filter)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
return(CreateQuery(filter).Execute().ToList());
}
}
/// <summary>
/// A collection of Issues Identified in the Retrospective
/// </summary>
public ICollection <Issue> GetIssues(IssueFilter filter)
{
filter = filter ?? new IssueFilter();
filter.Retrospective.Clear();
filter.Retrospective.Add(this);
return(Instance.Get.Issues(filter));
}
[Test] public void RankOrder()
{
IssueFilter filter = new IssueFilter();
filter.OrderBy.Add("RankOrder");
Assert.Less(-1, Instance.Get.Issues(filter).Count);
}
/// <summary>
/// A read-only collection of Issues owned by this member.
/// </summary>
public ICollection <Issue> GetOwnedIssues(IssueFilter filter)
{
filter = filter ?? new IssueFilter();
filter.Owner.Clear();
filter.Owner.Add(this);
return(Instance.Get.Issues(filter));
}
protected IQuery <IssueDTO> CreateQuery(IssueFilter filter = null)
{
var query = IssueListQuery;
query.Filter = filter;
return(query);
}
public IssueFilter GetFilter(String filtername)
{
IssueFilter filter = GetFilters().Where(f => f.Name.Equals(filtername)).FirstOrDefault();
if (filter == null)
{
throw new Exception(String.Format("The filter with name {0} does not exist", filtername));
}
return filter;
}
public ActionResult Index()
{
DynamicResponse <SelectLO> options = new DynamicResponse <SelectLO>();
options = _HomeServices.GetOption();
ViewBag.options = options.Data;
Hero_Banner banner = _ContentServices.GetContent <Hero_Banner>(ContentServices.ServiceTables.Hero_Banner, 1).Contents.FirstOrDefault();
ViewBag.Banner = banner;
DynamicResponse <List <SubmissionLO> > response = _HomeServices.GetSubmissionLatestArticles(3);
if (response.HttpStatusCode != HttpStatusCode.OK)
{
return(RedirectToAction("Index", "Oops"));
}
ViewBag.latestarticles = response.Data;
DynamicResponse <IssueLO> latestissues = _HomeServices.GetLatestIssues();
if (latestissues.HttpStatusCode != HttpStatusCode.OK)
{
return(RedirectToAction("Index", "Oops"));
}
ViewBag.latestIssues = latestissues.Data;
DynamicResponse <List <IssueLO> > allissues = _HomeServices.GetAllIssues();
if (allissues.HttpStatusCode != HttpStatusCode.OK)
{
return(RedirectToAction("Index", "Oops"));
}
ViewBag.allissues = allissues.Data.OrderByDescending(e => e.Date).ToList();;
IssueFilter issuefilter = new IssueFilter();
issuefilter = _ContentServices.GetContent <IssueFilter>(ContentServices.ServiceTables.IssueFilter, 1).Contents.FirstOrDefault();
ViewBag.issuefilter = issuefilter;
List <Events> ourevents = _ContentServices.GetContent <Events>(ContentServices.ServiceTables.Events, 3).Contents.ToList();
ourevents = ourevents.OrderBy(e => DateTime.Parse(e.EventDate)).ToList();
ViewBag.Events = ourevents;
List <Videos> ourvideos = _ContentServices.GetContent <Videos>(ContentServices.ServiceTables.Videos, 4).Contents.ToList();
ourvideos = ourvideos.OrderBy(e => DateTime.ParseExact(e.VideoDate, "dd-MM-yyyy", CultureInfo.InvariantCulture)).ToList();
ViewBag.Videos = ourvideos;
DynamicResponse <List <SubmissionLO> > submission = _HomeServices.GetAllArticles();
if (submission.HttpStatusCode != HttpStatusCode.OK)
{
return(RedirectToAction("Index", "Oops"));
}
ViewBag.articles = submission.Data;
return(View(options));
}
public static Task <IssueSummaries> GetSummariesAsync(IssueFilter filter)
{
return(Task.Run(() => {
var issues = (IEnumerable <Issue>)AllIssues.Value;
if (filter != null)
{
issues = FilterIssues(filter, issues);
}
var lastCreated = issues.Any() ? issues.Max(x => x.Created) : default(DateTime?);
return new IssueSummaries {
Count = issues.Count(), LastCreated = lastCreated
};
}));
}
[Test] public void Owner()
{
Issue issue = SandboxProject.CreateIssue("Issue Owned By Andre");
Assert.IsNull(issue.Owner);
Member andre = Instance.Get.MemberByID("Member:1000");
issue.Owner = andre;
issue.Save();
IssueFilter filter = new IssueFilter();
filter.Owner.Add(andre);
filter.Project.Add(SandboxProject);
Assert.AreEqual(1, Instance.Get.Issues(filter).Count);
}
public async Task NoRepo_PassesRelation(IssueRelation relation, IssueFilter filter)
{
// Arrange
_discoveryService.Setup(service => service.DiscoverInCurrentDirectory())
.Returns(() => null);
ListIssuesCommand command = new ListIssuesCommand(_gitHubClient.Object, _discoveryService.Object, _reporter.Object);
command.Relation = relation;
// Act
await command.OnExecuteAsync(NullConsole.Singleton);
// Assert
_issuesClient.Verify(client => client.GetAllForCurrent(It.Is <IssueRequest>(request => request.Filter == filter)), Times.Once());
}
private Collection <Issue> StubCollection(IssueFilter filter)
{
var random = new Random();
var members = Enumerable.Range(1, 10).Select(i => new Issue
{
Title = $"{filter.Title} issue #{i}",
DateCreated = new DateTime(filter.Year ?? random.Next(2000, DateTime.Now.Year), random.Next(1, 12), random.Next(1, 29)),
ProjectId = (IriRef)"/ęś"
});
return(new IssueCollection
{
Id = Request.Url,
Members = members.ToArray(),
TotalItems = 10,
Search = this.templateFactory.CreateIriTemplate <IssueFilter, Issue>()
});
}
static IEnumerable <Issue> FilterIssues(IssueFilter filter, IEnumerable <Issue> issues)
{
if (filter.CreatedFrom != null || filter.CreatedTo != null)
{
if (filter.CreatedFrom == null || filter.CreatedTo == null)
{
throw new InvalidOperationException();
}
issues = issues.Where(x => x.Created >= filter.CreatedFrom.Value && x.Created < filter.CreatedTo);
}
if (filter.MinVotes != null)
{
issues = issues.Where(x => x.Votes >= filter.MinVotes.Value);
}
if (filter.Priority != null)
{
issues = issues.Where(x => x.Priority == filter.Priority);
}
return(issues);
}
void TestPriority(Issue expected, Issue not, string expectedPriority)
{
IssueFilter filter = new IssueFilter();
filter.Project.Add(SandboxProject);
filter.Priority.Add(expectedPriority);
ResetInstance();
expected = Instance.Get.IssueByID(expected.ID);
not = Instance.Get.IssueByID(not.ID);
ICollection <Issue> results = SandboxProject.GetIssues(filter);
Assert.IsTrue(FindRelated(expected, results), "Expected to find Issue that matched filter.");
Assert.IsFalse(FindRelated(not, results), "Expected to NOT find Issue that doesn't match filter.");
foreach (Issue result in results)
{
Assert.AreEqual(expectedPriority, result.Priority.CurrentValue);
}
}
public static Task <Issue[]> GetIssuesAsync(int skip, int take, IssueSortOrder sortOrder, IssueFilter filter)
{
return(Task.Run(() => {
var issues = SortIssues(sortOrder, AllIssues.Value);
if (filter != null)
{
issues = FilterIssues(filter, issues);
}
return issues.Skip(skip).Take(take).Select(x => x.Clone()).ToArray();
}));
}
public async Task <IssuesResponse> GetIssues(IssueFilter filter, IssueSort sort)
{
return(await GetMany <IssuesResponse, IssueSort, IssueFilter>("issues", sort, filter));
}
/// <summary>
/// Get Issues in this Project filtered as specified in the passed in filter.
/// </summary>
/// <param name="filter">Criteria to filter on. Project will be set automatically. If null, all Issues in the project are returned.</param>
/// <param name="includeSubprojects">Specifies whether to include items from sub project or not. This only adds open subprojects.</param>
/// <returns>A readonly ICollection of Issues</returns>
public ICollection <Issue> GetIssues(IssueFilter filter, bool includeSubprojects)
{
return(Instance.Get.Issues(WithThisProjectIncludedIn(filter, includeSubprojects)));
}
/// <summary>
/// Get Issues in this Project filtered as specified in the passed in filter. Does not include subprojects.
/// </summary>
/// <param name="filter">Criteria to filter on. Project will be set automatically. If null, all Issues in the project are returned.</param>
/// <returns>A readonly ICollection of Issues</returns>
public ICollection <Issue> GetIssues(IssueFilter filter)
{
return(GetIssues(filter, false));
}
public override async Task <IssueSummaries> GetSummaries(IssueFilter request, ServerCallContext context)
{
return(await IssuesDataProvider.GetSummariesAsync(request));
}
private void ButtonIssuesAssigned_Click(object sender, EventArgs e)
{
if (this.SelectedFilter == IssueFilter.AssignedToCurrentUser) return;
this.SelectedFilter = IssueFilter.AssignedToCurrentUser;
this.RefreshIssues();
}
/// <summary>
/// Get Issues filtered by the criteria specified in the passed in filter.
/// </summary>
/// <param name="filter">Limit the items returned. If null, then all items returned.</param>
/// <returns>ICollection of items as specified in the filter.</returns>
public ICollection <Issue> Issues(IssueFilter filter)
{
return(Get <Issue>(filter ?? new IssueFilter()));
}
public IWithIssueOptions FilteredBy(IssueFilter issueFilter)
{
repositoryIssueRequest.Filter = issueFilter;
return(this);
}
public static void RequestIssues(System.Action <List <IssueEntry> > receivedCallback, IssueFilter filter)
{
_issueRequestState = IssueRequestState.Requesting;
backend.RequestIssues(entries =>
{
_issueRequestState = IssueRequestState.Completed;
if (receivedCallback != null)
{
receivedCallback(entries);
}
},
filter
);
}
private static HashSet <CrawledIssue> Execute(CrawledIndex index, IssueFilter filter)
{
var result = (HashSet <CrawledIssue>)null;
foreach (var term in filter.IncludedTerms)
{
ApplyTerm(ref result, index.Trie, term);
}
foreach (var org in filter.IncludedOrgs)
{
ApplyTerm(ref result, index.Trie, $"org:{org}");
}
foreach (var repo in filter.IncludedRepos)
{
ApplyTerm(ref result, index.Trie, $"repo:{repo}");
}
foreach (var assignee in filter.IncludedAssignees)
{
ApplyTerm(ref result, index.Trie, $"assignee:{assignee}");
}
foreach (var label in filter.IncludedLabels)
{
ApplyTerm(ref result, index.Trie, $"label:{label}");
}
foreach (var area in filter.IncludedAreas)
{
ApplyTerm(ref result, index.Trie, $"area-under:{area}");
}
foreach (var areaNode in filter.IncludedAreaNodes)
{
ApplyTerm(ref result, index.Trie, $"area-node:{areaNode}");
}
foreach (var areaLead in filter.IncludedAreaLeads)
{
ApplyTerm(ref result, index.Trie, $"area-lead:{areaLead}");
}
foreach (var areaOwner in filter.IncludedAreaOwners)
{
ApplyTerm(ref result, index.Trie, $"area-owner:{areaOwner}");
}
if (filter.Author != null)
{
ApplyTerm(ref result, index.Trie, $"author:{filter.Author}");
}
if (filter.Milestone != null)
{
ApplyTerm(ref result, index.Trie, $"milestone:{filter.Milestone}");
}
if (filter.IsOpen == true)
{
ApplyPredicate(ref result, index, i => i.IsOpen);
}
else if (filter.IsOpen == false)
{
ApplyPredicate(ref result, index, i => !i.IsOpen);
}
if (filter.IsLocked == true)
{
ApplyPredicate(ref result, index, i => i.IsLocked);
}
else if (filter.IsLocked == false)
{
ApplyPredicate(ref result, index, i => !i.IsLocked);
}
if (filter.IsPullRequest == true)
{
ApplyPredicate(ref result, index, i => i.IsPullRequest);
}
else if (filter.IsPullRequest == false)
{
ApplyPredicate(ref result, index, i => !i.IsPullRequest);
}
if (filter.IsMerged == true)
{
ApplyPredicate(ref result, index, i => i.IsMerged);
}
else if (filter.IsMerged == false)
{
ApplyPredicate(ref result, index, i => i.IsPullRequest && !i.IsMerged);
}
if (filter.IsDraft == true)
{
ApplyPredicate(ref result, index, i => i.IsDraft);
}
else if (filter.IsDraft == false)
{
ApplyPredicate(ref result, index, i => i.IsPullRequest && !i.IsDraft);
}
if (filter.IsArchived == true)
{
ApplyPredicate(ref result, index, i => i.Repo.IsArchived);
}
else if (filter.IsArchived == false)
{
ApplyPredicate(ref result, index, i => !i.Repo.IsArchived);
}
if (filter.NoAssignees == true)
{
ApplyPredicate(ref result, index, i => i.Assignees.Length == 0);
}
else if (filter.NoAssignees == false)
{
ApplyPredicate(ref result, index, i => i.Assignees.Length > 0);
}
if (filter.NoLabels == true)
{
ApplyPredicate(ref result, index, i => i.Labels.Length == 0);
}
else if (filter.NoLabels == false)
{
ApplyPredicate(ref result, index, i => i.Labels.Length > 0);
}
if (filter.NoArea == true)
{
ApplyPredicate(ref result, index, i => !i.Areas.Any());
}
else if (filter.NoArea == false)
{
ApplyPredicate(ref result, index, i => i.Areas.Any());
}
if (filter.NoAreaLead == true)
{
ApplyPredicate(ref result, index, i => !i.AreaLeads.Any());
}
else if (filter.NoAreaLead == false)
{
ApplyPredicate(ref result, index, i => i.AreaLeads.Any());
}
if (filter.NoAreaOwner == true)
{
ApplyPredicate(ref result, index, i => !i.AreaOwners.Any());
}
else if (filter.NoAreaOwner == false)
{
ApplyPredicate(ref result, index, i => i.AreaOwners.Any());
}
if (filter.NoMilestone == true)
{
ApplyPredicate(ref result, index, i => i.Milestone is null);
}
else if (filter.NoMilestone == false)
{
ApplyPredicate(ref result, index, i => i.Milestone is not null);
}
if (filter.Created is not null)
{
ApplyPredicate(ref result, index, i => filter.Created.Contains(i.CreatedAt));
}
if (filter.Updated is not null)
{
ApplyPredicate(ref result, index, i => i.UpdatedAt != null && filter.Updated.Contains(i.UpdatedAt.Value));
}
if (filter.Closed is not null)
{
ApplyPredicate(ref result, index, i => i.ClosedAt != null && filter.Closed.Contains(i.ClosedAt.Value));
}
if (filter.Comments is not null)
{
ApplyPredicate(ref result, index, i => filter.Comments.Contains(i.Comments));
}
if (filter.Reactions is not null)
{
ApplyPredicate(ref result, index, i => filter.Reactions.Contains(i.Reactions));
}
if (filter.Interactions is not null)
{
ApplyPredicate(ref result, index, i => filter.Interactions.Contains(i.Interactions));
}
foreach (var org in filter.ExcludedOrgs)
{
ApplyNegatedTerm(ref result, index, $"org:{org}");
}
foreach (var repo in filter.ExcludedRepos)
{
ApplyNegatedTerm(ref result, index, $"repo:{repo}");
}
foreach (var term in filter.ExcludedTerms)
{
ApplyNegatedTerm(ref result, index, term);
}
foreach (var assignee in filter.ExcludedAssignees)
{
ApplyNegatedTerm(ref result, index, $"assignee:{assignee}");
}
foreach (var author in filter.ExcludedAuthors)
{
ApplyNegatedTerm(ref result, index, $"author:{author}");
}
foreach (var label in filter.ExcludedLabels)
{
ApplyNegatedTerm(ref result, index, $"label:{label}");
}
foreach (var area in filter.ExcludedAreas)
{
ApplyNegatedTerm(ref result, index, $"area-under:{area}");
}
foreach (var areaNode in filter.ExcludedAreaNodes)
{
ApplyNegatedTerm(ref result, index, $"area-node:{areaNode}");
}
foreach (var areaLead in filter.ExcludedAreaLeads)
{
ApplyNegatedTerm(ref result, index, $"area-lead:{areaLead}");
}
foreach (var areaOwner in filter.ExcludedAreaOwners)
{
ApplyNegatedTerm(ref result, index, $"area-owner:{areaOwner}");
}
foreach (var milestone in filter.ExcludedMilestones)
{
ApplyNegatedTerm(ref result, index, $"milestone:{milestone}");
}
return(result ?? new HashSet <CrawledIssue>());
private void ButtonIssuesEventone_Click(object sender, EventArgs e)
{
if (this.SelectedFilter == IssueFilter.All) return;
this.SelectedFilter = IssueFilter.All;
this.RefreshIssues();
}
