public void SetSubscriptionPeriod(SubscriptionEntity subscriptionToAdd, string period, int monthlyPrice) { switch (period) { case "month": subscriptionToAdd.SubscriptionPeriod = "Monthly"; subscriptionToAdd.Price = monthlyPrice; subscriptionToAdd.ExpirationDate = DateTime.UtcNow.AddMonths(1); break; case "quarter": subscriptionToAdd.SubscriptionPeriod = "Quarter year"; subscriptionToAdd.Price = monthlyPrice * 3; subscriptionToAdd.ExpirationDate = DateTime.UtcNow.AddMonths(3); break; case "half": subscriptionToAdd.SubscriptionPeriod = "Half year"; subscriptionToAdd.Price = monthlyPrice * 6; subscriptionToAdd.ExpirationDate = DateTime.UtcNow.AddMonths(6); break; case "year": subscriptionToAdd.SubscriptionPeriod = "Annual"; subscriptionToAdd.Price = monthlyPrice * 12; subscriptionToAdd.ExpirationDate = DateTime.UtcNow.AddMonths(12); break; default: subscriptionToAdd.ExpirationDate = DateTime.UtcNow.AddMonths(1); break; } }
public async Task <bool> Remove(string query, ulong userId, bool isPrivate, ulong channelId, ulong guildId) { string partitionKey = GeneratePartitionKey ( userId: userId, isPrivate: isPrivate, channelId: channelId, guildId: guildId ); CloudTable subscriptionTable = CloudTableClient.GetTableReference(SubscriptionTableName); TableOperation retrieveOperation = TableOperation.Retrieve <SubscriptionEntity>(partitionKey, query); TableResult retrievedResult = await subscriptionTable.ExecuteAsync(retrieveOperation); SubscriptionEntity subscriptionEntity = (SubscriptionEntity)retrievedResult.Result; if (subscriptionEntity == null) { return(false); } else { TableOperation deleteOperation = TableOperation.Delete(subscriptionEntity); await subscriptionTable.ExecuteAsync(deleteOperation); return(true); } }
public HttpResponseMessage SaveSubscriptionInformation(SubscriptionEntity subscriptiondata) { try { var subscriptionid = _unitOfWork.SQLStringReturn("EXEC SaveSubscriptionInformation @Name,@EmailAddress", new SqlParameter[] { new SqlParameter("@Name", subscriptiondata.Name), new SqlParameter("@EmailAddress", subscriptiondata.EmailAddress), }); if (Convert.ToInt32(subscriptionid) > 0) { string AdminMail = System.Configuration.ConfigurationManager.AppSettings["ContactUsEmailId"]; string bodyAdminTemplate = System.IO.File.ReadAllText(System.Web.Hosting.HostingEnvironment.MapPath("~/EmailTemplate/AdminSubscription.html")); bodyAdminTemplate = bodyAdminTemplate.Replace("[@FullName]", subscriptiondata.Name); bodyAdminTemplate = bodyAdminTemplate.Replace("[@Email]", subscriptiondata.EmailAddress); Task Admintask = new Task(() => Email.Send(AdminMail, bodyAdminTemplate, "Subscription Request from " + subscriptiondata.Name, "", null)); Admintask.Start(); } return(Request.CreateResponse(HttpStatusCode.OK, "success!")); } catch (Exception ex) { return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message)); } }
public async Task <CompanySubscription> UpdateAsync(string userId, string subscriptionId, CompanySubscriptionUpdateOptions options) { // Get by subscription id CompanyEntity company = await _companyRepository.FindBySubscriptionAsync(subscriptionId); if (company == null) { throw new NotFoundException(string.Format("Could not find company by subscription id '{0}'", subscriptionId)); } CheckCompanyAccess(company); // Check user permissions if (!company.Users.Contains(userId)) { throw new ForbiddenException(); } // Get subscription SubscriptionEntity subscription = company.Subscriptions.First(s => s.Id == subscriptionId); if (subscription.State == (int)ResourceState.Deleted) { throw new ForbiddenException(string.Format("Subscription '{0}' is deleted", subscriptionId)); } subscription.SiteName = options.SiteName; subscription.GoogleAnalyticsId = options.GoogleAnalyticsId; await _companyRepository.UpdateAsync(company); return(_mapper.Map <SubscriptionEntity, CompanySubscription>(subscription)); }
private async Task <bool> SendMessages(SubscriptionEntity subscription, PlaybillChangeEntity[] changes) { string message = string.Join(Environment.NewLine, changes.Select(change => GetChangeDescription(subscription, change))); return(await _telegramService.SendMessageAsync(subscription.Id, message)); }
public async Task <CompanySubscription> AddAsync(string userId, CompanySubscriptionCreateOptions options) { CompanySubscription subscription = _mapper.Map <CompanySubscriptionCreateOptions, CompanySubscription>(options); // Searching for company CompanyEntity company = await _companyRepository.FindByUserAsync(userId); if (company == null) { throw new NotFoundException(string.Format("Could not find company by user '{0}'", userId)); } CheckCompanyAccess(company); // Setting defaults subscription.Id = Guid.NewGuid().ToString(); subscription.Created = DateTime.UtcNow; subscription.HasTrialClicks = true; SubscriptionEntity subscriptionEntity = _mapper.Map <CompanySubscription, SubscriptionEntity>(subscription); // Updating company company.Subscriptions.Add(subscriptionEntity); await _companyRepository.UpdateAsync(company); return(subscription); }
public async Task DeleteAsync(string userId, string subscriptionId) { // Get by subscription id CompanyEntity company = await _companyRepository.FindBySubscriptionAsync(subscriptionId); if (company == null) { throw new NotFoundException(string.Format("Could not find subscription by id '{0}'", subscriptionId)); } CheckCompanyAccess(company); // Check user permissions if (!company.Users.Contains(userId)) { throw new ForbiddenException(); } // Get subscription SubscriptionEntity subscription = company.Subscriptions.First(s => s.Id == subscriptionId); if (subscription.State == (int)ResourceState.Deleted) { throw new ForbiddenException(string.Format("Subscription '{0}' is deleted", subscriptionId)); } // Deleting subscription subscription.State = (int)ResourceState.Deleted; await _companyRepository.UpdateAsync(company); }
public async Task <bool> Subscribe(string query, ulong userId, bool isPrivate, ulong channelId, ulong guildId) { string partitionKey = GeneratePartitionKey ( userId: userId, isPrivate: isPrivate, channelId: channelId, guildId: guildId ); SubscriptionEntity subscriptionEntity = new SubscriptionEntity(partitionKey, query); subscriptionEntity.IsPrivate = isPrivate; subscriptionEntity.UserId = userId.ToString(); subscriptionEntity.ChannelId = channelId.ToString(); subscriptionEntity.GuildId = guildId.ToString(); subscriptionEntity.CacheFilled = false; TableOperation insertOperation = TableOperation.Insert(subscriptionEntity); CloudTable subscriptionTable = CloudTableClient.GetTableReference(SubscriptionTableName); await subscriptionTable.ExecuteAsync(insertOperation); return(true); }
public void LinkNewSubscription(string userId, string publisherId, string subscriptionPeriod) { var subscriptionPublisher = GetPublisherForSubscription(publisherId); var subscriptionToAdd = new SubscriptionEntity { UserId = userId, PublisherId = publisherId, IsExpired = false, IsRemoved = false }; if (_context.Subscriptions.Count() == 0) { subscriptionToAdd.Id = "1"; } else { subscriptionToAdd.Id = (Convert.ToInt32(_context.Subscriptions.ToList() .OrderByDescending(s => Convert.ToInt32(s.Id)) .ToList().First().Id) + 1).ToString(); } SetSubscriptionPeriod(subscriptionToAdd, subscriptionPeriod, subscriptionPublisher.MonthlySubscriptionPrice); PayForSubscription(userId, subscriptionToAdd.Price); _context.Subscriptions.Add(subscriptionToAdd); _context.SaveChanges(); }
public SubscriptionHandle CreateSubscription(TopicHandle topic, SubscriptionDescription subscriptionDescription, RuleDescription rule, Filter filter) { var topicEntity = Topics.Get(topic); var subscriptionEntity = new SubscriptionEntity(GetNextId(), topicEntity, subscriptionDescription); return(Subscriptions.GetOrAdd(subscriptionEntity)); }
public SubscriptionEntity Post([FromBody] SubscriptionEntity entity) { context.Subscriptions.Add(entity); context.SaveChanges(); return(entity); }
public static SubscriptionDataModel ToSubscriptionDataModel(this SubscriptionEntity entity) { return(new SubscriptionDataModel { AccessToken = entity.AccessToken, CreationTime = entity.CreationTime, TotalNotificationsPushed = entity.TotalNotificationsPushed, Username = entity.Username }); }
public static SubscriptionResponse ToSubscriptionResponse(this SubscriptionEntity entity) { return(new SubscriptionResponse { AccessToken = entity.AccessToken, CreationTime = entity.CreationTime, NumOfNotificationsPushed = entity.TotalNotificationsPushed, Username = entity.Username }); }
public object Get(int id) { SubscriptionEntity sub = context.Subscriptions.Find(id); if (null == sub) { return(NotFound()); } return(sub); }
public async Task <SubscriptionEntity> RetrieveSubscriber(CloudTable table, SubscriptionEntity subscription) { // Need to define the extra columns to retrieve var columns = new List <string>() { "Verified", "Slug", "Title" }; var result = await table.ExecuteAsync( TableOperation.Retrieve <SubscriptionEntity>(subscription.PartitionKey, subscription.RowKey, columns)); return((SubscriptionEntity)result.Result); }
public void AddUserSubscription(UserEntity user, SubscriptionEntity subscription) { user.UserSubscriptions.Add(new UserSubscriptionEntity { UserId = user.Id, User = user, SubscriptionId = subscription.Id, Subscription = subscription }); Update(user); }
private async Task SendUpdates(SubscriptionEntity subscriptionEntity, HashSet <string> newPictures) { try { if (newPictures.Count == 0) { return; } string replyString = $"Subscription Update for [{subscriptionEntity.Query}]!"; int counter = 1; foreach (string newPicture in newPictures) { replyString = $"{replyString}\n{newPicture}"; counter++; if (counter >= MaxReplyLines) { if (subscriptionEntity.IsPrivate) { IDMChannel channel = await DiscordSocketClient.GetUser(Convert.ToUInt64(subscriptionEntity.UserId)).GetOrCreateDMChannelAsync(); await channel.SendMessageAsync(replyString); } else { await DiscordSocketClient.GetGuild(Convert.ToUInt64(subscriptionEntity.GuildId)).GetTextChannel(Convert.ToUInt64(subscriptionEntity.ChannelId)).SendMessageAsync(replyString); } replyString = ""; counter = 0; } } if (!String.IsNullOrWhiteSpace(replyString)) { if (subscriptionEntity.IsPrivate) { IDMChannel channel = await DiscordSocketClient.GetUser(Convert.ToUInt64(subscriptionEntity.UserId)).GetOrCreateDMChannelAsync(); await channel.SendMessageAsync(replyString); } else { await DiscordSocketClient.GetGuild(Convert.ToUInt64(subscriptionEntity.GuildId)).GetTextChannel(Convert.ToUInt64(subscriptionEntity.ChannelId)).SendMessageAsync(replyString); } } } catch (Exception e) { Console.WriteLine(e); } }
public async Task <bool> Handle(SubscribeClientCommandRequest request, CancellationToken cancellationToken) { if (request.SubscriptionRequest == null) { throw new ArgumentNullException(nameof(request.SubscriptionRequest)); } // Сам на себя не должен подписываться if (request.SubscriptionRequest.PublisherClientId == request.SubscriptionRequest.SubscriberClientId) { throw new ArgumentException("SubscriberClientId == PublisherClientId!"); } using var dataContext = _dataContextFactory.Create(); // Может быть уже существует подписка var alreadyExists = await dataContext.Subscriptions.AnyAsync(x => x.PublisherId == request.SubscriptionRequest.PublisherClientId && x.SubscriberId == request.SubscriptionRequest.SubscriberClientId, cancellationToken); if (alreadyExists) { return(false); } // Получаем обоих одним запросом var clients = await dataContext.Clients .Where(x => x.Id == request.SubscriptionRequest.SubscriberClientId || x.Id == request.SubscriptionRequest.PublisherClientId).Take(2) .ToListAsync(cancellationToken); // Если их не 2, то таких клиентов не существует (или одного из них) if (clients == null || clients.Count != 2) { return(false); } var subscriber = clients.First(x => x.Id == request.SubscriptionRequest.SubscriberClientId); var publisher = clients.First(x => x.Id == request.SubscriptionRequest.PublisherClientId); var entity = new SubscriptionEntity { Publisher = publisher, Subscriber = subscriber }; await dataContext.AddAsync(entity, cancellationToken); await dataContext.SaveChangesAsync(cancellationToken); return(true); }
public object Delete(int id) { SubscriptionEntity sub = context.Subscriptions.Find(id); if (null == sub) { return(NotFound()); } context.Subscriptions.Remove(sub); context.SaveChanges(); return(NoContent()); }
public void When_SubscribeIsCalled_AndSubscriptionIsAlreadyAdded_Then_UninitializedEntityIsReturned() { // Setup var subscription = new SubscriptionEntity { Username = "******", AccessToken = "testtoken" }; _repository.Setup(_ => _.Add(It.IsAny <SubscriptionDataModel>())).Throws <DuplicateSubscriptionException>(); var result = _service.Subscribe(subscription); // Assert Assert.AreEqual(DateTime.MinValue, result.CreationTime); }
public static Subscription ToModel(this SubscriptionEntity source) { if (source == null) { return(null); } return(new Subscription() { Id = source.Id, ProductName = source.ProductName, InfluencedLogin = source.InfluencedLogin, Status = source.Status, Currency = source.Currency, PricePerPeriod = source.PricePerPeriod, PayPalAgreementId = source.PayPalAgreementId }); }
public object Patch(int id, [FromBody] JsonPatchDocument <SubscriptionEntity> entity) { SubscriptionEntity sub = context.Subscriptions.Find(id); if (null == sub) { return(NotFound()); } entity.ApplyTo(sub); context.Subscriptions.Update(sub); context.SaveChanges(); return(sub); }
/// <summary> /// Subscribe to an specific feed /// </summary> /// <param name="subscription"></param> public void SubscribeToFeed(SubscriptionEntity subscription) { subscriptionRepository = new SubscriptionRepository(new FeedContext()); var result = subscriptionRepository.FindBy(x => x.feedId == subscription.feedId && x.userId == subscription.userId).FirstOrDefault(); if (result != null) { subscriptionRepository.Erase(result); } else { subscriptionRepository.Add(subscription); } SyncroniceFeeds(); }
public bool CheckForSubscription(string userId, string publisherId) { bool doesExist = false; SubscriptionEntity result = new SubscriptionEntity(); try { result = _context.Subscriptions.Where(s => s.UserId == userId && s.PublisherId == publisherId && !(s.IsExpired == true || s.IsRemoved == true)).First(); } catch { } if (!string.IsNullOrEmpty(result.Id)) { doesExist = true; } return(doesExist); }
public async Task Run( [TimerTrigger("%SubscriptionInventorySchedule%")] TimerInfo timerInfo, [Table("InventorySubscription", Connection = "StorageConnectionAppSetting")] CloudTable inventorySubscription, [Queue("outqueue", Connection = "StorageConnectionAppSetting")] ICollector <string> msg, ILogger log) { log.LogInformation($"C# Timer trigger function executed at: {DateTime.UtcNow}. Next occurrence: {timerInfo.FormatNextOccurrences(1)}"); IReadOnlyList <SubscriptionDto> subscriptions = await _subscriptionInventoryService.GetSubscriptionsAsync(); foreach (SubscriptionDto sub in subscriptions) { await inventorySubscription.CreateIfNotExistsAsync(); DateTime init = DateTime.Now; SubscriptionEntity subEntity = new SubscriptionEntity() { PartitionKey = sub.SubscriptionId, RowKey = Constants.SubscriptionEntitySummaryRowKey, SubscriptionName = sub.SubscriptionName, CreatedOn = init, LastSeenOn = init }; TableOperation retrieveOperation = TableOperation.Retrieve <SubscriptionEntity>(sub.SubscriptionId, Constants.SubscriptionEntitySummaryRowKey); TableResult retrievedEntity = await inventorySubscription.ExecuteAsync(retrieveOperation); if (retrievedEntity.Result == null) { TableOperation insertOperation = TableOperation.Insert(subEntity); await inventorySubscription.ExecuteAsync(insertOperation); } else { subEntity.CreatedOn = ((SubscriptionEntity)retrievedEntity.Result).CreatedOn; TableOperation mergeOperation = TableOperation.InsertOrMerge(subEntity); await inventorySubscription.ExecuteAsync(mergeOperation); } msg.Add(sub.SubscriptionId); } }
public SubscriptionEntity Subscribe(SubscriptionEntity entity) { try { var subscriptionDataModel = entity.ToSubscriptionDataModel(); var result = _repository.Add(subscriptionDataModel); if (result != null) { return(result.ToSubscriptionEntity()); } } catch (DuplicateSubscriptionException) { return(entity); // May be log? } // Uninitialized entity returned to indicate failure return(entity); }
public void When_SubscribeIsCalled_AndRepsitoryReturnsFalse_Then_UninitializedEntityIsReturned() { // Setup var subscription = new SubscriptionEntity { Username = "******", AccessToken = "testtoken", }; _repository.Setup(_ => _.Add(It.IsAny <SubscriptionDataModel>())).Returns(new SubscriptionDataModel { Username = "******", AccessToken = "testtoken" }); var result = _service.Subscribe(subscription); // Assert Assert.AreEqual(0, result.TotalNotificationsPushed); Assert.AreEqual(DateTime.MinValue, result.CreationTime); }
public void EntityReaderWriter_Roundtrip_Subscription() { var registry = new QueryEngineRegistry(new MockQueryEngineRegistry()); var sub = new SubscriptionEntity(new Uri("io:/1"), Expression.Default(typeof(object)), null); var stream = new MemoryStream(); Write(); stream.Position = 0; var rt = Read(); Assert.AreEqual(ReactiveEntityKind.Subscription, rt.Kind); Assert.AreEqual(sub.Uri, rt.Uri); AssertEqual(sub.Expression, rt.Expression); Assert.AreEqual(sub.State, rt.State); void Write() { using var writer = new EntityWriter(stream, new SerializationPolicy(DefaultExpressionPolicy.Instance, Versioning.v1)); writer.WriteHeader(); writer.Save(sub); } ReactiveEntity Read() { using var reader = new EntityReader(stream, registry, new SerializationPolicy(DefaultExpressionPolicy.Instance, Versioning.v1)); reader.ReadHeader(); var rt = reader.Load(ReactiveEntityKind.Subscription); reader.ReadFooter(); return(rt); } }
public async Task <CompanySubscription> UpdateHasTrialClicksAsync(string subscriptionId, bool value) { CompanyEntity company = await _companyRepository.FindBySubscriptionAsync(subscriptionId); if (company == null) { throw new NotFoundException(string.Format("Could not find subscription by id {0}", subscriptionId)); } CheckCompanyAccess(company); SubscriptionEntity subscription = company.Subscriptions.First(s => s.Id == subscriptionId); if (subscription.State == (int)ResourceState.Deleted) { throw new ForbiddenException(string.Format("Subscription {0} is deleted", subscriptionId)); } await _companyRepository.SetSubscriptionHasTrialClicksAsync(subscriptionId, value); return(await GetAsync(subscriptionId)); }
public void When_SubscribeIsCalled_Then_SubscriptionIsAdded() { // Setup var subscription = new SubscriptionEntity { Username = "******", AccessToken = "testtoken" }; _repository.Setup(_ => _.Add(It.IsAny <SubscriptionDataModel>())).Returns(new SubscriptionDataModel { Username = "******", AccessToken = "testtoken", TotalNotificationsPushed = 0, CreationTime = DateTime.Now }); var result = _service.Subscribe(subscription); // Assert Assert.AreEqual(0, result.TotalNotificationsPushed); Assert.AreEqual(DateTime.Now.ToString("dd MM yyyy"), result.CreationTime.ToString("dd MM yyyy")); }