public IHttpActionResult DeleteSubscription(string id)
{
var currentUserId = User.Identity.GetUserId();
var result = _subscriptionService.DeleteSubscription(id, currentUserId);
return(this.ReturnHttpResponse(result));
}
public async Task <JsonResult> DeleteSubscriptions([FromBody] DeleteSubscriptionsDTO deleteSubscriptionsDto)
{
try
{
var results = new List <Result>();
// we do not use the automatic integration of fluentValidation into ASP.NET Core (validating objects that are passed in to controller actions), as we want to add ALL valid releases and not stop and throw if one is invalid)
var subscriptionValidator = new DeleteSubscriptionValidator(_trackedMediaSettings);
foreach (var deleteSubscription in deleteSubscriptionsDto.Subscriptions)
{
var validationResult = await subscriptionValidator.ValidateAsync(deleteSubscription);
if (validationResult.IsValid)
{
results.Add(await _subscriptionService.DeleteSubscription(deleteSubscription.MediaName, deleteSubscriptionsDto.NotificationEndpointIdentifier));
}
else
{
results.Add(Result.Failure(validationResult.GetMessage()));
}
}
return(new JsonResult(results.Select(r => r.AsSerializableResult())));
}
catch (Exception e)
{
_logger.LogError("Something went wrong. {exceptionMessage}", e.Message);
return(new JsonResult(Result.Failure("Deleting the subscriptions failed.").AsSerializableResult()));
}
}
public async Task <IActionResult> DeleteSubscription([FromRoute] int id)
{
var result = await _subscriptionService.DeleteSubscription(id);
if (!result)
{
return(BadRequest(result));
}
return(Ok(result));
}
protected async override Task <Either <CommandResult, Error> > ExecuteCommand(SubscriptionDeleteCommand command)
{
if (!(await spaceService.DoesSpaceExist(command.Space)))
{
return(new NotFoundError());
}
await subService.DeleteSubscription(command.Space, command.User);
return(Success());
}
public async Task <ActionResult <string> > Delete(int id)
{
Subscription subscription = await _eventsSubscriptionService.GetSubscription(id);
if (!AuthorizeAccessToSubscription(subscription))
{
return(Unauthorized());
}
await _eventsSubscriptionService.DeleteSubscription(id);
return(Ok());
}
public async Task ExecuteWhenDeleteSubscriptionCalledReturnsInternalServerErrorResult()
{
//Arrange
A.CallTo(() => subscriptionRegistrationService.DeleteSubscription(A <string> .Ignored)).Returns(HttpStatusCode.InternalServerError);
A.CallTo(() => _request.Method).Returns("DELETE");
//Act
InternalServerErrorResult result = (InternalServerErrorResult) await RunFunction("test-subscription-name");
// Assert
Assert.Equal((int?)HttpStatusCode.InternalServerError, result.StatusCode);
}
public DeleteResult Delete(SubscriptionInput input)
{
CheckModelState();
return(_subscriptionService.DeleteSubscription(input));
}
public void Delete(int id)
{
subscriptionMediator.DeleteSubscription(id);
}
public IActionResult DeleteSubscription(int subId)
{
_service.DeleteSubscription(subId);
return(Ok("successful subscription delete"));
}
public TopicSubscriptionsModule(ISubscriptionService subcriptionService)
{
_subscriptionService = subcriptionService;
//Subscribe to topic
Post("Subscriptions/{accountId}/Subscribe/{topicId}", async(args, ct) =>
{
var accountId = args.accountId;
var topicId = args.topicId;
var sessionCookie = Request.Headers.Cookie.FirstOrDefault(c => c.Name == _sessionTokenCookieName);
var sessionToken = sessionCookie == null ? null : sessionCookie.Value;
ActionResult <Subscription> result = await _subscriptionService.CreateSubscription(accountId, topicId, sessionToken);
if (result.statusCode != (System.Net.HttpStatusCode)HttpStatusCode.Created)
{
return(result.statusCode);
}
var subscription = result.resposeObject;
var confirmationToken = subscription.ConfirmationToken;
var subId = subscription.Id;
var links = new List <HyperMedia> {
new HyperMedia {
Href = this.Request.Url,
Rel = "self"
},
new HyperMedia {
Href = $"{this.Request.Url.SiteBase}/Subscriptions/{accountId}/Confirm/{confirmationToken}",
Rel = "confirm"
},
new HyperMedia {
Href = $"{this.Request.Url.SiteBase}/Subscriptions/{accountId}/Subscription/{subId}",
Rel = "delete"
}
};
var response = Response.AsJson(new { ConfirmationToken = confirmationToken, links = links });
if (!string.IsNullOrWhiteSpace(result.sessionToken))
{
await response.WithCookie(_sessionTokenCookieName, result.sessionToken);
}
return(response);
});
//Confirm topic subscription
Put("Subscriptions/{accountId}/Confirm/{confirmationToken}", async(args, ct) =>
{
var confirmationToken = args.confirmationToken;
var accountId = args.accountId;
var sessionCookie = Request.Headers.Cookie.FirstOrDefault(c => c.Name == _sessionTokenCookieName);
var sessionToken = sessionCookie == null ? null : sessionCookie.Value;
ActionResult <Subscription> result = await _subscriptionService.ConfirmSubscription(confirmationToken, accountId, sessionToken);
if (result.statusCode != (System.Net.HttpStatusCode)HttpStatusCode.OK)
{
//If status is Precondition failed then there is a concurrency violation.
if (result.statusCode == (System.Net.HttpStatusCode)HttpStatusCode.PreconditionFailed)
{
return("There is an update conflit on this subscription. Please refresh the status of the subscription and try again");
}
return(result.statusCode);
}
var subscription = result.resposeObject;
var subId = subscription.Id;
var links = new List <HyperMedia> {
new HyperMedia {
Href = this.Request.Url,
Rel = "self"
},
new HyperMedia {
Href = $"{this.Request.Url.SiteBase}/Subscriptions/{accountId}/Subscription/{subId}",
Rel = "delete"
}
};
var response = Response.AsJson(links);
if (!string.IsNullOrWhiteSpace(result.sessionToken))
{
await response.WithCookie(_sessionTokenCookieName, result.sessionToken);
}
return(Response.AsJson(links));
});
//Delete topic
Delete("Subscriptions/{accountId}/Subscription/{subscriptionId}", async args => {
var accountId = args.accountId;
var subId = args.subscriptionId;
var result = await _subscriptionService.DeleteSubscription(subId, accountId);
return(result);
});
}
public async Task <ActionResult <SubscriptionDto> > DeleteSubscription([FromRoute] int id)
{
_SubscriptionService.DeleteSubscription(id);
return(Ok());
}
public void ProcessNotifications()
{
var notifications = _repository.GetPendingNotifications().ToList();
if (!notifications.Any())
{
return;
}
//graph client is used to access graph API (create subscriptions, unpack notifications)
var graphClient = _tokenisedHttpClientFactory.GetGraphResourceClient();
//outlook client is used to access graph API (update calendars)
var outlookClient = _tokenisedHttpClientFactory.GetOutlookResourceClient();
foreach (var notification in notifications)
{
try
{
var subscription = _repository.GetSubscription(notification.SubscriptionId);
if (subscription == null)
{
//if the subscription doesnt exist in the database then stop further notifications?
_subscriptionService.DeleteSubscription(notification.SubscriptionId);
_repository.SetNotificationProcessingResult(notification.NotificationId, true, "Deleted Orphan Subscription");
continue;
}
string serviceRootUrl = string.Format($"{_setting.MicrosoftGraphResource}/v1.0/");
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, serviceRootUrl + notification.Resource);
// Send the 'GET' request to retreive the event
var response = graphClient.SendAsync(request).Result;
// Get the messages from the JSON response.
if (response.IsSuccessStatusCode)
{
string stringResult = response.Content.ReadAsStringAsync().Result;
Event e = JsonConvert.DeserializeObject <Event>(stringResult);
//Appogee events have leave type in the body but "Approved Leave" in the subject
if (e.BodyPreview.Contains("Leave Type: Working From Home") &&
e.Subject.Contains(": Approved Leave"))
{
var username = _repository.GetUsernameFromSubscription(notification.SubscriptionId);
if (string.IsNullOrEmpty(username))
{
throw new ApplicationException(string.Format($"could not locate subscription '{notification.SubscriptionId}' for notification '{notification.NotificationId}'"));
}
//for Graph PATCH requests supply only those properties to be updated
var update = new
{
Subject = e.Subject.Replace(": Approved Leave", ": Approved WFH"),
ShowAs = "4"
};
string patchUrl =
string.Format($"{_setting.OutlookResource}/api/v1.0/Users('{username}')/events/{e.Id}");
HttpRequestMessage updateRequest = new HttpRequestMessage(new HttpMethod("PATCH"), patchUrl);
string contentString = JsonConvert.SerializeObject(update,
new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
updateRequest.Content = new StringContent(contentString, System.Text.Encoding.UTF8,
"application/json");
HttpResponseMessage updateResponse = outlookClient.SendAsync(updateRequest).Result;
if (!updateResponse.IsSuccessStatusCode)
{
throw new ApplicationException(string.Format($"could not update entity: {e.Id}"));
}
_repository.SetNotificationProcessingResult(notification.NotificationId, true, "processed successfully");
}
else
{
_repository.SetNotificationProcessingResult(notification.NotificationId, true, string.Format($"no record to process, did not match predicate: Subject {e.Subject}, Body {e.BodyPreview}"));
}
}
else
{
throw new ApplicationException(String.Format($"failed processing. status code {response.StatusCode} .message {response.ReasonPhrase}"));
}
}
catch
(Exception ex)
{
_repository.SetNotificationProcessingResult(notification.NotificationId, false, ex.Message);
}
}
}
public void Configure(CommandLineApplication cmd)
{
cmd.Description = "Retrieve and manages your Youtube subscriptions";
cmd.HelpOption("-?|-h|--help");
var idOption = cmd.Option("-i|--id", "--id=[subscription id] - If this is not specified, all your subscriptions will be retrieved", CommandOptionType.SingleValue);
var deleteOption = cmd.Option("-d|--delete", "--delete - Delete retrieved subscription(s)", CommandOptionType.NoValue);
cmd.OnExecute(() =>
{
Console.WriteLine("Listing your subscriptions..");
Console.WriteLine("If you are not already logged in, a browser will open to allow you to log in to Youtube");
Console.WriteLine("");
List <Subscription> subscriptions;
if (idOption.HasValue())
{
subscriptions = new List <Subscription> {
_subscriptionService.GetSubscription(idOption.Value()).Result
};
}
else
{
subscriptions = _subscriptionService.GetSubscriptions().Result;
}
if (deleteOption.HasValue())
{
Console.WriteLine($"This will delete {subscriptions.Count} subscriptions.");
Console.WriteLine("Type 'd' or 'delete' to confirm:");
var userInput = Console.ReadLine();
if (userInput.ToLower() == "delete" || userInput.ToLower() == "d")
{
subscriptions.ForEach(subscription =>
{
Console.Write($"Deleting subscription with id {subscription.Id}... ");
_subscriptionService.DeleteSubscription(subscription.Id);
Console.Write("OK\n");
});
}
else
{
Console.WriteLine("Deletion canceled.");
}
}
else
{
// list subscriptions
subscriptions.ForEach(subscription =>
{
Console.WriteLine(JsonConvert.SerializeObject(subscription, Formatting.Indented));
Console.WriteLine("");
});
Console.WriteLine($"\n\n--------------------\nFinished listing {subscriptions.Count} subscriptions");
}
return(0);
});
}
