public async Task <IActionResult> Create([FromBody, Required] DefaultChannel.DefaultChannelCreateData data)
{
int channelId = data.ChannelId;
Channel channel = await _context.Channels.FindAsync(channelId);
if (channel == null)
{
return(NotFound(new ApiError($"The channel with id '{channelId}' was not found.")));
}
var defaultChannel = new Data.Models.DefaultChannel
{
Channel = channel,
Repository = data.Repository,
Branch = data.Branch,
Enabled = data.Enabled ?? true
};
await _context.DefaultChannels.AddAsync(defaultChannel);
await _context.SaveChangesAsync();
return(CreatedAtRoute(
new
{
action = "Get",
id = defaultChannel.Id
},
new DefaultChannel(defaultChannel)));
}
public async Task <IActionResult> DeleteChannel(int id)
{
Data.Models.Channel channel = await _context.Channels
.Include(ch => ch.ChannelReleasePipelines)
.FirstOrDefaultAsync(c => c.Id == id);
if (channel == null)
{
return(NotFound());
}
// Ensure that there are no subscriptions associated with the channel
if (await _context.Subscriptions.AnyAsync(s => s.ChannelId == id))
{
return(BadRequest(
new ApiError($"The channel with id '{id}' has associated subscriptions. " +
"Please remove these before removing this channel.")));
}
if (channel.ChannelReleasePipelines != null && channel.ChannelReleasePipelines.Any())
{
return(BadRequest(
new ApiError($"The channel with id '{id}' has '{channel.ChannelReleasePipelines.Count()}' " +
$"release pipeline(s) attached to it. Detach those release pipelines(s) first.")));
}
_context.Channels.Remove(channel);
await _context.SaveChangesAsync();
return(Ok(new Channel(channel)));
}
public override async Task <IActionResult> UpdateSubscription(Guid id, [FromBody] v2018_07_16.Models.SubscriptionUpdate update)
{
Data.Models.Subscription subscription = await _context.Subscriptions.Where(sub => sub.Id == id)
.FirstOrDefaultAsync();
if (subscription == null)
{
return(NotFound());
}
var doUpdate = false;
if (!string.IsNullOrEmpty(update.SourceRepository))
{
subscription.SourceRepository = update.SourceRepository;
doUpdate = true;
}
if (update.Policy != null)
{
subscription.PolicyObject = update.Policy.ToDb();
doUpdate = true;
}
if (!string.IsNullOrEmpty(update.ChannelName))
{
Data.Models.Channel channel = await _context.Channels.Where(c => c.Name == update.ChannelName)
.FirstOrDefaultAsync();
if (channel == null)
{
return(BadRequest(
new ApiError(
"The request is invalid",
new[] { $"The channel '{update.ChannelName}' could not be found." })));
}
subscription.Channel = channel;
doUpdate = true;
}
if (update.Enabled.HasValue)
{
subscription.Enabled = update.Enabled.Value;
doUpdate = true;
}
if (doUpdate)
{
_context.Subscriptions.Update(subscription);
await _context.SaveChangesAsync();
}
return(Ok(new Subscription(subscription)));
}
public async Task <IActionResult> CreateChannel([Required] string name, [Required] string classification)
{
var channelModel = new Data.Models.Channel {
Name = name, Classification = classification
};
await _context.Channels.AddAsync(channelModel);
await _context.SaveChangesAsync();
return(CreatedAtRoute(new { action = "GetChannel", id = channelModel.Id }, new Channel(channelModel)));
}
public async Task <IActionResult> DeleteChannel(int id)
{
Data.Models.Channel channel = await _context.Channels.FirstOrDefaultAsync(c => c.Id == id);
if (channel == null)
{
return(NotFound());
}
_context.Channels.Remove(channel);
await _context.SaveChangesAsync();
return(Ok(new Channel(channel)));
}
public virtual async Task <IActionResult> Create([FromBody, Required] Goal.GoalRequestJson goalData, [Required] String channelName, [Required] int definitionId)
{
Data.Models.Channel channel = await _context.Channels
.FirstOrDefaultAsync(c => c.Name.Equals(channelName));
if (channel == null)
{
return(NotFound());
}
Data.Models.GoalTime goal = await _context.GoalTime
.FirstOrDefaultAsync(g => g.DefinitionId == definitionId && g.ChannelId == channel.Id);
if (goal == null)
{
goal = new Data.Models.GoalTime
{
DefinitionId = definitionId,
Minutes = goalData.Minutes,
ChannelId = channel.Id
};
await _context.GoalTime.AddAsync(goal);
}
else
{
goal.Minutes = goalData.Minutes;
_context.GoalTime.Update(goal);
}
await _context.SaveChangesAsync();
return(Ok(new Goal(goal)));
}
public async Task <IActionResult> Create([FromBody] SubscriptionData subscription)
{
Data.Models.Channel channel = await _context.Channels.Where(c => c.Name == subscription.ChannelName)
.FirstOrDefaultAsync();
if (channel == null)
{
return(BadRequest(
new ApiError(
"the request is invalid",
new[] { $"The channel '{subscription.ChannelName}' could not be found." })));
}
var subscriptionModel = new Data.Models.Subscription(subscription)
{
Channel = channel
};
await _context.Subscriptions.AddAsync(subscriptionModel);
await _context.SaveChangesAsync();
return(CreatedAtRoute(
new { action = "GetSubscription", id = subscriptionModel.Id },
new Subscription(subscriptionModel)));
}
private async Task UpdateUserAsync(ApplicationUser user,
BuildAssetRegistryContext dbContext,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
GitHubClaimResolver gitHubClaimResolver)
{
using (IDbContextTransaction txn = await dbContext.Database.BeginTransactionAsync())
{
string token = await userManager.GetAuthenticationTokenAsync(user, GitHubScheme, "access_token");
var newClaims = (await gitHubClaimResolver.GetUserInformationClaims(token)).Concat(
await gitHubClaimResolver.GetMembershipClaims(token)
).Where(AccountController.ShouldAddClaimToUser);
var currentClaims = (await userManager.GetClaimsAsync(user)).ToList();
// remove old claims
await userManager.RemoveClaimsAsync(user, currentClaims);
// add new claims
await userManager.AddClaimsAsync(user, newClaims);
user.LastUpdated = DateTimeOffset.UtcNow;
await dbContext.SaveChangesAsync();
txn.Commit();
}
}
private async Task UpdateUserAsync(
ApplicationUser user,
BuildAssetRegistryContext dbContext,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager)
{
using (IDbContextTransaction txn = await dbContext.Database.BeginTransactionAsync())
{
string token = await userManager.GetAuthenticationTokenAsync(user, GitHubScheme, "access_token");
var roles = new HashSet <string>(await GetGithubRolesAsync(token));
List <Claim> currentRoles = (await userManager.GetClaimsAsync(user))
.Where(c => c.Type == ClaimTypes.Role)
.ToList();
// remove claims where github doesn't have the role anymore
await userManager.RemoveClaimsAsync(user, currentRoles.Where(c => !roles.Contains(c.Value)));
// add new claims
await userManager.AddClaimsAsync(
user,
roles.Where(r => currentRoles.All(c => c.Value != r))
.Select(r => new Claim(ClaimTypes.Role, r, ClaimValueTypes.String, GitHubScheme)));
user.LastUpdated = DateTimeOffset.UtcNow;
await dbContext.SaveChangesAsync();
txn.Commit();
}
}
public async Task <IActionResult> Create([FromBody] BuildData build)
{
var buildModel = new Data.Models.Build(build)
{
DateProduced = DateTimeOffset.UtcNow,
Dependencies = await _context.Builds.Where(b => build.Dependencies.Contains(b.Id)).ToListAsync()
};
await _context.Builds.AddAsync(buildModel);
var defaultChannels = await _context.DefaultChannels
.Where(dc => dc.Repository == buildModel.Repository && dc.Branch == buildModel.Branch)
.Select(dc => dc.ChannelId)
.ToListAsync();
foreach (var channelId in defaultChannels)
{
await _context.BuildChannels.AddAsync(new Data.Models.BuildChannel
{
ChannelId = channelId,
Build = buildModel,
});
}
await _context.SaveChangesAsync();
return(CreatedAtRoute(new { action = "GetBuild", id = buildModel.Id }, new Build(buildModel)));
}
public async Task <IActionResult> Create([FromBody, Required] DefaultChannel.DefaultChannelCreateData data)
{
int channelId = data.ChannelId;
Channel channel = await _context.Channels.FindAsync(channelId);
if (channel == null)
{
return(NotFound(new ApiError($"The channel with id '{channelId}' was not found.")));
}
Data.Models.DefaultChannel defaultChannel;
// Due to abundant retry logic, we'll return a normal response even if this is creating a duplicate, by simply
// returning the one that already exists vs. HTTP 409 / 500
var existingInstance = _context.DefaultChannels
.Where(d => d.Channel == channel &&
d.Repository == data.Repository &&
d.Branch == data.Branch)
.FirstOrDefault();
if (existingInstance != null)
{
defaultChannel = existingInstance;
}
else
{
defaultChannel = new Data.Models.DefaultChannel
{
Channel = channel,
Repository = data.Repository,
Branch = data.Branch,
Enabled = data.Enabled ?? true
};
await _context.DefaultChannels.AddAsync(defaultChannel);
await _context.SaveChangesAsync();
}
return(CreatedAtRoute(
new
{
action = "Get",
id = defaultChannel.Id
},
new DefaultChannel(defaultChannel)));
}
public async Task <IActionResult> Create([FromBody] BuildData build)
{
Data.Models.Build buildModel = build.ToDb();
buildModel.DateProduced = DateTimeOffset.UtcNow;
buildModel.Dependencies = build.Dependencies != null ? await _context.Builds.Where(b => build.Dependencies.Contains(b.Id)).ToListAsync() : null;
await _context.Builds.AddAsync(buildModel);
await _context.SaveChangesAsync();
return(CreatedAtRoute(new { action = "GetBuild", id = buildModel.Id }, new Build(buildModel)));
}
public async Task <IActionResult> AddAssetLocationToAsset(int assetId, [Required] string location, [Required] LocationType assetLocationType)
{
var assetLocation = new Data.Models.AssetLocation
{
Location = location,
Type = (Maestro.Data.Models.LocationType)assetLocationType,
};
Maestro.Data.Models.Asset asset = await _context.Assets
.Include(a => a.Locations)
.Where(a => a.Id == assetId)
.SingleOrDefaultAsync();
if (asset == null)
{
return(NotFound(new ApiError($"The asset with id '{assetId}' was not found.")));
}
// If asset location is already in asset, nothing to do
if (asset.Locations != null &&
asset.Locations.Any(existing => existing.Location.Equals(assetLocation.Location, StringComparison.OrdinalIgnoreCase) &&
existing.Type == assetLocation.Type))
{
return(StatusCode((int)HttpStatusCode.NotModified));
}
asset.Locations = asset.Locations ?? new List <Data.Models.AssetLocation>();
asset.Locations.Add(assetLocation);
await _context.SaveChangesAsync();
return(CreatedAtRoute(
new
{
action = "GetAsset",
id = assetLocation.Id
},
new AssetLocation(assetLocation)));
}
public virtual async Task <IActionResult> DeletePipeline(int id)
{
bool isPipelineInUse = await _context.ChannelReleasePipelines.AnyAsync(crp => crp.ReleasePipelineId == id);
if (isPipelineInUse)
{
return(BadRequest(new ApiError($"The pipeline with id '{id}' is in use and cannot be deleted.")));
}
Data.Models.ReleasePipeline pipeline = await _context.ReleasePipelines
.FirstOrDefaultAsync(c => c.Id == id);
if (pipeline == null)
{
return(NotFound());
}
_context.ReleasePipelines.Remove(pipeline);
await _context.SaveChangesAsync();
return(Ok(new ReleasePipeline(pipeline)));
}
public async Task ProcessAsync(JToken argumentToken)
{
// This method is called asynchronously whenever a new build is inserted in BAR.
// It's goal is to compute the incoherent dependencies that the build have and
// persist the list of them in BAR.
int buildId = argumentToken.Value <int>();
DependencyGraphBuildOptions graphBuildOptions = new DependencyGraphBuildOptions()
{
IncludeToolset = false,
LookupBuilds = false,
NodeDiff = NodeDiff.None
};
try
{
Data.Models.Build build = await _context.Builds.FindAsync(buildId);
DependencyGraph graph = await DependencyGraph.BuildRemoteDependencyGraphAsync(
_remoteFactory,
build.GitHubRepository ?? build.AzureDevOpsRepository,
build.Commit,
graphBuildOptions,
_logger);
var incoherencies = new List <Data.Models.BuildIncoherence>();
foreach (var incoherence in graph.IncoherentDependencies)
{
incoherencies.Add(new Data.Models.BuildIncoherence
{
Name = incoherence.Name,
Version = incoherence.Version,
Repository = incoherence.RepoUri,
Commit = incoherence.Commit
});
}
_context.Entry(build).Reload();
build.Incoherencies = incoherencies;
_context.Builds.Update(build);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogWarning(e, $"Problems computing the dependency incoherencies for BAR build {buildId}");
}
}
public virtual async Task <IActionResult> DeleteChannel(int id)
{
Data.Models.Channel channel = await _context.Channels
.FirstOrDefaultAsync(c => c.Id == id);
if (channel == null)
{
return(NotFound());
}
// Ensure that there are no subscriptions associated with the channel
if (await _context.Subscriptions.AnyAsync(s => s.ChannelId == id))
{
return(BadRequest(
new ApiError($"The channel with id '{id}' has associated subscriptions. " +
"Please remove these before removing this channel.")));
}
_context.Channels.Remove(channel);
await _context.SaveChangesAsync();
return(Ok(new Channel(channel)));
}
/// <summary>
/// This method is called asynchronously whenever a new build is inserted in BAR.
/// It's goal is to compute the incoherent dependencies that the build have and
/// persist the list of them in BAR.
/// </summary>
/// <param name="buildId">Build id for which the incoherencies should be computed.</param>
private async Task SetBuildIncoherencyInfoAsync(int buildId)
{
DependencyGraphBuildOptions graphBuildOptions = new DependencyGraphBuildOptions()
{
IncludeToolset = false,
LookupBuilds = false,
NodeDiff = NodeDiff.None
};
try
{
using (IServiceScope scope = ServiceScopeFactory.CreateScope())
{
BuildAssetRegistryContext context = scope.ServiceProvider.GetRequiredService <BuildAssetRegistryContext>();
Data.Models.Build build = await context.Builds.FindAsync(buildId);
DependencyGraph graph = await DependencyGraph.BuildRemoteDependencyGraphAsync(
RemoteFactory,
build.GitHubRepository ?? build.AzureDevOpsRepository,
build.Commit,
graphBuildOptions,
Logger);
var incoherencies = new List <Data.Models.BuildIncoherence>();
foreach (var incoherence in graph.IncoherentDependencies)
{
build.Incoherencies.Add(new Data.Models.BuildIncoherence
{
Name = incoherence.Name,
Version = incoherence.Version,
Repository = incoherence.RepoUri,
Commit = incoherence.Commit
});
}
context.Entry <Data.Models.Build>(build).Reload();
build.Incoherencies = incoherencies;
context.Builds.Update(build);
await context.SaveChangesAsync();
}
}
catch (Exception e)
{
Logger.LogWarning(e, $"Problems computing the dependency incoherencies for BAR build {buildId}");
}
}
public virtual async Task <IActionResult> Create([FromBody] BuildData build)
{
Data.Models.Build buildModel = build.ToDb();
buildModel.DateProduced = DateTimeOffset.UtcNow;
if (build.Dependencies?.Count > 0)
{
return(BadRequest("This api version doesn't support build dependencies."));
}
await _context.Builds.AddAsync(buildModel);
await _context.SaveChangesAsync();
return(CreatedAtRoute(
new
{
action = "GetBuild",
id = buildModel.Id
},
new Models.Build(buildModel)));
}
public async Task <IActionResult> UpdateSubscription(Guid id, [FromBody] SubscriptionUpdate update)
{
Data.Models.Subscription subscription = await _context.Subscriptions.Where(sub => sub.Id == id).Include(sub => sub.Channel)
.FirstOrDefaultAsync();
if (subscription == null)
{
return(NotFound());
}
var doUpdate = false;
if (!string.IsNullOrEmpty(update.SourceRepository))
{
subscription.SourceRepository = update.SourceRepository;
doUpdate = true;
}
if (update.Policy != null)
{
subscription.PolicyObject = update.Policy.ToDb();
doUpdate = true;
}
if (update.PullRequestFailureNotificationTags != null)
{
if (!await AllNotificationTagsValid(update.PullRequestFailureNotificationTags))
{
return(BadRequest(new ApiError("Invalid value(s) provided in Pull Request Failure Notification Tags; is everyone listed publicly a member of the Microsoft github org?")));
}
subscription.PullRequestFailureNotificationTags = update.PullRequestFailureNotificationTags;
doUpdate = true;
}
if (!string.IsNullOrEmpty(update.ChannelName))
{
Data.Models.Channel channel = await _context.Channels.Where(c => c.Name == update.ChannelName)
.FirstOrDefaultAsync();
if (channel == null)
{
return(BadRequest(
new ApiError(
"The request is invalid",
new[] { $"The channel '{update.ChannelName}' could not be found." })));
}
subscription.Channel = channel;
doUpdate = true;
}
if (update.Enabled.HasValue)
{
subscription.Enabled = update.Enabled.Value;
doUpdate = true;
}
if (doUpdate)
{
Data.Models.Subscription equivalentSubscription = await FindEquivalentSubscription(subscription);
if (equivalentSubscription != null)
{
return(Conflict(
new ApiError(
"the request is invalid",
new[]
{
$"The subscription '{equivalentSubscription.Id}' already performs the same update."
})));
}
_context.Subscriptions.Update(subscription);
await _context.SaveChangesAsync();
}
return(Ok(new Subscription(subscription)));
}