private void ValueUpdate(SubscriptionUpdate update)
{
Device.BeginInvokeOnMainThread(() =>
{
_valueLabel.Text = update.Value.ToString();
});
}
/// <summary>
/// 提醒DD动态更新的事件
/// </summary>
/// <param name="msgObject">CQApi</param>
private static void SubscriptionEvent(object msgObject)
{
if (msgObject is ConnectEventArgs connectEventArgs)
{
SubscriptionUpdate.BiliUpdateCheck(connectEventArgs);
}
}
public async Task MarkAsReceivedAsync(SubscriptionUpdate update, CancellationToken cancellationToken)
{
await _table.CreateIfNotExistsAsync(null, null, cancellationToken);
var model = new ReceivedSubscriptionModel(update);
await _table.ExecuteAsync(TableOperation.InsertOrReplace(model), null, null, cancellationToken);
}
public async Task <Subscription> SubscribeAsync(string appId, SubscriptionUpdate update, CancellationToken ct = default)
{
var document = MongoDbSubscription.FromSubscription(appId, update);
await Collection.ReplaceOneAsync(x => x.DocId == document.DocId, document, UpsertReplace, ct);
return(document.ToSubscription());
}
public async Task <Subscription> UpdateSubscriptionAsync(
Guid id,
SubscriptionUpdate body = default,
CancellationToken cancellationToken = default
)
{
if (id == default(Guid))
{
throw new ArgumentNullException(nameof(id));
}
const string apiVersion = "2019-01-16";
var _baseUri = Client.Options.BaseUri;
var _url = new RequestUriBuilder();
_url.Reset(_baseUri);
_url.AppendPath(
"/api/subscriptions/{id}".Replace("{id}", Uri.EscapeDataString(Client.Serialize(id))),
false);
_url.AppendQuery("api-version", Client.Serialize(apiVersion));
using (var _req = Client.Pipeline.CreateRequest())
{
_req.Uri = _url;
_req.Method = RequestMethod.Patch;
if (body != default(SubscriptionUpdate))
{
_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));
_req.Headers.Add("Content-Type", "application/json; charset=utf-8");
}
using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
{
if (_res.Status < 200 || _res.Status >= 300)
{
await OnUpdateSubscriptionFailed(_req, _res).ConfigureAwait(false);
}
if (_res.ContentStream == null)
{
await OnUpdateSubscriptionFailed(_req, _res).ConfigureAwait(false);
}
using (var _reader = new StreamReader(_res.ContentStream))
{
var _content = await _reader.ReadToEndAsync().ConfigureAwait(false);
var _body = Client.Deserialize <Subscription>(_content);
return(_body);
}
}
}
}
public async Task <IActionResult> UpdateSubscription(Guid id, [FromBody] SubscriptionUpdate update)
{
Data.Models.Subscription subscription = await _context.Subscriptions.Where(sub => sub.Id == id)
.FirstOrDefaultAsync();
if (subscription == null)
{
return(NotFound());
}
bool 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)));
}
/// <summary>
/// Implements the 'subscription-status' operation
/// </summary>
/// <param name="options"></param>
public override async Task <int> ExecuteAsync()
{
if ((_options.Enable && _options.Disable) ||
(!_options.Enable && !_options.Disable))
{
Console.WriteLine("Please specify either --enable or --disable");
return(Constants.ErrorCode);
}
IRemote remote = RemoteFactory.GetBarOnlyRemote(_options, Logger);
// First, try to get the subscription. If it doesn't exist the call will throw and the exception will be
// caught by `RunOperation`
Subscription subscription = await remote.GetSubscriptionAsync(_options.Id);
string statusMessage = "enable";
if (!_options.Enable)
{
statusMessage = "disable";
}
if (subscription.Enabled == _options.Enable)
{
Console.WriteLine($"Status of subscription '{_options.Id}' is already {statusMessage}d, exiting...");
return(Constants.SuccessCode);
}
try
{
SubscriptionUpdate subscriptionToUpdate = new SubscriptionUpdate
{
ChannelName = subscription.Channel.Name,
SourceRepository = subscription.SourceRepository,
Enabled = _options.Enable,
Policy = subscription.Policy
};
subscriptionToUpdate.Policy.Batchable = subscription.Policy.Batchable;
subscriptionToUpdate.Policy.UpdateFrequency = subscription.Policy.UpdateFrequency;
subscriptionToUpdate.Policy.MergePolicies = subscription.Policy.MergePolicies;
var updatedSubscription = await remote.UpdateSubscriptionAsync(
_options.Id,
subscriptionToUpdate);
Console.WriteLine($"Successfully {statusMessage}d subscription with id '{updatedSubscription.Id}'.");
return(Constants.SuccessCode);
}
catch (Exception e)
{
Logger.LogError(e, $"Failed to {statusMessage} subscription.");
return(Constants.ErrorCode);
}
}
public async Task TrackSuccessfulAction(string action, string result)
{
SubscriptionUpdate subscriptionUpdate = await GetSubscriptionUpdate();
subscriptionUpdate.Action = action;
subscriptionUpdate.ErrorMessage = result;
subscriptionUpdate.Method = null;
subscriptionUpdate.Arguments = null;
subscriptionUpdate.Success = true;
await Context.SaveChangesAsync();
}
public async Task TrackFailedAction(string action, string result, string method, string arguments)
{
SubscriptionUpdate subscriptionUpdate = await GetSubscriptionUpdate();
subscriptionUpdate.Action = action;
subscriptionUpdate.ErrorMessage = result;
subscriptionUpdate.Method = method;
subscriptionUpdate.Arguments = arguments;
subscriptionUpdate.Success = false;
await Context.SaveChangesAsync();
}
public async Task <IActionResult> Register([FromBody] RegisterRequestDto request)
{
string?userId = null;
string?userToken = null;
if (request.CreateUser)
{
userId = Guid.NewGuid().ToString();
var update = request.ToUpdate();
var user = await userStore.UpsertAsync(App.Id, userId, update, HttpContext.RequestAborted);
if (request.Topics?.Any() == true)
{
var subscription = new SubscriptionUpdate();
subscription.TopicSettings[Providers.WebPush] = new NotificationSetting
{
Send = true
};
if (!string.IsNullOrEmpty(request.EmailAddress))
{
subscription.TopicSettings[Providers.Email] = new NotificationSetting
{
Send = true
};
}
foreach (var topic in request.Topics)
{
subscription.TopicPrefix = topic;
await subscriptionStore.SubscribeWhenNotFoundAsync(App.Id, subscription, HttpContext.RequestAborted);
}
}
userToken = user.ApiKey;
}
var response = new RegisterResponseDto
{
PublicKey = webPushService.PublicKey,
UserId = userId,
UserToken = userToken
};
return(Ok(response));
}
public async Task <Subscription> UpdateSubscriptionAsync(
Guid id,
SubscriptionUpdate body = default,
CancellationToken cancellationToken = default
)
{
using (var _res = await UpdateSubscriptionInternalAsync(
id,
body,
cancellationToken
).ConfigureAwait(false))
{
return(_res.Body);
}
}
public static MongoDbSubscription FromSubscription(string appId, SubscriptionUpdate update)
{
var docId = CreateId(appId, update.UserId, update.TopicPrefix);
var result = new MongoDbSubscription
{
DocId = docId,
AppId = appId,
TopicArray = new TopicId(update.TopicPrefix).GetParts(),
TopicPrefix = update.TopicPrefix,
TopicSettings = update.TopicSettings,
UserId = update.UserId
};
return(result);
}
private Task SubscribeAsync(string userId, string topicPrefix, bool sendEmail = false)
{
var update = new SubscriptionUpdate {
TopicPrefix = topicPrefix, UserId = userId
};
if (sendEmail)
{
update.TopicSettings[Providers.Email] = new NotificationSetting
{
Send = sendEmail
};
}
return(_.Repository.SubscribeAsync(appId, update));
}
public async Task SubscribeWhenNotFoundAsync(string appId, SubscriptionUpdate update, CancellationToken ct = default)
{
var document = MongoDbSubscription.FromSubscription(appId, update);
try
{
await Collection.InsertOneAsync(document, null, ct);
}
catch (MongoWriteException ex)
{
if (ex.WriteError.Category == ServerErrorCategory.DuplicateKey)
{
return;
}
}
}
private async Task <SubscriptionUpdate> GetSubscriptionUpdate()
{
SubscriptionUpdate subscriptionUpdate = await Context.SubscriptionUpdates.FindAsync(SubscriptionId);
if (subscriptionUpdate == null)
{
Context.SubscriptionUpdates.Add(
subscriptionUpdate = new SubscriptionUpdate {
SubscriptionId = SubscriptionId
});
}
else
{
Context.SubscriptionUpdates.Update(subscriptionUpdate);
}
return(subscriptionUpdate);
}
/// <summary>
/// Checks if a specific update has been received previousl.y
/// </summary>
/// <returns>True if already received</returns>
private async Task <bool> HasPreviouslyBeenReceivedAsync(SubscriptionUpdate s, CancellationToken cancellationToken)
{
await _table.CreateIfNotExistsAsync(null, null, cancellationToken);
var model = new ReceivedSubscriptionModel(s);
var partitionMatch = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, model.PartitionKey);
var rowMatch = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, model.RowKey);
var pointQuery = TableQuery.CombineFilters(partitionMatch, TableOperators.And, rowMatch);
var tableQuery = new TableQuery <ReceivedSubscriptionModel>
{
FilterString = pointQuery
};
var tableQueryResult = await _table.ExecuteQuerySegmentedAsync(tableQuery, null, null, null, cancellationToken);
return(tableQueryResult.Results.Count > 0);
}
public async Task UpdateSubscription()
{
const string requestLocation =
"/v0/developmentEvents/subscriptions/amzn1.ask-subscriber.xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
var management = new ManagementApi("xxx", new ActionHandler(async req =>
{
Assert.Equal(HttpMethod.Put, req.Method);
Assert.Equal(requestLocation, req.RequestUri.PathAndQuery);
var raw = await req.Content.ReadAsStringAsync();
var request = JsonConvert.DeserializeObject <SubscriptionUpdate>(raw);
Assert.Equal(AlexaDevelopmentEventType.ManifestUpdate, request.Events.Single());
}, HttpStatusCode.NoContent));
var subscriptionUpdate = new SubscriptionUpdate
{
Name = "Example Development Event Subscriber",
Events = new [] { AlexaDevelopmentEventType.ManifestUpdate }
};
await management.SkillDevelopment.Subscription.Update("amzn1.ask-subscriber.xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", subscriptionUpdate);
}
public SubscriptionUpdate ToUpdate(string userId)
{
var result = new SubscriptionUpdate
{
TopicPrefix = TopicPrefix
};
if (TopicSettings != null)
{
foreach (var(key, value) in TopicSettings)
{
if (value != null)
{
result.TopicSettings[key] = value.ToDomainObject();
}
}
}
result.UserId = userId;
return(result);
}
internal async Task <HttpOperationResponse <Subscription> > UpdateSubscriptionInternalAsync(
Guid id,
SubscriptionUpdate body = default,
CancellationToken cancellationToken = default
)
{
if (id == default)
{
throw new ArgumentNullException(nameof(id));
}
const string apiVersion = "2019-01-16";
var _path = "/api/subscriptions/{id}";
_path = _path.Replace("{id}", Client.Serialize(id));
var _query = new QueryBuilder();
_query.Add("api-version", Client.Serialize(apiVersion));
var _uriBuilder = new UriBuilder(Client.BaseUri);
_uriBuilder.Path = _uriBuilder.Path.TrimEnd('/') + _path;
_uriBuilder.Query = _query.ToString();
var _url = _uriBuilder.Uri;
HttpRequestMessage _req = null;
HttpResponseMessage _res = null;
try
{
_req = new HttpRequestMessage(new HttpMethod("PATCH"), _url);
string _requestContent = null;
if (body != default)
{
_requestContent = Client.Serialize(body);
_req.Content = new StringContent(_requestContent, Encoding.UTF8)
{
Headers =
{
ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"),
},
};
}
if (Client.Credentials != null)
{
await Client.Credentials.ProcessHttpRequestAsync(_req, cancellationToken).ConfigureAwait(false);
}
_res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false);
if (!_res.IsSuccessStatusCode)
{
await OnUpdateSubscriptionFailed(_req, _res);
}
string _responseContent = await _res.Content.ReadAsStringAsync().ConfigureAwait(false);
return(new HttpOperationResponse <Subscription>
{
Request = _req,
Response = _res,
Body = Client.Deserialize <Subscription>(_responseContent),
});
}
catch (Exception)
{
_req?.Dispose();
_res?.Dispose();
throw;
}
}
/// <summary>
/// Implements the 'update-subscription' operation
/// </summary>
/// <param name="options"></param>
public override async Task <int> ExecuteAsync()
{
IRemote remote = RemoteFactory.GetBarOnlyRemote(_options, Logger);
// First, try to get the subscription. If it doesn't exist the call will throw and the exception will be
// caught by `RunOperation`
Subscription subscription = await remote.GetSubscriptionAsync(_options.Id);
var suggestedRepos = remote.GetSubscriptionsAsync();
var suggestedChannels = remote.GetChannelsAsync();
UpdateSubscriptionPopUp updateSubscriptionPopUp = new UpdateSubscriptionPopUp(
"update-subscription/update-subscription-todo",
Logger,
subscription,
(await suggestedChannels).Select(suggestedChannel => suggestedChannel.Name),
(await suggestedRepos).SelectMany(subs => new List <string> {
subscription.SourceRepository, subscription.TargetRepository
}).ToHashSet(),
Constants.AvailableFrequencies,
Constants.AvailableMergePolicyYamlHelp);
UxManager uxManager = new UxManager(Logger);
int exitCode = uxManager.PopUp(updateSubscriptionPopUp);
if (exitCode != Constants.SuccessCode)
{
return(exitCode);
}
string channel = updateSubscriptionPopUp.Channel;
string sourceRepository = updateSubscriptionPopUp.SourceRepository;
string updateFrequency = updateSubscriptionPopUp.UpdateFrequency;
bool batchable = updateSubscriptionPopUp.Batchable;
bool enabled = updateSubscriptionPopUp.Enabled;
List <MergePolicy> mergePolicies = updateSubscriptionPopUp.MergePolicies;
try
{
SubscriptionUpdate subscriptionToUpdate = new SubscriptionUpdate
{
ChannelName = channel ?? subscription.Channel.Name,
SourceRepository = sourceRepository ?? subscription.SourceRepository,
Enabled = enabled,
Policy = subscription.Policy,
};
subscriptionToUpdate.Policy.Batchable = batchable;
subscriptionToUpdate.Policy.UpdateFrequency = Enum.Parse <UpdateFrequency>(updateFrequency);
subscriptionToUpdate.Policy.MergePolicies = mergePolicies?.ToImmutableList();
var updatedSubscription = await remote.UpdateSubscriptionAsync(
_options.Id,
subscriptionToUpdate);
Console.WriteLine($"Successfully updated subscription with id '{updatedSubscription.Id}'.");
return(Constants.SuccessCode);
}
catch (RestApiException e) when(e.Response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
// Could have been some kind of validation error (e.g. channel doesn't exist)
Logger.LogError($"Failed to update subscription: {e.Response.Content}");
return(Constants.ErrorCode);
}
catch (Exception e)
{
Logger.LogError(e, $"Failed to update subscription.");
return(Constants.ErrorCode);
}
}
/// <param name='id'>
/// </param>
/// <param name='update'>
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ApiErrorException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <Subscription> > UpdateSubscriptionWithHttpMessagesAsync(System.Guid id, SubscriptionUpdate update = default(SubscriptionUpdate), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
string apiVersion = "2018-07-16";
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("id", id);
tracingParameters.Add("update", update);
tracingParameters.Add("apiVersion", apiVersion);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "UpdateSubscription", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/subscriptions/{id}").ToString();
_url = _url.Replace("{id}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(id, Client.SerializationSettings).Trim('"')));
List <string> _queryParameters = new List <string>();
if (apiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(apiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += "?" + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("PATCH");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (update != null)
{
_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(update, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json-patch+json; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new ApiErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ApiError _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ApiError>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <Subscription>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <Subscription>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='id'>
/// </param>
/// <param name='update'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Subscription> UpdateSubscriptionAsync(this ISubscriptions operations, System.Guid id, SubscriptionUpdate update = default(SubscriptionUpdate), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.UpdateSubscriptionWithHttpMessagesAsync(id, update, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Implements the 'subscription-status' operation
/// </summary>
/// <param name="options"></param>
public override async Task <int> ExecuteAsync()
{
if ((_options.Enable && _options.Disable) ||
(!_options.Enable && !_options.Disable))
{
Console.WriteLine("Please specify either --enable or --disable");
return(Constants.ErrorCode);
}
string presentTenseStatusMessage = _options.Enable ? "enable" : "disable";
string pastTenseStatusMessage = _options.Enable ? "enabled" : "disabled";
string actionStatusMessage = _options.Enable ? "Enabling" : "Disabling";
try
{
IRemote remote = RemoteFactory.GetBarOnlyRemote(_options, Logger);
bool noConfirm = _options.NoConfirmation;
List <Subscription> subscriptionsToEnableDisable = new List <Subscription>();
if (!string.IsNullOrEmpty(_options.Id))
{
// Look up subscription so we can print it later.
try
{
Subscription subscription = await remote.GetSubscriptionAsync(_options.Id);
subscriptionsToEnableDisable.Add(subscription);
}
catch (RestApiException e) when(e.Response.Status == (int)HttpStatusCode.NotFound)
{
Console.WriteLine($"Subscription with id '{_options.Id}' was not found.");
return(Constants.ErrorCode);
}
}
else
{
if (!_options.HasAnyFilters())
{
Console.WriteLine($"Please specify one or more filters to select which subscriptions should be {pastTenseStatusMessage} (see help).");
return(Constants.ErrorCode);
}
IEnumerable <Subscription> subscriptions = await _options.FilterSubscriptions(remote);
if (!subscriptions.Any())
{
Console.WriteLine("No subscriptions found matching the specified criteria.");
return(Constants.ErrorCode);
}
subscriptionsToEnableDisable.AddRange(subscriptions);
}
// Filter away subscriptions that already have the desired state:
subscriptionsToEnableDisable = subscriptionsToEnableDisable.Where(s => s.Enabled != _options.Enable).ToList();
if (!subscriptionsToEnableDisable.Any())
{
Console.WriteLine($"All subscriptions are already {pastTenseStatusMessage}.");
return(Constants.SuccessCode);
}
if (!noConfirm)
{
// Print out the list of subscriptions about to be enabled/disabled.
Console.WriteLine($"Will {presentTenseStatusMessage} the following {subscriptionsToEnableDisable.Count} subscriptions...");
foreach (var subscription in subscriptionsToEnableDisable)
{
Console.WriteLine($" {UxHelpers.GetSubscriptionDescription(subscription)}");
}
if (!UxHelpers.PromptForYesNo("Continue?"))
{
Console.WriteLine($"No subscriptions {pastTenseStatusMessage}, exiting.");
return(Constants.ErrorCode);
}
}
Console.Write($"{actionStatusMessage} {subscriptionsToEnableDisable.Count} subscriptions...{(noConfirm ? Environment.NewLine : "")}");
foreach (var subscription in subscriptionsToEnableDisable)
{
// If noConfirm was passed, print out the subscriptions as we go
if (noConfirm)
{
Console.WriteLine($" {UxHelpers.GetSubscriptionDescription(subscription)}");
}
SubscriptionUpdate subscriptionToUpdate = new SubscriptionUpdate
{
ChannelName = subscription.Channel.Name,
SourceRepository = subscription.SourceRepository,
Enabled = _options.Enable,
Policy = subscription.Policy
};
subscriptionToUpdate.Policy.Batchable = subscription.Policy.Batchable;
subscriptionToUpdate.Policy.UpdateFrequency = subscription.Policy.UpdateFrequency;
subscriptionToUpdate.Policy.MergePolicies = subscription.Policy.MergePolicies;
var updatedSubscription = await remote.UpdateSubscriptionAsync(
subscription.Id.ToString(),
subscriptionToUpdate);
}
Console.WriteLine("done");
return(Constants.SuccessCode);
}
catch (AuthenticationException e)
{
Console.WriteLine(e.Message);
return(Constants.ErrorCode);
}
catch (Exception e)
{
Logger.LogError(e, $"Unexpected error while {actionStatusMessage.ToLower()} subscriptions.");
return(Constants.ErrorCode);
}
}
public void Put(Guid id, SubscriptionUpdate value)
{
}
/// <summary>
/// Update an existing subscription
/// </summary>
/// <param name="subscriptionId">Id of subscription to update</param>
/// <param name="subscription">Subscription information</param>
/// <returns>Updated subscription</returns>
public Task <Subscription> UpdateSubscriptionAsync(string subscriptionId, SubscriptionUpdate subscription)
{
CheckForValidBarClient();
return(_barClient.UpdateSubscriptionAsync(GetSubscriptionGuid(subscriptionId), subscription));
}
/// <summary>
/// Update an existing subscription
/// </summary>
/// <param name="subscriptionId">Id of subscription to update</param>
/// <param name="subscription">Subscription information</param>
/// <returns>Updated subscription</returns>
public Task <Subscription> UpdateSubscriptionAsync(Guid subscriptionId, SubscriptionUpdate subscription)
{
return(_barClient.Subscriptions.UpdateSubscriptionAsync(subscriptionId, subscription));
}
public async Task UpdateSubscription()
{
string testChannelName = "test-channel-sub-controller20200220";
string defaultGitHubSourceRepo = "https://github.com/dotnet/sub-controller-test-source-repo";
string defaultGitHubTargetRepo = "https://github.com/dotnet/sub-controller-test-target-repo";
string defaultBranchName = "main";
string aValidDependencyFlowNotificationList = "@someMicrosoftUser;@some-github-team";
string anInvalidDependencyFlowNotificationList = "@someExternalUser;@someMicrosoftUser;@some-team";
// Create two subscriptions
SubscriptionData subscription1 = new SubscriptionData()
{
ChannelName = testChannelName,
Enabled = true,
SourceRepository = $"{defaultGitHubSourceRepo}-needsupdate",
TargetRepository = defaultGitHubTargetRepo,
Policy = new Api.v2018_07_16.Models.SubscriptionPolicy()
{
Batchable = true, UpdateFrequency = Api.v2018_07_16.Models.UpdateFrequency.EveryWeek
},
TargetBranch = defaultBranchName
};
Subscription createdSubscription1;
{
IActionResult result = await data.SubscriptionsController.Create(subscription1);
result.Should().BeAssignableTo <ObjectResult>();
var objResult = (ObjectResult)result;
objResult.StatusCode.Should().Be((int)HttpStatusCode.Created);
objResult.Value.Should().BeAssignableTo <Subscription>();
createdSubscription1 = (Subscription)objResult.Value;
createdSubscription1.Channel.Name.Should().Be(testChannelName);
createdSubscription1.Policy.Batchable.Should().Be(true);
createdSubscription1.Policy.UpdateFrequency.Should().Be(Api.v2018_07_16.Models.UpdateFrequency.EveryWeek);
createdSubscription1.TargetBranch.Should().Be(defaultBranchName);
createdSubscription1.SourceRepository.Should().Be($"{defaultGitHubSourceRepo}-needsupdate");
createdSubscription1.TargetRepository.Should().Be(defaultGitHubTargetRepo);
}
SubscriptionUpdate update = new SubscriptionUpdate()
{
Enabled = !subscription1.Enabled,
Policy = new Api.v2018_07_16.Models.SubscriptionPolicy()
{
Batchable = false, UpdateFrequency = Api.v2018_07_16.Models.UpdateFrequency.EveryDay
},
SourceRepository = $"{subscription1.SourceRepository}-updated",
PullRequestFailureNotificationTags = aValidDependencyFlowNotificationList
};
{
IActionResult result = await data.SubscriptionsController.UpdateSubscription(createdSubscription1.Id, update);
result.Should().BeAssignableTo <ObjectResult>();
var objResult = (ObjectResult)result;
objResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
objResult.Value.Should().BeAssignableTo <Subscription>();
// Could also do a get after this; that more tests the underlying data context though.
var updatedSubscription = (Subscription)objResult.Value;
updatedSubscription.Id.Should().Be(createdSubscription1.Id);
updatedSubscription.Enabled.Should().IsSameOrEqualTo(!subscription1.Enabled);
updatedSubscription.Policy.UpdateFrequency.Should().Be(Api.v2018_07_16.Models.UpdateFrequency.EveryDay);
updatedSubscription.SourceRepository.Should().Be($"{subscription1.SourceRepository}-updated");
updatedSubscription.PullRequestFailureNotificationTags.Should().Be(aValidDependencyFlowNotificationList);
}
// Update with an invalid list, make sure it fails
SubscriptionUpdate badUpdate = new SubscriptionUpdate()
{
Enabled = !subscription1.Enabled,
Policy = new Api.v2018_07_16.Models.SubscriptionPolicy()
{
Batchable = false, UpdateFrequency = Api.v2018_07_16.Models.UpdateFrequency.EveryDay
},
SourceRepository = $"{subscription1.SourceRepository}-updated",
PullRequestFailureNotificationTags = anInvalidDependencyFlowNotificationList
};
{
IActionResult result = await data.SubscriptionsController.UpdateSubscription(createdSubscription1.Id, badUpdate);
result.Should().BeAssignableTo <BadRequestObjectResult>();
}
}
/// <summary>
/// Implements the 'update-subscription' operation
/// </summary>
/// <param name="options"></param>
public override async Task <int> ExecuteAsync()
{
IRemote remote = RemoteFactory.GetBarOnlyRemote(_options, Logger);
// First, try to get the subscription. If it doesn't exist the call will throw and the exception will be
// caught by `RunOperation`
Subscription subscription = await remote.GetSubscriptionAsync(_options.Id);
var suggestedRepos = remote.GetSubscriptionsAsync();
var suggestedChannels = remote.GetChannelsAsync();
UpdateSubscriptionPopUp updateSubscriptionPopUp = new UpdateSubscriptionPopUp(
"update-subscription/update-subscription-todo",
Logger,
subscription,
(await suggestedChannels).Select(suggestedChannel => suggestedChannel.Name),
(await suggestedRepos).SelectMany(subs => new List <string> {
subscription.SourceRepository, subscription.TargetRepository
}).ToHashSet(),
Constants.AvailableFrequencies,
Constants.AvailableMergePolicyYamlHelp);
UxManager uxManager = new UxManager(_options.GitLocation, Logger);
int exitCode = uxManager.PopUp(updateSubscriptionPopUp);
if (exitCode != Constants.SuccessCode)
{
return(exitCode);
}
string channel = updateSubscriptionPopUp.Channel;
string sourceRepository = updateSubscriptionPopUp.SourceRepository;
string updateFrequency = updateSubscriptionPopUp.UpdateFrequency;
bool batchable = updateSubscriptionPopUp.Batchable;
bool enabled = updateSubscriptionPopUp.Enabled;
List <MergePolicy> mergePolicies = updateSubscriptionPopUp.MergePolicies;
try
{
SubscriptionUpdate subscriptionToUpdate = new SubscriptionUpdate
{
ChannelName = channel ?? subscription.Channel.Name,
SourceRepository = sourceRepository ?? subscription.SourceRepository,
Enabled = enabled,
Policy = subscription.Policy,
};
subscriptionToUpdate.Policy.Batchable = batchable;
subscriptionToUpdate.Policy.UpdateFrequency = Enum.Parse <UpdateFrequency>(updateFrequency);
subscriptionToUpdate.Policy.MergePolicies = mergePolicies?.ToImmutableList();
var updatedSubscription = await remote.UpdateSubscriptionAsync(
_options.Id,
subscriptionToUpdate);
Console.WriteLine($"Successfully updated subscription with id '{updatedSubscription.Id}'.");
// Determine whether the subscription should be triggered.
if (!_options.NoTriggerOnUpdate)
{
bool triggerAutomatically = _options.TriggerOnUpdate;
// Determine whether we should prompt if the user hasn't explicitly
// said one way or another. We shouldn't prompt if nothing changes or
// if non-interesting options have changed
if (!triggerAutomatically &&
((subscriptionToUpdate.ChannelName != subscription.Channel.Name) ||
(subscriptionToUpdate.SourceRepository != subscription.SourceRepository) ||
(subscriptionToUpdate.Enabled.Value && !subscription.Enabled) ||
(subscriptionToUpdate.Policy.UpdateFrequency != UpdateFrequency.None && subscriptionToUpdate.Policy.UpdateFrequency !=
subscription.Policy.UpdateFrequency)))
{
triggerAutomatically = UxHelpers.PromptForYesNo("Trigger this subscription immediately?");
}
if (triggerAutomatically)
{
await remote.TriggerSubscriptionAsync(updatedSubscription.Id.ToString());
Console.WriteLine($"Subscription '{updatedSubscription.Id}' triggered.");
}
}
return(Constants.SuccessCode);
}
catch (AuthenticationException e)
{
Console.WriteLine(e.Message);
return(Constants.ErrorCode);
}
catch (RestApiException e) when(e.Response.Status == (int)System.Net.HttpStatusCode.BadRequest)
{
// Could have been some kind of validation error (e.g. channel doesn't exist)
Logger.LogError($"Failed to update subscription: {e.Response.Content}");
return(Constants.ErrorCode);
}
catch (Exception e)
{
Logger.LogError(e, $"Failed to update subscription.");
return(Constants.ErrorCode);
}
}
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)));
}
public Task <Subscription> UpdateSubscriptionAsync(Guid subscriptionId, SubscriptionUpdate subscription)
{
throw new NotImplementedException();
}
