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);
}
}
}
