private static TeamFoundation.Build.Client.IBuildDetailSpec CreateBuildDetailSpec(TeamFoundation.Build.Client.IBuildServer buildServer, string projectName, FilterNode rootFilterNode)
{
var detailSpec = default(TeamFoundation.Build.Client.IBuildDetailSpec);
if (rootFilterNode != null)
{
var definitionSpec = buildServer.CreateBuildDefinitionSpec(projectName);
var definition = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Definition", StringComparison.OrdinalIgnoreCase));
var number = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Number", StringComparison.OrdinalIgnoreCase));
var quality = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Quality", StringComparison.OrdinalIgnoreCase));
var reason = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Reason", StringComparison.OrdinalIgnoreCase));
var status = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Status", StringComparison.OrdinalIgnoreCase));
var requestedFor = rootFilterNode.SingleOrDefault(p => p.Key.Equals("RequestedFor", StringComparison.OrdinalIgnoreCase));
if (definition != null)
{
if (definition.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Definition can only be filtered with an equality operator", "en-US", null);
}
definitionSpec.Name = definition.Value;
}
detailSpec = buildServer.CreateBuildDetailSpec(definitionSpec);
if (number != null)
{
if (number.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Number can only be filtered with an equality operator", "en-US", null);
}
detailSpec.BuildNumber = number.Value;
}
if (quality != null)
{
if (quality.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Quality can only be filtered with an equality operator", "en-US", null);
}
detailSpec.Quality = quality.Value;
}
if (requestedFor != null)
{
if (requestedFor.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Requested For can only be filtered with an equality operator", "en-US", null);
}
detailSpec.RequestedFor = requestedFor.Value;
}
if (status != null)
{
if (status.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Status can only be filtered with an equality operator", "en-US", null);
}
var statusValue = default(TeamFoundation.Build.Client.BuildStatus);
if (Enum.TryParse<TeamFoundation.Build.Client.BuildStatus>(status.Value, out statusValue))
{
detailSpec.Status = statusValue;
}
}
if (reason != null)
{
if (reason.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Reason can only be filtered with an equality operator", "en-US", null);
}
var reasonValue = default(TeamFoundation.Build.Client.BuildReason);
if (Enum.TryParse<TeamFoundation.Build.Client.BuildReason>(reason.Value, out reasonValue))
{
detailSpec.Reason = reasonValue;
}
}
return detailSpec;
}
else
{
detailSpec = buildServer.CreateBuildDetailSpec(projectName);
}
return detailSpec;
}
private static IEnumerable<Build> FilterBuilds(IEnumerable<Build> builds, FilterNode rootFilterNode)
{
if (rootFilterNode != null)
{
var startTimeParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("StartTime"));
var finishTimeParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("FinishTime"));
var buildFinishedParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("BuildFinished"));
var requestedByParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("RequestedBy"));
var startTimeValue = default(DateTime);
if (startTimeParameter != null && DateTime.TryParse(startTimeParameter.Value, out startTimeValue))
{
switch (startTimeParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.StartTime.Equals(startTimeValue));
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => !b.StartTime.Equals(startTimeValue));
break;
case FilterExpressionType.GreaterThan:
builds = builds.Where(b => b.StartTime > startTimeValue);
break;
case FilterExpressionType.LessThan:
builds = builds.Where(b => b.StartTime < startTimeValue);
break;
default:
throw new NotSupportedException("Start time field can only be filtered with equality, inequality, greater than and less than operators");
}
}
var finishTimeValue = default(DateTime);
if (finishTimeParameter != null && DateTime.TryParse(finishTimeParameter.Value, out finishTimeValue))
{
switch (finishTimeParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.FinishTime.Equals(finishTimeValue));
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => !b.FinishTime.Equals(finishTimeValue));
break;
case FilterExpressionType.GreaterThan:
builds = builds.Where(b => b.FinishTime > finishTimeValue);
break;
case FilterExpressionType.LessThan:
builds = builds.Where(b => b.FinishTime < finishTimeValue);
break;
default:
throw new NotSupportedException("Finish time field can only be filtered with equality, inequality, greater than and less than operators");
}
}
var buildFinishedValue = default(bool);
if (buildFinishedParameter != null && bool.TryParse(buildFinishedParameter.Value, out buildFinishedValue))
{
switch (buildFinishedParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.BuildFinished == buildFinishedValue);
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => b.BuildFinished != buildFinishedValue);
break;
default:
throw new NotSupportedException("Build Finished field can only be filtered with equality and inequality operators");
}
}
if (requestedByParameter != null)
{
switch (requestedByParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.RequestedBy.Equals(requestedByParameter.Value));
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => !b.RequestedBy.Equals(requestedByParameter.Value));
break;
default:
throw new NotSupportedException("Requested By field can only be filtered with equality and inequality operators");
}
}
}
return builds;
}
private IEnumerable<Build> RequestBuildsByProjectCollection(FilterNode rootFilterNode)
{
var teamProjects = this.TfsConnection.CatalogNode.QueryChildren(
new Guid[] { CatalogResourceTypes.TeamProject },
false,
CatalogQueryOptions.None);
IEnumerable<Build> preliminaryResults = null;
var buildServer = this.TfsConnection.GetService<TeamFoundation.Build.Client.IBuildServer>();
if (rootFilterNode != null && rootFilterNode.Count(p => p.Key.Equals("Project", StringComparison.OrdinalIgnoreCase)) > 0)
{
var projectParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Project", StringComparison.OrdinalIgnoreCase));
var spec = CreateBuildDetailSpec(buildServer, projectParameter.Value, rootFilterNode);
preliminaryResults = buildServer.QueryBuilds(spec).Builds.Select(b => b.ToModel());
}
else
{
var specs = teamProjects.Select(t => CreateBuildDetailSpec(buildServer, t.Resource.DisplayName, rootFilterNode));
preliminaryResults = specs.Select(s => buildServer.QueryBuilds(s)).SelectMany(r => r.Builds).Select(b => b.ToModel());
}
return FilterBuilds(preliminaryResults, rootFilterNode).ToArray();
}
private static string GetRequestedPath(string branch, string projectName, FilterNode rootFilterNode)
{
var path = "$/";
var branchParameter = default(FilterNode);
if (rootFilterNode != null)
{
branchParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Branch", StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(branch))
{
var branchName = EntityTranslator.DecodePath(branch);
path = string.Format(CultureInfo.InvariantCulture, branchName.StartsWith("$/", StringComparison.Ordinal) ? "{0}/*" : "$/{0}/*", branchName);
}
else if (branchParameter != null && !string.IsNullOrEmpty(branchParameter.Value))
{
if (branchParameter.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Changeset Branch can only be filtered with an equality operator", "en-US", null);
}
var branchName = EntityTranslator.DecodePath(branchParameter.Value);
path = string.Format(CultureInfo.InvariantCulture, branchName.StartsWith("$/", StringComparison.Ordinal) ? "{0}/*" : "$/{0}/*", branchName);
}
else if (!string.IsNullOrEmpty(projectName))
{
path = string.Format(CultureInfo.InvariantCulture, "$/{0}", projectName);
}
return path;
}
private static TeamFoundation.VersionControl.Client.VersionSpec GetRequestedVersionTo(FilterNode rootFilterNode)
{
if (rootFilterNode != null)
{
if (rootFilterNode.SingleOrDefault(p => p.Key.Equals("Id", StringComparison.OrdinalIgnoreCase)) != null)
{
return GetRequestedIdVersionTo(rootFilterNode);
}
else if (rootFilterNode.SingleOrDefault(p => p.Key.Equals("CreationDate", StringComparison.OrdinalIgnoreCase)) != null)
{
return GetRequestedDateVersionTo(rootFilterNode);
}
}
return null;
}
private static TeamFoundation.VersionControl.Client.VersionSpec GetRequestedIdVersionTo(FilterNode rootFilterNode)
{
var versionTo = default(TeamFoundation.VersionControl.Client.ChangesetVersionSpec);
if (rootFilterNode != null)
{
var idParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Id", StringComparison.OrdinalIgnoreCase));
if (idParameter != null)
{
switch (idParameter.Sign)
{
case FilterExpressionType.Equal:
case FilterExpressionType.LessThanOrEqual:
versionTo = new TeamFoundation.VersionControl.Client.ChangesetVersionSpec(idParameter.Value);
break;
case FilterExpressionType.LessThan:
int versionValue;
if (int.TryParse(idParameter.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out versionValue))
{
versionTo = new TeamFoundation.VersionControl.Client.ChangesetVersionSpec(versionValue - 1);
}
break;
case FilterExpressionType.GreaterThan:
case FilterExpressionType.GreaterThanOrEqual:
versionTo = null;
break;
default:
throw new DataServiceException(501, "Not Implemented", "Changeset Id can only be filtered with an equality, greater than, less than, greater than or equal and less than or equal operators", "en-US", null);
}
}
}
return versionTo;
}
private static TeamFoundation.VersionControl.Client.VersionSpec GetRequestedDateVersionTo(FilterNode rootFilterNode)
{
var versionTo = default(TeamFoundation.VersionControl.Client.DateVersionSpec);
if (rootFilterNode != null)
{
var dateParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("CreationDate", StringComparison.OrdinalIgnoreCase));
var dateTo = default(DateTime);
if (dateParameter != null && DateTime.TryParse(dateParameter.Value, out dateTo))
{
switch (dateParameter.Sign)
{
case FilterExpressionType.Equal:
case FilterExpressionType.LessThan:
case FilterExpressionType.LessThanOrEqual:
versionTo = new TeamFoundation.VersionControl.Client.DateVersionSpec(dateTo.AddSeconds(1));
break;
case FilterExpressionType.GreaterThan:
case FilterExpressionType.GreaterThanOrEqual:
versionTo = null;
break;
default:
throw new DataServiceException(501, "Not Implemented", "Changeset Creation Date can only be filtered with an equality, greater than, less than, greater than or equal and less than or equal operators", "en-US", null);
}
}
}
return versionTo;
}
private static string GetRequestedCommitter(FilterNode rootFilterNode)
{
var committer = default(string);
if (rootFilterNode != null)
{
var committerParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Committer", StringComparison.OrdinalIgnoreCase));
if (committerParameter != null)
{
if (committerParameter.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Changeset committer can only be filtered with an equality operator", "en-US", null);
}
committer = committerParameter.Value;
}
}
return committer;
}
private static IEnumerable<Changeset> FilterChangesetsByOwner(IEnumerable<Changeset> changesets, FilterNode rootFilterNode)
{
if (rootFilterNode.Count(p => p.Key.Equals("Owner")) > 0)
{
var ownerParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Owner"));
switch (ownerParameter.Sign)
{
case FilterExpressionType.Equal:
changesets = ownerParameter != null
? changesets.Where(c => c.Owner != null && c.Owner.Equals(ownerParameter.Value, StringComparison.OrdinalIgnoreCase))
: changesets.Where(c => c.Owner == null);
break;
case FilterExpressionType.NotEqual:
changesets = ownerParameter != null
? changesets.Where(c => c.Owner == null || !c.Owner.Equals(ownerParameter.Value, StringComparison.OrdinalIgnoreCase))
: changesets.Where(c => c.Owner != null);
break;
default:
throw new NotSupportedException("Changeset Owner can only be filtered with an equal or not equal operator");
}
}
return changesets;
}
private static IEnumerable<Changeset> FilterChangesetsByCreationDate(IEnumerable<Changeset> changesets, FilterNode rootFilterNode)
{
if (rootFilterNode.Count(p => p.Key.Equals("CreationDate")) > 0 && rootFilterNode.Count(p => p.Key.Equals("Id")) > 0)
{
// We could not filter by both parameters using the API. So we filter programmatically
var dateParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("CreationDate"));
var dateValue = default(DateTime);
if (DateTime.TryParse(dateParameter.Value, out dateValue))
{
switch (dateParameter.Sign)
{
case FilterExpressionType.Equal:
changesets = dateParameter != null
? changesets.Where(c => c.CreationDate != null && RoundDateToSeconds(c.CreationDate).Equals(dateValue))
: changesets.Where(c => c.CreationDate == null);
break;
case FilterExpressionType.GreaterThan:
changesets = dateParameter != null
? changesets.Where(c => c.CreationDate != null && RoundDateToSeconds(c.CreationDate) > dateValue)
: changesets.Where(c => c.CreationDate != null);
break;
case FilterExpressionType.GreaterThanOrEqual:
changesets = dateParameter != null
? changesets.Where(c => c.CreationDate != null && RoundDateToSeconds(c.CreationDate) >= dateValue)
: changesets.Where(c => c.CreationDate != null);
break;
case FilterExpressionType.LessThan:
changesets = dateParameter != null
? changesets.Where(c => c.CreationDate != null && RoundDateToSeconds(c.CreationDate) < dateValue)
: changesets.Where(c => c.CreationDate != null);
break;
case FilterExpressionType.LessThanOrEqual:
changesets = dateParameter != null
? changesets.Where(c => c.CreationDate != null && RoundDateToSeconds(c.CreationDate) <= dateValue)
: changesets.Where(c => c.CreationDate != null);
break;
default:
throw new DataServiceException(501, "Not Implemented", "Changeset Creation Date can only be filtered with an equality, greater than, less than, greater than or equal and less than or equal operators", "en-US", null);
}
}
}
return changesets;
}
