private async void ExecuteSubscriptionCommand(int id)
{
SubscriptionItem value = SubscriptionItems.First(x => x.Id == id);
if (value.IsSubscribed)
{
UserContentProvider user = new UserContentProvider();
DiscoverSubscribeResult reuslt = await user.Unsubscribe(id, GlobalValue.CurrentUserContext.UserId, GlobalValue.CurrentUserContext.MobileToken);
if (reuslt.Error == null || reuslt.Error.Count == 0)
{
value.IsSubscribed = false;
}
}
else
{
UserContentProvider user = new UserContentProvider();
DiscoverSubscribeResult reuslt = await user.Subscribe(id, GlobalValue.CurrentUserContext.UserId, GlobalValue.CurrentUserContext.MobileToken);
if (reuslt.Error == null || reuslt.Error.Count == 0)
{
value.IsSubscribed = true;
}
}
}
public void Initialize(SubscriptionItem itemInformation)
{
_itemInformation = itemInformation;
itemName.text = _itemInformation.name;
itemDescription.text = _itemInformation.description;
itemStatus.text = _itemInformation.status.ToUpper();
switch (itemInformation.Status)
{
case SubscriptionStatusType.None:
itemStatus.text = "Subscription not purchased";
break;
case SubscriptionStatusType.Active:
itemStatus.text = "Subscription active until";
break;
case SubscriptionStatusType.Expired:
itemStatus.text = "Subscription expired at";
break;
}
if (_itemInformation.expired_at != null && _itemInformation.Status != SubscriptionStatusType.None)
{
itemExpiration.text = UnixTimeToDateTime(_itemInformation.expired_at.Value).ToString("dd/MM/yyyy hh:mm:tt");
itemExpiration.gameObject.SetActive(true);
}
ChangeImageUrl(_itemInformation);
}
public async Task <int> ImportSubscriptionItem(SubscriptionItem item)
{
_logger.LogInformation(GetLogMessage("{SubscriptionItem}"), item.Id);
var existingItem = _itemRepository.Queryable().FirstOrDefault(x => x.Id == item.Id);
if (existingItem == null)
{
existingItem = new StripeSubscriptionItem()
{
ObjectState = ObjectState.Added,
Id = item.Id
};
}
else
{
existingItem.ObjectState = ObjectState.Modified;
}
existingItem.SubscriptionId = item.Subscription;
existingItem.PlanId = item.Plan.Id;
existingItem.IsDeleted = item.Deleted.GetValueOrDefault();
existingItem.Quantity = item.Quantity;
return(await Task.FromResult(_itemRepository.InsertOrUpdateGraph(existingItem, true)));
}
private List <SubscriptionItem> LoadSubscriptionItems(SQLiteConnection connection)
{
var result = new List <SubscriptionItem>();
using (var statement = connection.Prepare(@"SELECT ID, SORT_ID, TITLE, UNREAD_COUNT, URL, HTML_URL, ICON_URL, FIRST_ITEM_MSEC FROM SUB_ITEM;"))
{
while (statement.Step() == SQLiteResult.ROW)
{
var item = new SubscriptionItem
{
Id = (string)statement[0],
SortId = (string)statement[1],
Title = (string)statement[2],
PageTitle = (string)statement[2],
UnreadCount = (long)statement[3],
Url = (string)statement[4],
HtmlUrl = (string)statement[5],
IconUrl = (string)statement[6],
FirstItemMsec = (long)statement[7]
};
result.Add(item);
}
}
return(result);
}
private bool Subscribe(SubscriptionItem item, HttpTargetSite target)
{
bool ok = false;
WireData data = null;
BaseServiceNode serviceNode = _service.Children
.Where((IIotNode node) => string.Equals(node.Id, item.Node, StringComparison.OrdinalIgnoreCase)).FirstOrDefault()
as BaseServiceNode;
if (serviceNode != null)
{
if (string.IsNullOrEmpty(item.Data))
{
serviceNode.Subscribe(target);
ok = true;
}
else
{
data = serviceNode.GetData <WireData>(item.Data);
if (data != null)
{
data.Subscribe(target);
ok = true;
}
}
}
return(ok);
}
public void AddItem(SubscriptionItem itemInformation)
{
var newItem = Instantiate(itemPrefab, itemParent);
newItem.GetComponent <SubscriptionItemUI>().Initialize(itemInformation);
_items.Add(newItem);
}
public void IsClosedCorrectlyReflectsStateOfObject()
{
var ip = "1.1.1.1";
var port = 1883;
var eventData = "Test data";
string connectionKey = "123";
var moqSocket = new MoqSocket();
var protocol = new MqttClientProtocol(new LogCompositor(), moqSocket);
var bldr = new MqttConnectMessageBuilder
{
ClientId = "UnitTest"
};
protocol.ConnectAsync(bldr, ip, port, SocketEncryption.None, eventData);
var subscriptionItem = new SubscriptionItem
{
TopicName = "a/b/+",
QualityOfService = QualityOfService.AtMostOnce
};
var subClient = new SubscriptionClient(protocol, subscriptionItem, connectionKey);
Assert.IsTrue(subClient.IsClosed);
subClient.OnMessage(msg =>
{
Assert.IsNotNull(msg);
Assert.IsTrue(msg.MessageType == MessageType.Publish);
});
Assert.IsFalse(subClient.IsClosed);
subClient.Close();
Assert.IsTrue(subClient.IsClosed);
}
public ActionResult AddApplicationSubscription(Subscription record, FormCollection form)
{
try
{
record.Type = "Application";
record.CreatedDate = DateTime.Now;
record.State = "Active";
var application_ = form.GetValue("application_");
if ((application_ != null) && (application_.AttemptedValue != null))
{
int applicationId = Int32.Parse(application_.AttemptedValue);
SubscriptionItem item = new SubscriptionItem();
item.ApplicationId = applicationId;
record.Items = new List <SubscriptionItem>();
record.Items.Add(item);
}
CcAddSubscriptionRequest request = new CcAddSubscriptionRequest(Settings.Credentials);
request.Subscription = record;
EndPoints.CcDashboardService.AddSubscription(request);
return(RedirectToAction("Subscriptions"));
}
catch (Exception e)
{
return(ShowError(e));
}
}
public MergeResult Merge(IEnumerable<SubscriptionItem> oldItems, IEnumerable<FeedItem> newItems)
{
var items = newItems.Select(x =>
{
var item = new SubscriptionItem(Subscription)
{
Id = x.Id,
PublishDate = x.PublishDate,
LastUpdatedTime = x.LastUpdatedTime,
Summary = x.Summary,
Title = x.Title,
Categories = x.Categories
};
item.Links = x.Links.Select(y => new SubscriptionItemLink(item)
{
Length = y.Length,
MediaType = y.MediaType,
RelationshipType = y.RelationshipType,
Title = y.Title,
Uri = y.Uri
}).ToList();
return item;
});
var result = new MergeResult();
foreach (var item in items)
result.AddItem(item, ItemMergeStatus.NewItem);
return result;
}
/// <summary>
/// Gets a value indicating whether download is allowed
/// </summary>
/// <param name="subscriptionItem">Subscription item to check</param>
/// <returns>True if download is allowed; otherwise, false.</returns>
public virtual bool IsDownloadAllowed(SubscriptionItem subscriptionItem)
{
if (subscriptionItem == null)
{
return(false);
}
var subscription = subscriptionItem.Subscription;
if (subscription == null || subscription.Deleted)
{
return(false);
}
//subscription status
if (subscription.SubscriptionStatus == SubscriptionStatus.Cancelled)
{
return(false);
}
var article = subscriptionItem.Article;
if (article == null)
{
return(false);
}
//payment status
return(false);
}
public SubscriptionItemViewModel(SubscriptionItem subscriptionItem)
{
SubscriptionItemId = subscriptionItem.SubscriptionItemId;
FullUrl = subscriptionItem.FeedItem.GetFullUrl();
Title = subscriptionItem.FeedItem.Title;
PublishDate = subscriptionItem.FeedItem.PublishDate;
IsRead = subscriptionItem.IsRead;
}
private PersistenceStorage.SubscriptionItem TransformSubscriptionItem(SubscriptionItem item)
{
PersistenceStorage.SubscriptionItem item_ = new PersistenceStorage.SubscriptionItem();
item_.ID = item.Id;
item_.SubscriptionID = item.SubscriptionId;
item_.ApplicationID = item.ApplicationId;
return(item_);
}
private static SubscriptionItem TransformSubscriptionItem(PersistenceStorage.SubscriptionItem item)
{
SubscriptionItem item_ = new SubscriptionItem();
item_.Id = item.ID;
item_.SubscriptionId = item.SubscriptionID;
item_.ApplicationId = item.ApplicationID;
return(item_);
}
internal SubscriptionClient(MqttClientProtocol mqttClient, SubscriptionItem subscription, string clientUid)
{
_mqtt = mqttClient;
_mqtt.SubscribeComplete += MqttOnSubscribeComplete;
_mqtt.SendMessageComplete += MqttOnOperationComplete;
_mqtt.ConnectComplete += MqttOnConnectComplete;
_subscription = subscription;
_clientUid = clientUid;
_disposed = false;
}
/// <summary>
/// Gets a value indicating whether license download is allowed
/// </summary>
/// <param name="subscriptionItem">Subscription item to check</param>
/// <returns>True if license download is allowed; otherwise, false.</returns>
public virtual bool IsLicenseDownloadAllowed(SubscriptionItem subscriptionItem)
{
if (subscriptionItem == null)
{
return(false);
}
return(IsDownloadAllowed(subscriptionItem) &&
subscriptionItem.LicenseDownloadId.HasValue &&
subscriptionItem.LicenseDownloadId > 0);
}
public BillingSubscriptionItem(SubscriptionItem item)
{
if (item.Plan != null)
{
Name = item.Plan.Nickname;
Amount = item.Plan.Amount.GetValueOrDefault() / 100M;
Interval = item.Plan.Interval;
}
Quantity = (int)item.Quantity;
}
public BillingSubscriptionItem(SubscriptionItem item)
{
if (item.Plan != null)
{
Name = item.Plan.Nickname;
Amount = item.Plan.Amount.GetValueOrDefault() / 100M;
Interval = item.Plan.Interval;
}
Quantity = (int)item.Quantity;
SponsoredSubscriptionItem = Utilities.StaticStore.SponsoredPlans.Any(p => p.StripePlanId == item.Plan.Id);
}
/// <summary>
/// Delete an subscription item
/// </summary>
/// <param name="subscriptionItem">The subscription item</param>
public virtual void DeleteSubscriptionItem(SubscriptionItem subscriptionItem)
{
if (subscriptionItem == null)
{
throw new ArgumentNullException("subscriptionItem");
}
_subscriptionItemRepository.Delete(subscriptionItem);
//event notification
_eventPublisher.EntityDeleted(subscriptionItem);
}
private void ChangeImageUrl(SubscriptionItem itemInformation)
{
if (!string.IsNullOrEmpty(_itemInformation.image_url))
{
ImageLoader.Instance.GetImageAsync(_itemInformation.image_url, LoadImageCallback);
}
else
{
Debug.LogError($"Subscription item with sku = '{itemInformation.sku}' without image!");
loadingCircle.SetActive(false);
itemImage.sprite = null;
}
}
public string GeneratePreview(SubscriptionItem subscriptionItem)
{
var feed = new Feed
{
Title = "Vacancies",
Description = "The Find an apprenticeship service provides a list of new vacancies",
Link = new Uri("https://www.findapprenticeship.service.gov.uk/"),
Copyright = "RSS feed supplied by the Education & Skills Funding Agency"
};
var feedSerialised = feed.Serialize();
return(feedSerialised);
}
public async Task <string> Create(SubscriptionRequest subscriptionRequest, ContentType contentType)
{
var subscriptionOutput = SubscriptionOutputFactory.Create(contentType);
var subscriptionId = subscriptionRequest.SubscriptionId;
await _resultsCacheRepository.Get(subscriptionId);
var subscriptionItem = new SubscriptionItem("1");
// TODO AU Update usages
var result = subscriptionOutput.GeneratePreview(subscriptionItem);
return(result);
}
public async Task <Subscription> RefreshSubscriptionAsync(string userName, int subscriptionId)
{
var subscription = await _readerContext.Subscriptions
.Include(uf => uf.Items)
.FirstAsync(uf => uf.SubscriptionId == subscriptionId);
if (subscription.UserName != userName)
{
throw new ApplicationException("Invalid Subscription Id.");
}
// refresh feed
await refreshFeedAsync(subscription.FeedId);
// insert new subscription items
var recentFeedItems = await _readerContext
.FeedItems
.Where(fi => fi.FeedId == subscription.FeedId)
.Where(fi => !_readerContext.SubscriptionItems
.Where(ufi => ufi.SubscriptionId == subscriptionId)
.Select(ufi => ufi.FeedItemId)
.Contains(fi.FeedItemId))
.ToListAsync();
foreach (var recentFeedItem in recentFeedItems)
{
var subscriptionItem = new SubscriptionItem();
subscriptionItem.SubscriptionId = subscriptionId;
subscriptionItem.FeedItemId = recentFeedItem.FeedItemId;
subscriptionItem.IsRead = false;
_readerContext.SubscriptionItems.Add(subscriptionItem);
}
await _readerContext.SaveChangesAsync();
// re-load subscription with fresh items
subscription = await _readerContext.Subscriptions
.Include(uf => uf.Feed)
.FirstAsync(uf => uf.SubscriptionId == subscriptionId);
subscription.Items = await _readerContext.SubscriptionItems
.Include(ufi => ufi.FeedItem)
.Where(ufi => ufi.SubscriptionId == subscription.SubscriptionId)
.OrderByDescending(ufi => ufi.FeedItemId)
.Take(PAGE_ROWS)
.ToListAsync();
return(subscription);
}
public void OnMessageCallbackGetsCalledWithWildcardTopics1()
{
var are = new AutoResetEvent(false);
var ip = "1.1.1.1";
var port = 1883;
var eventData = "Test data";
string connectionKey = "123";
var moqSocket = new MoqSocket();
var protocol = new MqttClientProtocol(new LogCompositor(), moqSocket);
var bldr = new MqttConnectMessageBuilder
{
ClientId = "UnitTest"
};
protocol.ConnectAsync(bldr, ip, port, SocketEncryption.None, eventData);
var subscriptionItem = new SubscriptionItem
{
TopicName = "a/b/+",
QualityOfService = QualityOfService.AtMostOnce
};
var subClient = new SubscriptionClient(protocol, subscriptionItem, connectionKey);
subClient.OnMessage(msg =>
{
Assert.IsNotNull(msg);
Assert.IsTrue(msg.MessageType == MessageType.Publish);
Assert.AreEqual(msg.Payload[0], 0x00);
Assert.AreEqual(msg.Payload[1], 0x01);
Assert.AreEqual(msg.Payload[2], 0x02);
are.Set();
});
moqSocket.ReceiveMessage(new MqttPublishMessageBuilder
{
TopicName = "a/b/c",
Payload = new byte[] { 0x00, 0x01, 0x02 }
});
if (!are.WaitOne(5000))
{
Assert.Fail("OnMessage callback not called.");
}
}
/// <summary>
/// Prepare the user agreement model
/// </summary>
/// <param name="subscriptionItem">Subscription item</param>
/// <param name="article">Article</param>
/// <returns>User agreement model</returns>
public virtual UserAgreementModel PrepareUserAgreementModel(SubscriptionItem subscriptionItem, Article article)
{
if (subscriptionItem == null)
{
throw new ArgumentNullException("subscriptionItem");
}
if (article == null)
{
throw new ArgumentNullException("article");
}
var model = new UserAgreementModel();
model.UserAgreementText = article.UserAgreementText;
model.SubscriptionItemGuid = subscriptionItem.SubscriptionItemGuid;
return(model);
}
public void OnMessageCallbackDoesNotGetCalledAfterClose()
{
var are = new AutoResetEvent(false);
var ip = "1.1.1.1";
var port = 1883;
var eventData = "Test data";
string connectionKey = "123";
var moqSocket = new MoqSocket();
var protocol = new MqttClientProtocol(new LogCompositor(), moqSocket);
var bldr = new MqttConnectMessageBuilder
{
ClientId = "UnitTest"
};
protocol.ConnectAsync(bldr, ip, port, SocketEncryption.None, eventData);
var subscriptionItem = new SubscriptionItem
{
TopicName = "a/b/c",
QualityOfService = QualityOfService.AtMostOnce
};
var subClient = new SubscriptionClient(protocol, subscriptionItem, connectionKey);
subClient.OnMessage(msg =>
{
Assert.Fail("OnMessage callback was called after Close call.");
are.Set();
});
subClient.Close();
moqSocket.ReceiveMessage(new MqttPublishMessageBuilder
{
TopicName = "a/b/c",
Payload = new byte[] { 0x00, 0x01, 0x02 }
});
are.WaitOne(3000);
}
private void ReadPayload()
{
lock (_msg.SyncLock)
{
if (!_msg.PayloadRead)
{
int pos = ReadVariableHeader();
while (pos < _msg.MsgBuffer.Length)
{
var subscription = new SubscriptionItem
{
TopicName = Frame.DecodeString(_msg.MsgBuffer, ref pos),
QualityOfService = (QualityOfService)_msg.MsgBuffer[pos++]
};
_subscriptionItems.Add(subscription);
}
_msg.PayloadRead = true;
}
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
// Create a SubscriptionClient instance to track the subscription, if not already created
if (_subClient == null)
{
var subscription = new SubscriptionItem
{
TopicName = App.Instance.XivelyFeedPath,
QualityOfService = QualityOfService.AtMostOnce
};
_subClient = App.Instance.MqttClient.CreateSubscription(subscription);
}
try
{
// Apply a callback to the OnMessage method
_subClient.OnMessage(msg =>
{
string temp;
string humid;
ParseTempAndHumid(msg.StringPayload, out temp, out humid);
Dispatcher.BeginInvoke(() =>
{
TempTitle.Text = "Temperature (C) " + temp;
HumidTitle.Text = "Humidity (%) " + humid;
TempSlider.Value = float.Parse(temp);
HumidSlider.Value = float.Parse(humid);
});
});
}
catch (Exception ex)
{
Debug.WriteLine("ERROR: Unable to subscribe to topic '{0}: {1}", _subClient.TopicName, ex.Message);
}
}
private void SubscribeButton_OnClick(object sender, RoutedEventArgs e)
{
try
{
if (!_subscriptions.ContainsKey(PublishTopic.Text))
{
var subscription = new SubscriptionItem
{
QualityOfService = QualityOfService.ExactlyOnce,
TopicName = PublishTopic.Text
};
SubscriptionClient subClient = App.Instance.MqttClient.CreateSubscription(subscription);
_subscriptions.Add(PublishTopic.Text, subClient);
subClient.OnMessage(MqttClientOnPublishReceived);
}
AppendLogMessage(MessageLevel.Info, "Successfully subscribed to topic.");
}
catch (Exception ex)
{
AppendLogMessage(MessageLevel.Error, "ERROR: Subscribe failed with error: " + ex.Message);
}
}
public static void RequirementInventoryUpdate(ClientContext context, ReqItemcollection reqItemcollection, SubscriptionItem subscriptionItem, NetworkCredential networkCredential)
{
try
{
context.Credentials = networkCredential;
List olistReq = context.Web.Lists.GetByTitle(CommonVariables.RequirementListTitle);
var count = reqItemcollection.reqitems.Count;
var maxChunkSize = 100;
var shouldRun = true;
var start = 0;
var chunkSize = count < maxChunkSize ? count : maxChunkSize;
var end = start + chunkSize < count ? start + chunkSize : count;
context.RequestTimeout = -1;
while (shouldRun)
{
shouldRun = end == count ? false : true;
for (int i = start; i < end; i++)
{
ListItem oListItem = olistReq.GetItemById(reqItemcollection.reqitems[i].reqID);
oListItem["inventory"] = reqItemcollection.reqitems[i].invID;
oListItem["_ModerationStatus"] = 0; // Approved:0,Denied:1,Pending:2,Draft:3,Shceduled:4
oListItem.Update();
context.Load(oListItem);
}
context.ExecuteQuery();
start = end;
end = start + chunkSize < count ? start + chunkSize : count;
}
subscriptionItem.IsSuccess = 1;
}
catch (Exception ex)
{
if (ex.Message.Contains("Version conflict"))
{
for (int i = 0; i < noOfAttempts; i++)
{
Thread.Sleep(1000);
Requirement.RequirementInventoryUpdate(context, reqItemcollection, subscriptionItem, networkCredential);
if (subscriptionItem.IsSuccess == 1)
{
break;
}
}
}
Errorlogs.Log(context, new ErrorLogItem
{
ErrorMessage = ex.Message,
MethodName = "Requirement.RequirementInventoryUpdate",
StackTrace = ex.StackTrace,
SubscriptionID = subscriptionItem.ID
});
}
}
/// <summary>
/// Create a subscriber client on the specified topic.
/// </summary>
/// <param name="subscription"></param>
/// <returns></returns>
public SubscriptionClient CreateSubscription(SubscriptionItem subscription)
{
var subClient = new SubscriptionClient(_mqtt, subscription, _clientUid);
return(subClient);
}
public SubstractSubject(IPushObservable <TLeft> observable, IPushObservable <TRight> observableToRemove, IComparer <TLeft, TRight> comparer)
{
_comparer = comparer;
_leftSubscriptionItem = new SubscriptionItem <TLeft>(observable, HandlePushValueLeft, HandleCompleteLeft, PushException);
_rightSubscriptionItem = new SubscriptionItem <TRight>(observableToRemove, HandlePushValueRight, HandleCompleteRight, PushException);
}
