public SubscriptionsResponse Post(Subscriptions request) { if (request.Subscription.Id > 0) { Bm2s.Data.Common.BLL.Article.Subscription item = Datas.Instance.DataStorage.Subscriptions[request.Subscription.Id]; item.ArticleId = request.Subscription.Article.Id; item.Code = request.Subscription.Code; item.Designation = request.Subscription.Designation; item.EndingDate = request.Subscription.EndingDate; item.PeriodId = request.Subscription.Period.Id; item.StartingDate = request.Subscription.StartingDate; } else { Bm2s.Data.Common.BLL.Article.Subscription item = new Data.Common.BLL.Article.Subscription() { ArticleId = request.Subscription.Article.Id, Code = request.Subscription.Code, Designation = request.Subscription.Designation, EndingDate = request.Subscription.EndingDate, PeriodId = request.Subscription.Period.Id, StartingDate = request.Subscription.StartingDate }; Datas.Instance.DataStorage.Subscriptions.Add(item); request.Subscription.Id = item.Id; } SubscriptionsResponse response = new SubscriptionsResponse(); response.Subscriptions.Add(request.Subscription); return response; }
public SubscriptionsResponse Delete(Subscriptions request) { Bm2s.Data.Common.BLL.Article.Subscription item = Datas.Instance.DataStorage.Subscriptions[request.Subscription.Id]; Datas.Instance.DataStorage.Subscriptions.Remove(item); SubscriptionsResponse response = new SubscriptionsResponse(); response.Subscriptions.Add(request.Subscription); return response; }
public Model( Subscriptions.SubscriptionService subscriptionService, Media.MediaCacheService mediaCacheService, CommuterApplication application) { _subscriptionService = subscriptionService; _mediaCacheService = mediaCacheService; _application = application; }
public Server(int port) { Version = 1; Methods = new Methods(); Subscriptions = new Subscriptions(); Publications = new Publications(); new PublicationMethods(this).AttachMethods(); var messageMethods = new MessageMethods(this).GetMethods(); var messageProcessor = new MessageProcessor(messageMethods); _messageQueue = new ResultQueue<KeyValuePair<IWebSocketConnection, string>>(messageProcessor); _connector = new Connector(this, "127.0.0.1", port); }
public MyCommuteViewModel( Subscriptions.SubscriptionService subscriptions, Search.SearchService search, Images.ImageCacheService imageCacheService, CommuterApplication application, Media.MediaCacheService mediaCacheService) { _subscriptions = subscriptions; _search = search; _imageCacheService = imageCacheService; _application = application; _mediaCacheService = mediaCacheService; }
public SubscriptionsResponse Get(Subscriptions request) { SubscriptionsResponse response = new SubscriptionsResponse(); List<Bm2s.Data.Common.BLL.Article.Subscription> items = new List<Data.Common.BLL.Article.Subscription>(); if (!request.Ids.Any()) { items.AddRange(Datas.Instance.DataStorage.Subscriptions.Where(item => (request.ArticleId == 0 || item.ArticleId == request.ArticleId) && (string.IsNullOrWhiteSpace(request.Code) || item.Code.ToLower().Contains(request.Code.ToLower())) && (string.IsNullOrWhiteSpace(request.Designation) || item.Code.ToLower().Contains(request.Designation.ToLower())) && (!request.Date.HasValue || (request.Date >= item.StartingDate && (!item.EndingDate.HasValue || request.Date < item.EndingDate.Value))) )); } else { items.AddRange(Datas.Instance.DataStorage.Subscriptions.Where(item => request.Ids.Contains(item.Id))); } var collection = (from item in items select new Bm2s.Poco.Common.Article.Subscription() { Article = new ArticlesService().Get(new Articles() { Ids = new List<int>() { item.ArticleId } }).Articles.FirstOrDefault(), Code = item.Code, Designation = item.Designation, EndingDate = item.EndingDate, Id = item.Id, Period = new PeriodsService().Get(new Periods() { Ids = new List<int>() { item.PeriodId } }).Periods.FirstOrDefault(), StartingDate = item.StartingDate }).AsQueryable().OrderBy(request.Order, !request.DescendingOrder); response.ItemsCount = collection.Count(); if (request.PageSize > 0) { response.Subscriptions.AddRange(collection.Skip((request.CurrentPage - 1) * request.PageSize).Take(request.PageSize)); } else { response.Subscriptions.AddRange(collection); } try { response.PagesCount = collection.Count() / response.Subscriptions.Count + (collection.Count() % response.Subscriptions.Count > 0 ? 1 : 0); } catch { response.PagesCount = 1; } return response; }
/// <summary> /// Add Market Data Required - generic data typing support as long as Type implements BaseData. /// </summary> /// <param name="dataType">Set the type of the data we're subscribing to.</param> /// <param name="tickType">Tick type for the subscription.</param> /// <param name="symbol">Symbol of the asset we're like</param> /// <param name="resolution">Resolution of Asset Required</param> /// <param name="dataTimeZone">The time zone the subscription's data is time stamped in</param> /// <param name="exchangeTimeZone">Specifies the time zone of the exchange for the security this subscription is for. This /// is this output time zone, that is, the time zone that will be used on BaseData instances</param> /// <param name="isCustomData">True if this is custom user supplied data, false for normal QC data</param> /// <param name="fillDataForward">when there is no data pass the last tradebar forward</param> /// <param name="extendedMarketHours">Request premarket data as well when true </param> /// <param name="isInternalFeed">Set to true to prevent data from this subscription from being sent into the algorithm's OnData events</param> /// <param name="isFilteredSubscription">True if this subscription should have filters applied to it (market hours/user filters from security), false otherwise</param> /// <returns>The newly created <see cref="SubscriptionDataConfig"/></returns> public SubscriptionDataConfig Add(Type dataType, TickType tickType, Symbol symbol, Resolution resolution, DateTimeZone dataTimeZone, DateTimeZone exchangeTimeZone, bool isCustomData, bool fillDataForward = true, bool extendedMarketHours = false, bool isInternalFeed = false, bool isFilteredSubscription = true) { if (dataTimeZone == null) { throw new ArgumentNullException(nameof(dataTimeZone), "DataTimeZone is a required parameter for new subscriptions. Set to the time zone the raw data is time stamped in."); } if (exchangeTimeZone == null) { throw new ArgumentNullException(nameof(exchangeTimeZone), "ExchangeTimeZone is a required parameter for new subscriptions. Set to the time zone the security exchange resides in."); } //Create: var newConfig = new SubscriptionDataConfig(dataType, symbol, resolution, dataTimeZone, exchangeTimeZone, fillDataForward, extendedMarketHours, isInternalFeed, isCustomData, isFilteredSubscription: isFilteredSubscription, tickType: tickType); //Add to subscription list: make sure we don't have this symbol: if (_subscriptions.ContainsKey(newConfig)) { Log.Trace("SubscriptionManager.Add(): subscription already added: " + newConfig); return(newConfig); } _subscriptions.TryAdd(newConfig, 0); // count data subscriptions by symbol, ignoring multiple data types var uniqueCount = Subscriptions .Where(x => !x.Symbol.IsCanonical()) .DistinctBy(x => x.Symbol.Value) .Count(); if (uniqueCount > _algorithmSettings.DataSubscriptionLimit) { throw new Exception( $"The maximum number of concurrent market data subscriptions was exceeded ({_algorithmSettings.DataSubscriptionLimit}). Please reduce the number of symbols requested or increase the limit using Settings.DataSubscriptionLimit."); } // add the time zone to our time keeper _timeKeeper.AddTimeZone(exchangeTimeZone); // if is custom data, sets HasCustomData to true HasCustomData = HasCustomData || isCustomData; return(newConfig); }
public void UnSubscribeAll() { _connector.AddInfoLog(nameof(UnSubscribeAll)); var subscriptions = new List <Subscription>(); lock (_syncObject) { _keeped.Clear(); _keeped.AddRange(_subscriptions.Values); subscriptions.AddRange(Subscriptions.Where(s => s.State.IsActive())); } foreach (var subscription in subscriptions) { UnSubscribe(subscription); } }
public static bool IsSubscriber(string userId, string broadcasterId) { bool isSubscriber = false; try { string channelOauth = ConfigurationManager.AppSettings["channelOauth"]; string helixChannelSubscriptionToken = ConfigurationManager.AppSettings["helixChannelSubscriptionToken"]; Subscriptions subscriptions = new Subscriptions(); string url = "https://api.twitch.tv/helix/subscriptions?broadcaster_id=" + broadcasterId + "&user_id=" + userId; HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url); if (webRequest != null) { webRequest.Method = "GET"; webRequest.Timeout = 12000; webRequest.Headers.Add("Client-ID", channelOauth); webRequest.ContentType = "application/json"; webRequest.Accept = "application/vnd.twitchtv.v5+json"; webRequest.Headers.Add("Authorization: " + helixChannelSubscriptionToken); } using (Stream s = webRequest.GetResponse().GetResponseStream()) { using (System.IO.StreamReader sr = new System.IO.StreamReader(s)) { var jsonResponse = sr.ReadToEnd(); subscriptions = JsonConvert.DeserializeObject <Subscriptions>(jsonResponse); } } if (subscriptions.data.Count != 0) { isSubscriber = true; } } catch (Exception ex) { StringBuilder sb = new StringBuilder(DateTime.Now.ToString("dd-MM-yyyy") + " : " + ex.Message); Console.WriteLine(sb); } return(isSubscriber); }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public override void Dispose() { #if DEBUG GC.SuppressFinalize(this); #endif foreach (var observeChangesAndEvictItemsFromCacheForDatabase in observeChangesAndEvictItemsFromCacheForDatabases) { observeChangesAndEvictItemsFromCacheForDatabase.Value.Dispose(); } var tasks = new List <Task>(); foreach (var databaseChange in databaseChanges) { var remoteDatabaseChanges = databaseChange.Value as RemoteDatabaseChanges; if (remoteDatabaseChanges != null) { tasks.Add(remoteDatabaseChanges.DisposeAsync()); } else { using (databaseChange.Value as IDisposable) { } } } foreach (var replicationInformer in replicationInformers) { replicationInformer.Value.Dispose(); } // try to wait until all the async disposables are completed Task.WaitAll(tasks.ToArray(), TimeSpan.FromSeconds(3)); // if this is still going, we continue with disposal, it is for graceful shutdown only, anyway Subscriptions?.Dispose(); AsyncSubscriptions?.Dispose(); WasDisposed = true; AfterDispose?.Invoke(this, EventArgs.Empty); jsonRequestFactory?.Dispose(); }
public Subscribe(FixedHeader header, byte[] data) : base(header) { if (header.RemainingLength > 0) { using (var stream = new MemoryStream(data)) { if (Header.QualityOfService != QualityOfService.AtMostOnce) { MessageId = MessageId.FromStream(stream); while (stream.Position < stream.Length) { Subscriptions.Add(new Subscription(MQString.FromStream(stream), (QualityOfService)stream.ReadByteOrFail())); } } } } }
public virtual DynamicJsonValue ToJson() { return(new DynamicJsonValue(GetType()) { [nameof(DatabaseRecord)] = DatabaseRecord.ToJson(), [nameof(Documents)] = Documents.ToJson(), [nameof(RevisionDocuments)] = RevisionDocuments.ToJson(), [nameof(Tombstones)] = Tombstones.ToJson(), [nameof(Conflicts)] = Conflicts.ToJson(), [nameof(Identities)] = Identities.ToJson(), [nameof(Indexes)] = Indexes.ToJson(), [nameof(CompareExchange)] = CompareExchange.ToJson(), [nameof(Subscriptions)] = Subscriptions.ToJson(), [nameof(Counters)] = Counters.ToJson(), [nameof(CompareExchangeTombstones)] = CompareExchangeTombstones.ToJson(), [nameof(TimeSeries)] = TimeSeries.ToJson(), [nameof(ReplicationHubCertificates)] = ReplicationHubCertificates.ToJson(), }); }
public void SaveSubscriptions(string subscriptionsDataFile) { if (subscriptionsDataFile == null) { throw new ArgumentNullException("subscriptionsDataFile"); } var subscriptionsXml = new Subscriptions { Subscription = Subscriptions.Values.Select(subscription => { var subscriptionsSubscription = new SubscriptionsSubscription { CurrentStorageAccount = subscription.CurrentStorageAccount, name = subscription.SubscriptionName, ServiceEndpoint = subscription.ServiceEndpoint, SQLAzureServiceEndpoint = subscription.SqlAzureServiceEndpoint, SubscriptionId = subscription.SubscriptionId }; if (subscription.Certificate != null) { // Make sure certificate is in store General.AddCertificateToStore(subscription.Certificate); // Save the thumbprint for the certificate subscriptionsSubscription.Thumbprint = subscription.Certificate.Thumbprint; } return(subscriptionsSubscription); } ).ToArray() }; var parentDirectory = Directory.GetParent(subscriptionsDataFile); if (!parentDirectory.Exists) { parentDirectory.Create(); } General.SerializeXmlFile(subscriptionsXml, subscriptionsDataFile); }
private bool IsValidUrl(Subscriptions sub) { HttpClient client = new HttpClient(); try { var response = client.GetAsync(sub.Url).GetAwaiter().GetResult(); if ((int)response.StatusCode != 200) { return(false); } else { return(true); } } catch (Exception) { return(false); } }
/// <summary> /// Prepares the subscription response. /// </summary> /// <param name="subscription">The subscription.</param> /// <param name="allPlanDetails">All plan details.</param> /// <returns></returns> private SubscriptionResultExtension PrepareSubscriptionResponse(Subscriptions subscription, List <Plans> allPlanDetails) { SubscriptionResultExtension subscritpionDetail = new SubscriptionResultExtension(); subscritpionDetail.Id = subscription.AmpsubscriptionId; subscritpionDetail.SubscribeId = subscription.Id; subscritpionDetail.PlanId = string.IsNullOrEmpty(subscription.AmpplanId) ? string.Empty : subscription.AmpplanId; subscritpionDetail.Quantity = subscription.Ampquantity; subscritpionDetail.Name = subscription.Name; subscritpionDetail.SaasSubscriptionStatus = GetSubscriptionStatus(subscription.SubscriptionStatus); subscritpionDetail.IsActiveSubscription = subscription.IsActive ?? false; subscritpionDetail.CustomerName = subscription.User?.FullName; subscritpionDetail.CustomerEmailAddress = subscription.User?.EmailAddress; var existingPlanDetail = allPlanDetails.Where(s => s.PlanId == subscritpionDetail.PlanId).FirstOrDefault(); subscritpionDetail.IsMeteringSupported = existingPlanDetail != null ? (existingPlanDetail.IsmeteringSupported ?? false) : false; return(subscritpionDetail); }
public void GetSubscriptionsWithSearch(string overideSecretKey) { var subscription = CreateBasicSubscription(overideSecretKey); var request = new SubscriptionSearchRequest { customer_id = subscription.resource.data.customer.customer_id }; SubscriptionItemsResponse response; if (overideSecretKey != null) { response = new Subscriptions(overideSecretKey).Get(request); } else { response = new Subscriptions().Get(request); } Assert.IsTrue(response.IsSuccess); Assert.AreEqual(1, response.resource.data.Count()); }
public void AddSubscriber(Type messageType, QueueName destination) { Condition.Requires(messageType, "messageType").IsNotNull(); Condition.Requires(destination, "destination").IsNotNull(); SubscriptionRegistration registration; if (!Subscriptions.TryGet(messageType, out registration)) { registration = new SubscriptionRegistration(); } if (!registration.SubscriberQueueNames.Any(q => q == destination)) { registration.SubscriberQueueNames.Add(destination.Name); } Subscriptions.Put(messageType, registration); }
public IActionResult AddNewSubscription(Subscriptions subscription) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } subscription.UserID = Convert.ToInt64(User.Claims.Where(x => x.Type == "user_id").FirstOrDefault().Value); ResultObject result = con.ResultObject.FromSql($"[phi].[usp_createNewSubscription] {subscription.subscriptionType},{subscription.subscriptionName},{subscription.UserID}").FirstOrDefault(); return(StatusCode(200, result)); } catch (Exception e) { return(StatusCode(500, e.Message)); } }
private void AddSubscription(long APartnerKey, string APublicationCode, string AConsentCode) { TVerificationResultCollection VerificationResult; List <string> Subscriptions; List <string> PartnerTypes; string DefaultEmailAddress; string DefaultPhoneMobile; string DefaultPhoneLandline; PartnerEditTDS MainDS = TSimplePartnerEditWebConnector.GetPartnerDetails(APartnerKey, out Subscriptions, out PartnerTypes, out DefaultEmailAddress, out DefaultPhoneMobile, out DefaultPhoneLandline); if (!Subscriptions.Contains(APublicationCode)) { Subscriptions.Add(APublicationCode); } string EmailChangeObject = "{\"PartnerKey\":\"" + APartnerKey + "\",\"Type\":\"email address\"," + "\"Value\":\"" + DefaultEmailAddress + "\",\"ChannelCode\":\"PHONE\",\"Permissions\":\"" + AConsentCode + "\"," + "\"ConsentDate\":\"" + DateTime.Today.ToString("yyyy-MM-dd") + "\"," + "\"Valid\":true}"; bool SendMail = true; bool result = TSimplePartnerEditWebConnector.SavePartner(MainDS, Subscriptions, PartnerTypes, new List <string>() { EmailChangeObject }, SendMail, DefaultEmailAddress, DefaultPhoneMobile, DefaultPhoneLandline, out VerificationResult); Assert.IsTrue(result, "AddSubscription.SavePartner"); }
private void HandleEmpty() { Image image = new Image() { Path = "img/establishments/none/empty.jpg" }; List <Image> images = new List <Image>(); images.Add(image); if (Subscriptions.Count == 0) { Establishment establishment = new Establishment() { Name = "Je hebt nog geen abonnementen", Images = images }; Subscriptions.Add(establishment); } if (Promotions.Count == 0) { Promotion p = new Promotion() { Name = "Er zijn nog geen promoties toegevoegd", Images = images }; Promotions.Add(p); } if (Events.Count == 0) { Event e = new Event() { Name = "Er zijn nog geen events toegevoegd", Images = images }; Events.Add(e); } }
public ActionResult SubscriptionsAdd(BackEndSubscriptionsAdd backEndSubscriptionsAdd) { if (ModelState.IsValidOrRefresh()) { Subscriptions subscriptions = new Subscriptions(); int? result = subscriptions.Add(backEndSubscriptionsAdd.Email, backEndSubscriptionsAdd.Password, backEndSubscriptionsAdd.FirstName, backEndSubscriptionsAdd.LastName, backEndSubscriptionsAdd.Birthdate.ToDateTime(), backEndSubscriptionsAdd.PhoneNumber, backEndSubscriptionsAdd.Address, backEndSubscriptionsAdd.City, backEndSubscriptionsAdd.PostCode, backEndSubscriptionsAdd.CountryCode, backEndSubscriptionsAdd.SubscriptionStatusId, backEndSubscriptionsAdd.WantsNewsletter, DateTime.Now, Request.UserHostAddress, DateTime.Now.Ticks.ToBase36() + Session.SessionID, backEndSubscriptionsAdd.Notes); switch (result) { case 0: ModelState.Clear(); backEndSubscriptionsAdd = new BackEndSubscriptionsAdd(); ModelState.AddResult(ViewData, ModelStateResult.Success, Resources.Strings.ItemSuccessfullyAdded); break; case 2: ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.EmailAlreadyExists); break; default: ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.UnexpectedError); break; } } return(View(backEndSubscriptionsAdd)); }
public async Task SupervisionStrategy_Decider_on_Producer_Upstream_should_work() { var topic = CreateTopic(1); var group = CreateGroup(1); var topicPartition = new TopicPartition(topic, 0); var callCount = 0; // create a custom Decider with a "Restart" directive in the event of DivideByZeroException Directive Decider(Exception cause) { callCount++; return(cause is DivideByZeroException ? Directive.Restart : Directive.Stop); } var consumerSettings = CreateConsumerSettings <string>(group); var numbers = Source.From(new [] { 9, 8, 7, 6, 0, 5, 4, 3, 2, 1 }); await numbers // a DivideByZeroException will be thrown here, and since this happens upstream of the producer sink, // the whole stream got restarted when the exception happened, and the offending message will be ignored. // All the messages prior and after the exception are sent to the Kafka producer. .Via(Flow.Create <int>().Select(x => $"1/{x} is {1/x} w/ integer division")) .WithAttributes(ActorAttributes.CreateSupervisionStrategy(Decider)) .Select(elem => new ProducerRecord <Null, string>(topicPartition, elem)) .RunWith(KafkaProducer.PlainSink(ProducerSettings), Materializer); var(_, probe) = KafkaConsumer .PlainSource(consumerSettings, Subscriptions.Assignment(topicPartition)) .Select(c => c.Message.Value) .ToMaterialized(this.SinkProbe <string>(), Keep.Both) .Run(Materializer); probe.Request(10); for (var i = 0; i < 9; i++) { Log.Info(probe.ExpectNext(TimeSpan.FromSeconds(10))); } probe.Cancel(); callCount.Should().BeGreaterThan(0); }
public void Subscribe(NatsSubscription natsSubscription) { if (Subscriptions.ContainsKey(natsSubscription)) { return; } Logger.Info($"{nameof(Subscribe)}: {natsSubscription.Subject}"); List <IAsyncSubscription> subs = new List <IAsyncSubscription>(); foreach (var conn in ConnectionsByName.Values) { IAsyncSubscription sub = conn.SubscribeAsync(natsSubscription.Subject, OnMessage); subs.Add(sub); } Subscriptions[natsSubscription] = subs; natsSubscription.Subscribed = subs.Any(); Subscribed?.Invoke(natsSubscription); }
/// <summary> /// Configures a topic subscription. /// </summary> /// <typeparam name="T">The type of the message to subscribe to.</typeparam> /// <param name="topicNameOverride">The name of the topic that this queue will be subscribed to. Overrides the default set by the <see cref="ITopicNamingConvention"/>.</param> /// <param name="configure">A delegate to a method to use to configure a topic subscription.</param> /// <returns> /// The current <see cref="SubscriptionsBuilder"/>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="configure"/> is <see langword="null"/>. /// </exception> public SubscriptionsBuilder ForTopic <T>(string topicNameOverride, Action <TopicSubscriptionBuilder <T> > configure) where T : Message { if (configure == null) { throw new ArgumentNullException(nameof(configure)); } if (topicNameOverride == null) { throw new ArgumentNullException(nameof(topicNameOverride)); } var builder = new TopicSubscriptionBuilder <T>().WithTopicName(topicNameOverride); configure(builder); Subscriptions.Add(builder); return(this); }
public ActionResult editSubscription(FormCollection fc) { int Id = int.Parse(fc["subID"].ToString()); int membershipID = int.Parse(fc["membership"]); Subscriptions sb = new Subscriptions(); sb.Id = Id; sb.MembershipID = membershipID; bool flag = subs.UpdateSubscriptions(sb); if (flag) { ViewBag.Message = "Membership Updated Successfully"; } else { ViewBag.Message = "Something went wrong !!! "; } return(RedirectToAction("Subscriptions")); }
/// <summary> /// Adds/Update partner subscriptions. /// </summary> /// <param name="subscriptionDetail">The subscription detail.</param> public int AddUpdatePartnerSubscriptions(SaasKitModels.SubscriptionResult subscriptionDetail) { var isActive = GetSubscriptionStateFromStatus(Convert.ToString(subscriptionDetail.SaasSubscriptionStatus)); Subscriptions newSubscription = new Subscriptions() { Id = 0, AmpplanId = subscriptionDetail.PlanId, Ampquantity = subscriptionDetail.Quantity, AmpsubscriptionId = subscriptionDetail.Id, CreateBy = CurrentUserId, CreateDate = DateTime.Now, IsActive = isActive, ModifyDate = DateTime.Now, Name = subscriptionDetail.Name, SubscriptionStatus = Convert.ToString(subscriptionDetail.SaasSubscriptionStatus), UserId = CurrentUserId, }; return(SubscriptionRepository.Add(newSubscription)); }
private async Task ExecuteMessages(Subscriptions subscriptionsClient, int index, TriggeredFunctionData messages, IEnumerable <string> ackIds, IDisposable logScope, CancellationToken cancellationToken) { int bucketIndex = 0; if (messages != null && ackIds != null && ackIds.Any()) { logger.LogInformation($"Fetch {ackIds.Count()} items for bucket #{++bucketIndex}"); var functionResult = await executor.TryExecuteAsync(messages, cancellationToken); if (functionResult.Succeeded) { await AcknowledgeAsync(subscriptionsClient, ackIds, cancellationToken); } else { logger.Log(Microsoft.Extensions.Logging.LogLevel.Error, new Microsoft.Extensions.Logging.EventId(index, "TryExecuteAsync"), logScope, functionResult.Exception, null); } } }
public async Task SubscribeToChunk(ChunkKey key) { if (Subscriptions.ContainsKey(key)) { return; } var channel = OutgoingChannel;//copy to local for closure; var chunkHandlerSubscription = await BattleHandler.GetChunkHandlerAndSubscribeAsync(key, (chunkKey, update) => OnChunkUpdateAsync(key, update, channel)); if (Subscriptions.TryAdd(key, chunkHandlerSubscription)) { await SendChunkStateAsync(key, chunkHandlerSubscription); } else { chunkHandlerSubscription.Dispose(); throw new InvalidOperationException("Duplicate subscription is detected."); } }
public static string SubscribeToTicket(RestCommand command, int ticketIDOrNumber, int userId) { TicketsViewItem ticket = TicketsView.GetTicketsViewItemByIdOrNumber(command.LoginUser, ticketIDOrNumber); if (ticket == null || ticket.OrganizationID != command.Organization.OrganizationID) { throw new RestException(HttpStatusCode.Unauthorized); } UsersViewItem subscribingUser = UsersView.GetUsersViewItem(command.LoginUser, userId); if (subscribingUser == null || subscribingUser.OrganizationID != command.Organization.OrganizationID) { throw new RestException(HttpStatusCode.Unauthorized); } Subscriptions.AddSubscription(command.LoginUser, userId, ReferenceType.Tickets, ticket.TicketID); return(ticket.GetXml("Ticket", true)); }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public override void Dispose() { #if DEBUG GC.SuppressFinalize(this); #endif foreach (var observeChangesAndEvictItemsFromCacheForDatabase in observeChangesAndEvictItemsFromCacheForDatabases) { observeChangesAndEvictItemsFromCacheForDatabase.Value.Dispose(); } var tasks = new List <Task>(); foreach (var databaseChange in databaseChanges) { var remoteDatabaseChanges = databaseChange.Value as RemoteDatabaseChanges; //TODO iftah /*if (remoteDatabaseChanges != null) * { * tasks.Add(remoteDatabaseChanges.DisposeAsync()); * } * else * { * using (databaseChange.Value as IDisposable) { } * }*/ } // try to wait until all the async disposables are completed Task.WaitAll(tasks.ToArray(), TimeSpan.FromSeconds(3)); // if this is still going, we continue with disposal, it is for graceful shutdown only, anyway //return unused hilo keys AsyncHelpers.RunSync(() => _asyncMultiDbHiLo?.ReturnUnusedRange()); Subscriptions?.Dispose(); AsyncSubscriptions?.Dispose(); WasDisposed = true; AfterDispose?.Invoke(this, EventArgs.Empty); }
public void Ask_Adds1Limit_With1Order_When1LimitExists_ButPriceGreaterThanExistingLimit() { // Arrange. var sub = new Subscription { Owned = 5, UserId = _userId1 }; Subscriptions.Add(sub.UserId, sub); // Act. Ask(_userId1, 2, 1); // Assert. var order = new Order { Id = 1, Shares = 1, Subscription = new Subscription { Owned = 5, UserId = _userId1 } }; var limit = new Limit { AskHead = order, Price = 2 * ScaleFactor }; order.ParentLimit = limit; Assert.AreEqual(2, Limits.Count); Assert.AreEqual(1, Orders.Count); Assert.AreEqual(1, Subscriptions.Count); CollectionAssert.AreEqual(new Limit[] { new Limit { Price = 1 * ScaleFactor }, limit }, Limits, _limitTestComparer); CollectionAssert.AreEqual(new Order[] { order }, (ICollection)Orders.Values, _orderTestComparer); CollectionAssert.AreEqual(new Subscription[] { order.Subscription }, (ICollection)Subscriptions.Values, _subscriptionTestComparer); }
public Response Create(NewSubscriptions subscription) { Response response = new Response(); try { using (IDbConnection conn = GetConnection()) { var exists = conn.GetList <Subscriptions>("Where CustomerId = ?CustomerId and ProductId = ?ProductId", subscription).ToList(); if (exists.Count > 0) { response.Status = false; response.Description = "Record exists"; return(response); } var customers = conn.Get <Customers>(subscription.CustomerId); var products = conn.Get <Products>(subscription.ProductId); var frequencies = conn.Get <Frequencies>(subscription.FrequencyId); Subscriptions sub = new Subscriptions() { CustomerId = subscription.CustomerId, CustomerName = customers.FullName, ProductId = subscription.ProductId, ProductName = products.ProductName, Quantity = subscription.Quantity, Status = true, FrequencyId = subscription.FrequencyId, Frequency = frequencies.Frequency }; conn.Insert(sub); response.Status = true; response.Description = "Record saved"; } } catch (Exception ex) { response.Description = ex.Message; response.Status = false; } return(response); }
public IObservable <IEnumerable <string> > Listen() { CreateStoresIfNotExistsAsync().Wait(); var stream = Observable.Create <IEnumerable <string> >(obs => { var factory = new SampleObserverFactory(obs); var processor = new ChangeFeedProcessorBuilder() .WithFeedCollection(new DocumentCollectionInfo { Uri = CosmosUri, MasterKey = CosmosKey, DatabaseName = DatabaseName, CollectionName = MonitoredCollection }) .WithLeaseCollection(new DocumentCollectionInfo { Uri = CosmosUri, MasterKey = CosmosKey, DatabaseName = DatabaseName, CollectionName = LeaseCollection }) .WithHostName("SampleHost") .WithObserverFactory(factory) /* the explicit checkpoint is important because otherwise when the stream blows, it still checkpoints, and we 'lose' the message */ .WithProcessorOptions(new ChangeFeedProcessorOptions { MaxItemCount = 2, CheckpointFrequency = new CheckpointFrequency { ExplicitCheckpoint = true } }) .BuildAsync().Result; processor.StartAsync().Wait(); var sub = Tuple.Create(obs, processor); Subscriptions.Add(sub); return(Disposable.Create(() => { // the ConfigureAwait(false) is *critical* to ensure the processor stops! processor.StopAsync().ConfigureAwait(false).AsTask().Wait(); Subscriptions.Remove(sub); Log.Warning("Disposable run for subscription"); })); }); Log.Information("Subscription created"); return(stream); }
public SubscriptionResponse Update(Subscriptions subscription) { SubscriptionResponse response = new SubscriptionResponse(); try { using (IDbConnection conn = GetConnection()) { var customers = conn.Get <Customers>(subscription.CustomerId); var products = conn.Get <Products>(subscription.ProductId); var frequencies = conn.Get <Frequencies>(subscription.FrequencyId); int MerchantId = subscription.MerchantId == 0 ? 1 : subscription.MerchantId; var merchants = conn.Get <Merchants>(MerchantId); Subscriptions sub = new Subscriptions() { CustomerId = subscription.CustomerId, CustomerName = customers.FullName, ProductId = subscription.ProductId, ProductName = products.ProductName, Quantity = subscription.Quantity, Status = true, FrequencyId = subscription.FrequencyId, Frequency = frequencies.Frequency, SubscriptionId = subscription.SubscriptionId, MerchantId = MerchantId, MerchantName = merchants.MerchantName }; conn.Update(sub); response.Status = true; response.Description = "Record updated"; response.Subscription = sub; } } catch (Exception ex) { response.Description = ex.Message; response.Status = false; } return(response); }
public ActionResult Index(FrontEndCmsPage page, FrontEndSubscriptionProfile frontEndSubscriptionProfile) { if (ModelState.IsValidOrRefresh()) { Subscriptions subscriptions = new Subscriptions(); int? result = subscriptions.EditProfile(FrontEndSessions.CurrentSubscription.Email, frontEndSubscriptionProfile.FirstName, frontEndSubscriptionProfile.LastName, frontEndSubscriptionProfile.Birthdate.ToDateTime(), frontEndSubscriptionProfile.PhoneNumber, frontEndSubscriptionProfile.Address, frontEndSubscriptionProfile.City, frontEndSubscriptionProfile.PostCode, frontEndSubscriptionProfile.CountryCode, frontEndSubscriptionProfile.WantsNewsletter); switch (result) { case 0: FrontEndSessions.CurrentSubscription = subscriptions.GetSubscriptionByEmail(FrontEndSessions.CurrentSubscription.Email); ModelState.AddResult(ViewData, ModelStateResult.Success, Resources.Strings_Subscription.ProfileEditSuccess); ViewData.IsFormVisible(false); break; case 2: ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.ItemDoesNotExist); ViewData.IsFormVisible(false); break; case 3: ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.EmailAlreadyExists); break; default: ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.UnexpectedError); break; } } return(View(frontEndSubscriptionProfile)); }
private void button_SaveAdd_Click(object sender, EventArgs e) { if (!CheckFields()) { return; } try { using (var db = new SportEntities(SportProgramSettings.ConnectionString)) { DateTime startDate = new DateTime(Years[box_StartDateYear.SelectedIndex], box_StartDateMonth.SelectedIndex, int.Parse(box_StartDateDay.Text)); DateTime formDate = new DateTime(Years[box_StartDateYear.SelectedIndex], box_StartDateMonth.SelectedIndex, int.Parse(box_StartDateDay.Text)); List <Subscriptions> subs = new List <Subscriptions>(); for (int i = 0; i < SportProgramSettings.Subscribe_DurationList[box_Duration.SelectedIndex]; i++) { Subscriptions sub = new Subscriptions { StudentId = CurrentStudentId, GroupId = CurrentGroupId, BuyTime = DateTime.Now, IsUnlimited = radioButton_TypeUnlim.Checked, SubHoursMax = (int?)numeric_Hours.Value, SubHoursLeft = (int)numeric_Hours.Value, DateStart = startDate.AddDays(0), DateEnd = formDate.AddMonths(i + 1).AddDays(-1) }; subs.Add(sub); startDate = sub.DateEnd.AddDays(1); } db.Subscriptions.AddRange(subs); db.SaveChanges(); IsNewAdded = true; this.Close(); } } catch (Exception ex) { MessageBox.Show("Произошла ошибка при сохранении данных. Exception: " + ex); } }
public void SaveSubscriptions(string subscriptionsDataFile) { if (subscriptionsDataFile == null) { throw new ArgumentNullException("subscriptionsDataFile"); } var subscriptionsXml = new Subscriptions { Subscription = Subscriptions.Values.Select(subscription => { var subscriptionsSubscription = new SubscriptionsSubscription { CurrentStorageAccount = subscription.CurrentStorageAccount, name = subscription.SubscriptionName, ServiceEndpoint = subscription.ServiceEndpoint, SQLAzureServiceEndpoint = subscription.SqlAzureServiceEndpoint, SubscriptionId = subscription.SubscriptionId }; if (subscription.Certificate != null) { // Make sure certificate is in store General.AddCertificateToStore(subscription.Certificate); // Save the thumbprint for the certificate subscriptionsSubscription.Thumbprint = subscription.Certificate.Thumbprint; } return subscriptionsSubscription; } ).ToArray() }; var parentDirectory = Directory.GetParent(subscriptionsDataFile); if (!parentDirectory.Exists) { parentDirectory.Create(); } General.SerializeXmlFile(subscriptionsXml, subscriptionsDataFile); }