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