private ActionResult ModifyState(ClientSubscription clientSubscription, ClientSubscriptionState state) { if (ModelState.IsValid) { DateTime time = clientSubscription.Timestamp; ClientSubscription subscription = db.ClientSubscriptions.Find(clientSubscription.ClientSubscriptionId); long clientAccountId = subscription.ClientAccountId; subscription.State = state; subscription.Timestamp = DateTime.Now; subscription.Notes = clientSubscription.Notes; db.Entry(subscription).State = EntityState.Modified; var clientSubscriptionHistory = new ClientSubscriptionHistory() { UnitPrice = subscription.UnitPrice, State = state, Quantity = subscription.CurrentQuantity, Notes = subscription.Notes, VesselName = subscription.VesselName, ClientSubscriptionId = subscription.ClientSubscriptionId, Timestamp = time }; db.ClientSubscriptionHistories.Add(clientSubscriptionHistory); db.SaveChanges(); return(RedirectToAction("Index", new { accountId = clientAccountId })); } return(View("Invalid state.")); }
public async Task ClientSubscription_FromQueryData_GeneralPropertyCheck() { var testServer = new TestServerBuilder() .AddGraphController <ClientSubscriptionTestController>() .AddSubscriptionServer() .Build(); var schema = testServer.Schema; var subServer = testServer.RetrieveSubscriptionServer(); var queryPlan = await testServer.CreateQueryPlan("subscription { watchObjects { property1 property2 }} "); Assert.AreEqual(1, queryPlan.Operations.Count); Assert.AreEqual(0, queryPlan.Messages.Count); var field = queryPlan.Operations.Values.First().FieldContexts[0].Field; var name = field.GetType().FullName; (var socketClient, var testClient) = await testServer.CreateSubscriptionClient(); var queryData = new GraphQueryData(); var sub = new ClientSubscription <GraphSchema>( testClient, queryData, queryPlan, queryPlan.Operations.First().Value, "abc123"); Assert.IsTrue(sub.IsValid); Assert.AreEqual("[subscription]/WatchObjects", sub.Route.Path); Assert.AreEqual("abc123", sub.Id); Assert.AreEqual(field, sub.Field); Assert.AreEqual(testClient, sub.Client); Assert.AreEqual(queryData, sub.QueryData); }
public ActionResult Deliver(long?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ClientSubscription clientSubscription = db.ClientSubscriptions.Find(id); if (clientSubscription == null) { return(HttpNotFound()); } ClientSubscriptionDeliverViewModel model = new ClientSubscriptionDeliverViewModel() { ClientAccountId = clientSubscription.ClientAccountId, ClientSubscriptionId = clientSubscription.ClientSubscriptionId, ClientAccountName = clientSubscription.Client.ClientAccountName, VesselName = clientSubscription.VesselName, StationAccountName = clientSubscription.Station.StationName, Quantity = clientSubscription.CurrentQuantity }; return(View(model)); }
// GET: ClientSubscriptions/Pay/5 public ActionResult Pay(long?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ClientSubscription clientSubscription = db.ClientSubscriptions.Find(id); if (clientSubscription == null) { return(HttpNotFound()); } var client = db.ClientAccounts.Find(clientSubscription.ClientAccountId); if (client == null) { return(HttpNotFound()); } if (client.Balance < clientSubscription.UnitPrice * clientSubscription.StartQuantity) { return(View("The balance is not enough to pay the subscription.")); } return(View(clientSubscription)); }
public IHttpActionResult Subscribe([FromBody] ClientSubscription subscription) { // save this subscription into the database if (ModelState.IsValid) { var pushSub = new PushSubscription { Username = "******", Url = subscription.Endpoint, P256dh = subscription.Keys.P256dh, Auth = subscription.Keys.Auth }; db.PushSubscriptions.Add(pushSub); db.SaveChanges(); var data = new { data = new { success = true } }; return(Ok(data)); } else { return(BadRequest(ModelState)); } }
public async Task ClientSubscription_NoFieldContextFound_ReturnsError() { var testServer = new TestServerBuilder() .AddGraphController <ClientSubscriptionTestController>() .AddSubscriptionServer() .Build(); var fakePlan = new Mock <IGraphQueryPlan>(); var fakeOp = new Mock <IGraphFieldExecutableOperation>(); var fakeFieldContext = new Mock <IGraphFieldInvocationContext>(); fakeFieldContext.Setup(x => x.Field).Returns(null as IGraphField); var fakeFieldContexts = new Mock <IFieldInvocationContextCollection>(); fakeFieldContexts.Setup(x => x[It.IsAny <int>()]).Returns(fakeFieldContext.Object); fakeOp.Setup(x => x.OperationType).Returns(GraphCollection.Subscription); fakeOp.Setup(x => x.FieldContexts).Returns(fakeFieldContexts.Object); (var socketClient, var testClient) = await testServer.CreateSubscriptionClient(); var sub = new ClientSubscription <GraphSchema>( testClient, GraphQueryData.Empty, fakePlan.Object, fakeOp.Object, "abc123"); Assert.IsFalse(sub.IsValid); Assert.AreEqual(1, sub.Messages.Count); Assert.AreEqual(Constants.ErrorCodes.BAD_REQUEST, sub.Messages[0].Code); Assert.IsTrue(sub.Messages.Severity.IsCritical()); }
public async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel) { if (input.Type != MqttPacketType.Unsubscribe) { return; } Unsubscribe unsubscribe = input as Unsubscribe; ClientSession session = _sessionRepository.Read(clientId); if (session == null) { throw new MqttException(ServerProperties.SessionRepository_ClientSessionNotFound(clientId)); } foreach (string topic in unsubscribe.Topics) { ClientSubscription subscription = session.GetSubscriptions().FirstOrDefault(s => s.TopicFilter == topic); if (subscription != null) { session.RemoveSubscription(subscription); } } _sessionRepository.Update(session); await channel.SendAsync(new UnsubscribeAck( unsubscribe.PacketId )); }
public async Task <Func <Task> > Subscribe <TEventArgs>(string eventName, EventHandler <TEventArgs> eventHandler, Dictionary <string, string> eventFilter = null) where TEventArgs : EventArgs { // match event name with the argument type MessageTypeProvider.Register(eventName, typeof(TEventArgs)); // prepare subscription metadata var subscription = new ClientSubscription <TEventArgs> { SubscriptionId = GenerateMessageId(), EventName = eventName, EventFilter = eventFilter, EventHandler = eventHandler, }; // notify the server about the new subscription var subscrMessage = subscription.CreateSubscriptionMessage(); await Call(subscrMessage); // register subscription in the subscription manager var unsubscribe = SubscriptionManager.Add(subscription); var unsubMessage = subscription.CreateUnsubscriptionMessage(); // return unsubscription action return(async() => { unsubscribe(); await Call(unsubMessage); }); }
public ActionResult DeleteConfirmed(long id) { ClientSubscription clientSubscription = db.ClientSubscriptions.Find(id); long clientAccountId = clientSubscription.ClientAccountId; db.ClientSubscriptions.Remove(clientSubscription); db.SaveChanges(); return(RedirectToAction("Index", new { accountId = clientAccountId })); }
public async Task <IActionResult> Unsubscribe([FromBody] ClientSubscription sub) { //var user = await _userManager.GetUserAsync(User); var user = await db.Users.FirstOrDefaultAsync(); var subscription = await db.Subscriptions.FirstOrDefaultAsync(s => s.UserId == user.UserId && s.auth == sub.keys.auth); db.Subscriptions.Remove(subscription); await db.SaveChangesAsync(); return(Ok()); }
public ActionResult PayConfirmed([Bind(Include = "ClientSubscriptionId, Notes, Timestamp")] ClientSubscription subscription) { if (ModelState.IsValid) { DateTime time = subscription.Timestamp; ClientSubscription clientSubscription = db.ClientSubscriptions.Find(subscription.ClientSubscriptionId); long clientAccountId = clientSubscription.ClientAccountId; ClientAccount client = db.ClientAccounts.Find(clientAccountId); if (client.Balance >= clientSubscription.UnitPrice * clientSubscription.StartQuantity) { clientSubscription.State = ClientSubscriptionState.Paid; db.Entry(clientSubscription).State = EntityState.Modified; client.Balance -= clientSubscription.UnitPrice * clientSubscription.StartQuantity; clientSubscription.Timestamp = time; db.Entry(client).State = EntityState.Modified; var clientSubscriptionHistory = new ClientSubscriptionHistory() { UnitPrice = clientSubscription.UnitPrice, State = ClientSubscriptionState.Paid, Quantity = clientSubscription.StartQuantity, VesselName = subscription.VesselName, Notes = clientSubscription.Notes, ClientSubscriptionId = clientSubscription.ClientSubscriptionId, Timestamp = time }; db.ClientSubscriptionHistories.Add(clientSubscriptionHistory); var clientBalanceHistory = new ClientBalanceHistory() { Amount = clientSubscription.UnitPrice * clientSubscription.StartQuantity * -1, BalanceType = BalanceChangeType.Pay, ClientAccountId = clientAccountId, Description = string.Format("Pay for Subscription: {0}.", subscription.ClientSubscriptionId), Timestamp = time }; db.ClientBalanceHistories.Add(clientBalanceHistory); db.SaveChanges(); return(RedirectToAction("Index", new { accountId = clientAccountId })); } return(View("The balance is not enough to pay the subscription.")); } return(View("The state is not valid.")); }
/// <summary> /// Client Manager Class Initaliser /// </summary> /// <param name="applicationName"></param> /// <param name="EndpointURL"></param> /// <param name="OPCItems"></param> /// <param name="AutoAccept"></param> public ClientController(string ApplicationName, string EndpointURL, List <DataItem> OPCItems, bool AutoAccept) { opcItems = OPCItems; applicationName = ApplicationName; endpointURL = EndpointURL; autoAccept = AutoAccept; opcSession = new ClientSession(applicationName, endpointURL, autoAccept).Execute(); ClientSubscription clientSubscription = new ClientSubscription(opcSession); clientSubscription.OnNotificationEventHandler += (sender, e) => OnClientSubscriptionNotificationEventHandler(sender, e); clientSubscription.Execute(opcItems); }
// GET: ClientSubscriptions/Details/5 public ActionResult Details(long?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ClientSubscription clientSubscription = db.ClientSubscriptions.Find(id); if (clientSubscription == null) { return(HttpNotFound()); } return(View(clientSubscription)); }
private ActionResult GetSnapshot(long?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ClientSubscription clientSubscription = db.ClientSubscriptions.Find(id); if (clientSubscription == null) { return(HttpNotFound()); } return(View(clientSubscription)); }
async Task DispatchAsync(Publish publish, ClientSubscription subscription, bool isWill = false) { MqttQualityOfService requestedQos = isWill ? publish.QualityOfService : subscription.MaximumQualityOfService; MqttQualityOfService supportedQos = configuration.GetSupportedQos(requestedQos); bool retain = isWill ? publish.Retain : false; ushort? packetId = supportedQos == MqttQualityOfService.AtMostOnce ? null : (ushort?)_packetIdProvider.GetPacketId(); Publish subscriptionPublish = new Publish(publish.Topic, supportedQos, retain, duplicated: false, packetId: packetId) { Payload = publish.Payload }; IMqttChannel <IPacket> clientChannel = _connectionProvider.GetConnection(subscription.ClientId); await _senderFlow.SendPublishAsync(subscription.ClientId, subscriptionPublish, clientChannel); }
async Task DispatchAsync(Publish publish, ClientSubscription subscription, bool isWill = false) { var requestedQos = isWill ? publish.QualityOfService : subscription.MaximumQualityOfService; var supportedQos = configuration.GetSupportedQos(requestedQos); var retain = isWill ? publish.Retain : false; ushort?packetId = supportedQos == MqttQualityOfService.AtMostOnce ? null : (ushort?)packetIdProvider.GetPacketId(); var subscriptionPublish = new Publish(publish.Topic, supportedQos, retain, duplicated: false, packetId: packetId) { Payload = publish.Payload }; var clientChannel = connectionProvider.GetConnection(subscription.ClientId); await senderFlow.SendPublishAsync(subscription.ClientId, subscriptionPublish, clientChannel) .ConfigureAwait(continueOnCapturedContext: false); }
public async Task <IActionResult> Subscribe([FromBody] ClientSubscription sub) { //var user = await _userManager.GetUserAsync(User); var user = await db.Users.FirstOrDefaultAsync(); var subscription = new Subscription { UserId = user.UserId, p256dh = sub.keys.p256dh, auth = sub.keys.auth, endpoint = sub.endpoint }; db.Subscriptions.Add(subscription); await db.SaveChangesAsync(); return(Ok(subscription)); }
public ActionResult Create([Bind(Include = "ClientAccountId,StationAccountId, VesselName, Quantity,UnitPrice,Notes,Timestamp")] ClientSubscriptionViewModel clientSubscriptionViewModel) { if (ModelState.IsValid) { DateTime time = clientSubscriptionViewModel.Timestamp; var clientSubscription = new ClientSubscription() { UnitPrice = clientSubscriptionViewModel.UnitPrice, State = ClientSubscriptionState.Created, StartQuantity = clientSubscriptionViewModel.Quantity, CurrentQuantity = clientSubscriptionViewModel.Quantity, ClientAccountId = clientSubscriptionViewModel.ClientAccountId, Notes = clientSubscriptionViewModel.Notes, VesselName = clientSubscriptionViewModel.VesselName, StationAccountId = int.Parse(clientSubscriptionViewModel.StationAccountId), Timestamp = time }; db.ClientSubscriptions.Add(clientSubscription); db.SaveChanges(); var clientSubscriptionHistory = new ClientSubscriptionHistory() { UnitPrice = clientSubscriptionViewModel.UnitPrice, State = ClientSubscriptionState.Created, Quantity = clientSubscriptionViewModel.Quantity, Notes = clientSubscriptionViewModel.Notes, VesselName = clientSubscriptionViewModel.VesselName, ClientSubscriptionId = clientSubscription.ClientSubscriptionId, Timestamp = time }; db.ClientSubscriptionHistories.Add(clientSubscriptionHistory); db.SaveChanges(); return(RedirectToAction("Index", new { accountId = clientSubscriptionViewModel.ClientAccountId })); } return(View(clientSubscriptionViewModel)); }
public ActionResult DeliverConfirmed([Bind(Include = "ClientSubscriptionId, Quantity, Notes")] ClientSubscriptionDeliverViewModel model) { if (ModelState.IsValid) { DateTime time = DateTime.Now; ClientSubscription subscription = db.ClientSubscriptions.Find(model.ClientSubscriptionId); long clientAccountId = subscription.ClientAccountId; float leftQuantity = subscription.CurrentQuantity - model.Quantity; if (leftQuantity == 0) { subscription.State = ClientSubscriptionState.Delivered; } else { subscription.State = ClientSubscriptionState.PartialDelivered; } subscription.CurrentQuantity = leftQuantity; subscription.Timestamp = time; subscription.Notes = model.Notes; db.Entry(subscription).State = EntityState.Modified; var clientSubscriptionHistory = new ClientSubscriptionHistory() { UnitPrice = subscription.UnitPrice, State = subscription.State, Quantity = model.Quantity, Notes = model.Notes, VesselName = subscription.VesselName, ClientSubscriptionId = subscription.ClientSubscriptionId, Timestamp = time }; db.ClientSubscriptionHistories.Add(clientSubscriptionHistory); db.SaveChanges(); return(RedirectToAction("Index", new { accountId = clientAccountId })); } return(View("Invalid state.")); }
async Task SendRetainedMessagesAsync(ClientSubscription subscription, IMqttChannel <IPacket> channel) { var retainedMessages = retainedRepository.GetAll() .Where(r => topicEvaluator.Matches(r.Topic, subscription.TopicFilter)); if (retainedMessages != null) { foreach (var retainedMessage in retainedMessages) { ushort?packetId = subscription.MaximumQualityOfService == MqttQualityOfService.AtMostOnce ? null : (ushort?)packetIdProvider.GetPacketId(); var publish = new Publish(retainedMessage.Topic, subscription.MaximumQualityOfService, retain: true, duplicated: false, packetId: packetId) { Payload = retainedMessage.Payload }; await senderFlow.SendPublishAsync(subscription.ClientId, publish, channel) .ConfigureAwait(continueOnCapturedContext: false); } } }
public void SubscribeAndUnsubscribeClientSubscription() { var firedCounter = 0; var cancel = false; void handler(object s, CancelEventArgs e) { firedCounter++; cancel = e.Cancel; } var subscription = new ClientSubscription <CancelEventArgs> { SubscriptionId = "1", EventHandler = handler, EventName = EventName, }; var unsubscribe = SubscriptionManager.Add(subscription); Assert.AreEqual(0, firedCounter); Assert.IsFalse(cancel); SubscriptionManager.Broadcast(EventName, new CancelEventArgs(true)); Assert.AreEqual(1, firedCounter); Assert.IsTrue(cancel); SubscriptionManager.Broadcast(EventName, new CancelEventArgs(false)); Assert.AreEqual(2, firedCounter); Assert.IsFalse(cancel); unsubscribe(); SubscriptionManager.Broadcast(EventName, new CancelEventArgs(true)); // event wasn't fired Assert.AreEqual(2, firedCounter); Assert.IsFalse(cancel); }
async Task SendRetainedMessagesAsync(ClientSubscription subscription, IMqttChannel <IPacket> channel) { IEnumerable <RetainedMessage> retainedMessages = _retainedRepository .ReadAll() .Where(r => _topicEvaluator.Matches(topicName: r.Id, topicFilter: subscription.TopicFilter)); if (retainedMessages != null) { foreach (RetainedMessage retainedMessage in retainedMessages) { ushort?packetId = subscription.MaximumQualityOfService == MqttQualityOfService.AtMostOnce ? null : (ushort?)_packetIdProvider.GetPacketId(); Publish publish = new Publish(topic: retainedMessage.Id, qualityOfService: subscription.MaximumQualityOfService, retain: true, duplicated: false, packetId: packetId) { Payload = retainedMessage.Payload }; await _senderFlow.SendPublishAsync(subscription.ClientId, publish, channel); } } }
public async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel) { if (input.Type != MqttPacketType.Subscribe) { return; } Subscribe subscribe = input as Subscribe; ClientSession session = _sessionRepository.Read(clientId); if (session == null) { throw new MqttException(ServerProperties.SessionRepository_ClientSessionNotFound(clientId)); } List <SubscribeReturnCode> returnCodes = new List <SubscribeReturnCode>(); foreach (Subscription subscription in subscribe.Subscriptions) { try { if (!_topicEvaluator.IsValidTopicFilter(subscription.TopicFilter)) { _tracer.Error(ServerProperties.ServerSubscribeFlow_InvalidTopicSubscription(subscription.TopicFilter, clientId)); returnCodes.Add(SubscribeReturnCode.Failure); continue; } ClientSubscription clientSubscription = session .GetSubscriptions() .FirstOrDefault(s => s.TopicFilter == subscription.TopicFilter); if (clientSubscription != null) { clientSubscription.MaximumQualityOfService = subscription.MaximumQualityOfService; } else { clientSubscription = new ClientSubscription { ClientId = clientId, TopicFilter = subscription.TopicFilter, MaximumQualityOfService = subscription.MaximumQualityOfService }; session.AddSubscription(clientSubscription); } await SendRetainedMessagesAsync(clientSubscription, channel); MqttQualityOfService supportedQos = _configuration.GetSupportedQos(subscription.MaximumQualityOfService); SubscribeReturnCode returnCode = supportedQos.ToReturnCode(); returnCodes.Add(returnCode); } catch (RepositoryException repoEx) { _tracer.Error(repoEx, ServerProperties.ServerSubscribeFlow_ErrorOnSubscription(clientId, subscription.TopicFilter)); returnCodes.Add(SubscribeReturnCode.Failure); } } _sessionRepository.Update(session); await channel.SendAsync(new SubscribeAck( subscribe.PacketId, returnCodes.ToArray())); }
public async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel) { if (input.Type != MqttPacketType.Subscribe) { return; } var subscribe = input as Subscribe; var session = sessionRepository.Read(clientId); if (session == null) { throw new MqttException(string.Format(Properties.Resources.SessionRepository_ClientSessionNotFound, clientId)); } var returnCodes = new List <SubscribeReturnCode> (); foreach (var subscription in subscribe.Subscriptions) { try { if (!topicEvaluator.IsValidTopicFilter(subscription.TopicFilter)) { tracer.Error(Server.Properties.Resources.ServerSubscribeFlow_InvalidTopicSubscription, subscription.TopicFilter, clientId); returnCodes.Add(SubscribeReturnCode.Failure); continue; } var clientSubscription = session .GetSubscriptions() .FirstOrDefault(s => s.TopicFilter == subscription.TopicFilter); if (clientSubscription != null) { clientSubscription.MaximumQualityOfService = subscription.MaximumQualityOfService; } else { Console.WriteLine("Client just connected: " + clientId + " " + subscription.TopicFilter); clientSubscription = new ClientSubscription { ClientId = clientId, TopicFilter = subscription.TopicFilter, MaximumQualityOfService = subscription.MaximumQualityOfService }; session.AddSubscription(clientSubscription); } await SendRetainedMessagesAsync(clientSubscription, channel) .ConfigureAwait(continueOnCapturedContext: false); var supportedQos = configuration.GetSupportedQos(subscription.MaximumQualityOfService); var returnCode = supportedQos.ToReturnCode(); returnCodes.Add(returnCode); } catch (RepositoryException repoEx) { tracer.Error(repoEx, Server.Properties.Resources.ServerSubscribeFlow_ErrorOnSubscription, clientId, subscription.TopicFilter); returnCodes.Add(SubscribeReturnCode.Failure); } } sessionRepository.Update(session); await channel.SendAsync(new SubscribeAck (subscribe.PacketId, returnCodes.ToArray())) .ConfigureAwait(continueOnCapturedContext: false); }
public ActionResult DeliverConfirmed([Bind(Include = "SubscriptionId, Quantity,ClientSubscriptionId, Notes, Timestamp")] SubscriptionDeliverViewModel model) { if (ModelState.IsValid) { DateTime time = model.Timestamp; Subscription subscription = db.Subscriptions.Find(model.SubscriptionId); ClientSubscription cs = db.ClientSubscriptions.Find(model.ClientSubscriptionId); long csId = cs.ClientSubscriptionId; if (cs.State != ClientSubscriptionState.Paid) { if (cs.State != ClientSubscriptionState.PartialDelivered) { throw new Exception("The client subscription state must be 'paid'."); } } if (cs.StationAccountId != subscription.StationAccountId) { throw new Exception("The station does not match."); } string clientAccountName = cs.Client.ClientAccountName; string vesselName = cs.VesselName; long accountId = subscription.StationAccountId; float leftQuantity = subscription.CurrentQuantity - model.Quantity; if (leftQuantity == 0) { subscription.State = SubscriptionState.Delivered; } else { subscription.State = SubscriptionState.PartialDelivered; } subscription.CurrentQuantity = leftQuantity; subscription.Timestamp = time; subscription.Notes = model.Notes; db.Entry(subscription).State = EntityState.Modified; var subscriptionHistory = new SubscriptionHistory() { UnitPrice = subscription.UnitPrice, State = subscription.State, Quantity = model.Quantity, Notes = model.Notes, ClientSubscriptionId = model.ClientSubscriptionId, ClientAccountName = clientAccountName, VesselName = vesselName, SubscriptionId = subscription.SubscriptionId, Timestamp = time }; db.SubscriptionHistories.Add(subscriptionHistory); float csLeftQuantity = cs.CurrentQuantity - model.Quantity; if (csLeftQuantity == 0) { cs.State = ClientSubscriptionState.Delivered; } else { cs.State = ClientSubscriptionState.PartialDelivered; } cs.CurrentQuantity = csLeftQuantity; cs.Timestamp = time; cs.Notes = model.Notes; db.Entry(cs).State = EntityState.Modified; var clientSubscriptionHistory = new ClientSubscriptionHistory() { UnitPrice = subscription.UnitPrice, State = cs.State, Quantity = model.Quantity, Notes = model.Notes, VesselName = vesselName, ClientSubscriptionId = cs.ClientSubscriptionId, Timestamp = time }; db.ClientSubscriptionHistories.Add(clientSubscriptionHistory); db.SaveChanges(); return(RedirectToAction("Index", new { accountId = accountId })); } return(View("Invalid state.")); }
public ActionResult CloseConfirmed([Bind(Include = "ClientSubscriptionId, Notes, Timestamp")] ClientSubscription clientSubscription) { return(ModifyState(clientSubscription, ClientSubscriptionState.Closed)); }