public async Task <WebhookEntity> GetWebhookEntity(WebhookEntity row)
{
TableOperation selOperation = TableOperation.Retrieve <WebhookEntity>(row.PartitionKey, row.RowKey);
TableResult result = await GetClickWebhookTable().ExecuteAsync(selOperation);
return(result.Result as WebhookEntity);
}
public async Task DeleteWebhookEntity(WebhookEntity entity)
{
var originalWebhook = await GetWebhookEntity(entity);
var deleteOperation = TableOperation.Delete(originalWebhook);
TableResult result = await GetClickWebhookTable().ExecuteAsync(deleteOperation);
}
public async Task <WebhookEntity> SaveWebhookEntity(WebhookEntity webhookEntity)
{
TableOperation insOperation = TableOperation.InsertOrMerge(webhookEntity);
TableResult result = await GetClickWebhookTable().ExecuteAsync(insOperation);
return(result.Result as WebhookEntity);
}
public async Task <WebhookEntity> UpdateWebhookEntity(WebhookEntity entity)
{
var originalWebhook = await GetWebhookEntity(entity);
originalWebhook.Url = entity.Url;
return(await SaveWebhookEntity(originalWebhook));
}
public static async Task SetWebhookAsync(this Telegram telegram, string webhookUrl)
{
var webhookRequest = new WebhookEntity()
{
Url = webhookUrl
};
var url = telegram.GetFullPathUrl("setWebhook");
var request = new ExternalRequest <ResponseAnswer <object>, WebhookEntity>()
{
Method = POST_METHOD,
PostContentType = "application/json",
PostContent = webhookRequest
};
var response = await RequestSender.Execute(DataAccessMode.Server, request, url).ConfigureAwait(false);
}
/// <summary>
/// Creates a model based on the given domain entity.
/// </summary>
/// <param name="entity">The domain entity.</param>
/// <param name="constants">The application constants.</param>
/// <returns>The domain entity as a model.</returns>
public static WebhookModel Create(WebhookEntity entity, IApplicationConstants constants)
{
if (entity == null)
{
return(null);
}
return(new WebhookModel
{
Id = entity.Id.ToString(),
CreatedDate = entity.CreatedDate,
ModifiedDate = entity.ModifiedDate,
Url = entity.Url,
ApiVersion = entity.ApiVersion,
EnabledEvents = string.IsNullOrWhiteSpace(entity.EnabledEvents) ?
Array.Empty <string>() : entity.EnabledEvents.Replace(constants.ValueSeparator, string.Empty).Split(','),
UserId = entity.UserId
});
}
/// <inheritdoc/>
protected override async Task <WebhookModel> ProtectedHandleAsync(CreateWebhookCommand request, CancellationToken cancellationToken)
{
var principal = PrincipalProvider.GetPrincipal();
if (principal == null)
{
throw new ForbiddenException("Not authenticated");
}
int webhookLimit;
if (principal.IsInRole(RoleType.Administrator))
{
webhookLimit = 0;
}
else
{
webhookLimit = apiConfiguration.Options.WebhookLimit;
}
processMutex = new Mutex(false, this.GetMethodName());
return(await processMutex.Execute(new TimeSpan(0, 0, 2), async() =>
{
if (webhookLimit > 0)
{
var count = await Context.WebhookRepository.CountAsync(
e => e.UserId == principal.Identity.Name, cancellationToken);
if (count >= webhookLimit)
{
throw new AmiException($"The webhook limit of {webhookLimit} has been reached.");
}
}
Guid guid = idGenerator.GenerateId();
string enabledEvents = request.EnabledEvents.Contains(constants.WildcardCharacter) ?
constants.WildcardCharacter.Embed(constants.ValueSeparator) :
request.EnabledEvents.ToArray().ToString(",", constants.ValueSeparator);
var entity = new WebhookEntity()
{
Id = guid,
CreatedDate = DateTime.UtcNow,
ModifiedDate = DateTime.UtcNow,
Url = request.Url,
ApiVersion = request.ApiVersion,
Secret = request.Secret,
EnabledEvents = enabledEvents,
UserId = principal.Identity.Name
};
Context.WebhookRepository.Add(entity);
await Context.SaveChangesAsync(cancellationToken);
var result = WebhookModel.Create(entity, constants);
return result;
}));
}
