public JsonResult GetSubscriptionDetail(int Id) { SubscriptionModel subscriptionModel = new SubscriptionModel(); SubscriptionHelper subscriptionHelper = new SubscriptionHelper(); subscriptionModel = subscriptionHelper.GetByID(Id); subscriptionModel.SubscriptionWithValidity = AppLogic.CalculateSubscriptionExpiryDate(DateTime.UtcNow, subscriptionModel.Validity).ToString("dd MMM yyyy"); return(Json(subscriptionModel, JsonRequestBehavior.AllowGet)); }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { actual.OnSubscribe(this); s.Request(long.MaxValue); } }
/// <inheritdoc/> public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { actual.OnSubscribe(this); OnStart(); } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { SubscribeActual(); s.Request(prefetch); } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { qs = s as IQueueSubscription <T>; subscribeActual(); } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.SetOnce(ref main, s)) { actual.OnSubscribe(this); s.Request(long.MaxValue); } }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (!BackpressureHelper.PostCompleteRequest(ref requested, n, actual, queue, ref cancelled)) { s.Request(n); } } }
private ActionResult BindSubscription() { SubscriptionHelper helper = new SubscriptionHelper(); SubscriptionModel subscriptionModel = new SubscriptionModel(); var List = helper.GetAll().ToList(); ActiveList = List.Where(x => x.Status == 1).ToList(); InActiveList = List.Where(x => x.Status == 0).ToList(); return(View(Tuple.Create(ActiveList, InActiveList, subscriptionModel))); }
public void OnError(Exception cause) { if (!SubscriptionHelper.IsCancelled(ref upstream)) { item = default(T); error = cause; SubscriptionHelper.LazySetCancel(ref upstream); } latch.Signal(); }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.SetOnce(ref this.s, s)) { worker.SchedulePeriodically(StartWindow, timeskip, timeskip); worker.SchedulePeriodically(EndWindow, timespan, timespan); s.Request(long.MaxValue); } }
public void OnNext(U value) { if (!once) { once = true; SubscriptionHelper.Terminate(ref other); DoSubscribe(); } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.SetOnce(ref this.s, s)) { Emit(window); Set(scheduler.SchedulePeriodicallyDirect(this.Run, time, time)); s.Request(long.MaxValue); } }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (Interlocked.CompareExchange(ref once, 1, 0) == 0) { var d = scheduler.Schedule(Run); DisposableHelper.Replace(ref cancel, d); } } }
public override void OnNext(T element) { if (!SubscriptionHelper.IsCancelled(ref upstream)) { hasItem = true; item = element; upstream.Cancel(); SubscriptionHelper.LazySetCancel(ref upstream); latch.Signal(); } }
/// <summary> /// Atomically set the new ISubscription once on the current field and request /// any accumulated value. /// </summary> /// <param name="current">The current ISubscription field</param> /// <param name="requested">The requested amount field</param> /// <param name="s">The new ISubscription to set once</param> public static void DeferredSetOnce(ref ISubscription current, ref long requested, ISubscription s) { if (SubscriptionHelper.SetOnce(ref current, s)) { long r = Interlocked.Exchange(ref requested, 0L); if (r != 0L) { s.Request(r); } } }
public void Set(int index, ISubscription s) { if (index == 0) { SubscriptionHelper.SetOnce(ref first, s); } else { SubscriptionHelper.SetOnce(ref second, s); } }
public void Cancel() { Volatile.Write(ref cancelled, true); SubscriptionHelper.Cancel(ref s); if (QueueDrainHelper.Enter(ref wip)) { actual = null; queue.Clear(); } }
public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.Validate(ref upstream, subscription)) { if (subscription is IQueueSubscription <T> qs) { this.qs = qs; } OnStart(subscription); } }
public void ResubscribeTest() { var subHelper = new SubscriptionHelper(); subHelper.SubHandler.Subscribe(subHelper.BuildSubReq(SubReqs.Button1)); Assert.That(subHelper.DeviceEmptyResults.Count, Is.EqualTo(0)); subHelper.SubHandler.Subscribe(subHelper.BuildSubReq(SubReqs.Button1)); Assert.That(subHelper.DeviceEmptyResults.Count, Is.EqualTo(0)); subHelper.SubHandler.Unsubscribe(subHelper.BuildSubReq(SubReqs.Button1)); Assert.That(subHelper.DeviceEmptyResults.Count, Is.EqualTo(1)); }
public bool MoveNext() { if (SubscriptionHelper.IsCancelled(ref upstream)) { return(false); } if (Volatile.Read(ref wip) == 0) { Monitor.Enter(this); try { for (;;) { if (SubscriptionHelper.IsCancelled(ref upstream)) { return(false); } if (Volatile.Read(ref wip) != 0) { break; } Monitor.Wait(this); } } finally { Monitor.Exit(this); } } if (queue.Poll(out current)) { int c = consumed + 1; if (c == limit) { consumed = 0; upstream.Request(c); } else { consumed = c; } Interlocked.Decrement(ref wip); return(true); } var ex = error; if (ex != null) { throw ex; } return(false); }
internal void Request(int index, long n) { if (SubscriptionHelper.Validate(n)) { var rs = requests; BackpressureHelper.GetAndAddCap(ref rs[index], n); if (Volatile.Read(ref subscriberCount) == rs.Length) { Drain(); } } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.SetOnce(ref this.other, s)) { s.Request(long.MaxValue); } else { s.Cancel(); OnSubscribeHelper.ReportSubscriptionSet(); } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { if (BeforeSubscribe()) { actual.OnSubscribe(this); AfterSubscribe(); } } }
/// <inheritdoc/> public void OnSubscribe(ISubscription s) { subscriptions++; if (SubscriptionHelper.SetOnce(ref this.s, s)) { var qs = s as IQueueSubscription <T>; this.qs = qs; if (qs != null) { if (requestFusionMode != FuseableHelper.NONE) { int m = qs.RequestFusion(requestFusionMode); establishedFusionMode = m; if (m == FuseableHelper.SYNC) { try { try { T v; while (qs.Poll(out v)) { values.Add(v); } completions++; Volatile.Write(ref valueCount, values.Count); Volatile.Write(ref lastTimestamp, DateTimeOffset.UtcNow.UtcMillis()); } catch (Exception ex) { errors.Add(ex); } } finally { cde.Signal(); } return; } } } long r = Interlocked.Exchange(ref requested, 0L); if (r != 0L) { s.Request(r); } } }
/// <summary> /// Invoked after calling IPublisher.Subscribe(ISubscriber). /// No data will start flowing until ISubscription.Request(long) /// is invoked. /// It is the responsibility of this ISubscriber instance to call /// Reactive.Streams.ISubscription.Request(System.Int64) whenever more data is wanted. /// The IPublisher will send notifications only in response to /// Reactive.Streams.ISubscription.Request(System.Int64). /// </summary> /// <param name="subscription">ISubscription that allows requesting data via ISubscription.Request(long)</param> public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.SetOnce(ref upstream, subscription, crash: false)) { if (manager.HasTerminated) { subscription.Cancel(); } else { subscription.Request(long.MaxValue); } } }
public virtual void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { qs = s as IQueueSubscription <T>; if (BeforeSubscribe()) { actual.OnSubscribe(this); AfterSubscribe(); } } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.SetOnce(ref this.s, s)) { if (maxConcurrency == int.MaxValue) { s.Request(long.MaxValue); } else { s.Request(maxConcurrency); } } }
/// <summary> /// Invoked after calling IPublisher.Subscribe(ISubscriber). /// No data will start flowing until ISubscription.Request(long) /// is invoked. /// It is the responsibility of this ISubscriber instance to call /// Reactive.Streams.ISubscription.Request(System.Int64) whenever more data is wanted. /// The IPublisher will send notifications only in response to /// Reactive.Streams.ISubscription.Request(System.Int64). /// </summary> /// <param name="subscription">ISubscription that allows requesting data via ISubscription.Request(long)</param> public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.SetOnce(ref upstream, subscription, false)) { if (Volatile.Read(ref subscribers) != Terminated) { subscription.Request(long.MaxValue); } else { subscription.Cancel(); } } }
public void Subscribe(IPublisher <T>[] others) { var a = subscribers; int n = this.n; for (int i = 0; i < n; i++) { if (SubscriptionHelper.IsCancelled(ref s)) { return; } others[i].Subscribe((InnerSubscriber)a[i]); } }
/// <summary> /// Invoked after calling IPublisher.Subscribe(ISubscriber). /// No data will start flowing until ISubscription.Request(long) /// is invoked. /// It is the responsibility of this ISubscriber instance to call /// Reactive.Streams.ISubscription.Request(System.Int64) whenever more data is wanted. /// The IPublisher will send notifications only in response to /// Reactive.Streams.ISubscription.Request(System.Int64). /// </summary> /// <param name="subscription">ISubscription that allows requesting data via ISubscription.Request(long)</param> public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.SetOnce(ref upstream, subscription, false)) { if (Volatile.Read(ref done) || Volatile.Read(ref cancelled)) { subscription.Cancel(); } else { subscription.Request(long.MaxValue); } } }