public async Task OnConfiguredAsync(App app, string id, ConfiguredIntegration configured, ConfiguredIntegration?previous,
CancellationToken ct)
{
var accountSid = AccountSidProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(accountSid))
{
return;
}
var authToken = AuthTokenProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(authToken))
{
return;
}
var phoneNumber = PhoneNumberProperty.GetNumber(configured);
if (phoneNumber == 0)
{
return;
}
try
{
var client = clientPool.GetServer(accountSid, authToken);
await PhoneNumberResource.FetchAsync(ConvertPhoneNumber(phoneNumber), client : client);
}
catch
{
throw new ValidationException(Texts.Twilio_ErrorInvalidConfig);
}
}
public async Task OnRemovedAsync(App app, string id, ConfiguredIntegration configured,
CancellationToken ct)
{
var client = GetBotClient(configured);
await client.DeleteWebhookAsync(cancellationToken : ct);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var apiIdentity = ApiIdentity.GetString(configured);
if (string.IsNullOrWhiteSpace(apiIdentity))
{
return(null);
}
var apiSecret = ApiSecret.GetString(configured);
if (string.IsNullOrWhiteSpace(apiSecret))
{
return(null);
}
return(new ThreemaSimpleMessagingSender(
serviceProvider.GetRequiredService <IHttpClientFactory>(),
apiIdentity,
apiSecret));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var projectId = ProjectIdProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(projectId))
{
return(null);
}
var credentials = CredentialsProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(credentials))
{
return(null);
}
var sendSilentIOS = SilentISOProperty.GetBoolean(configured);
var sendSilentAndroid = SilentAndroidProperty.GetBoolean(configured);
return(new FirebaseMobilePushSender(
() => messagingPool.GetMessaging(projectId, credentials),
sendSilentIOS,
sendSilentAndroid));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var accessKey = AccessKeyProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(accessKey))
{
return(null);
}
var phoneNumber = PhoneNumberProperty.GetNumber(configured);
if (phoneNumber == 0)
{
return(null);
}
var phoneNumbers = PhoneNumbersProperty.GetString(configured);
var client = clientPool.GetServer(accessKey, phoneNumber, ParsePhoneNumbers(phoneNumbers));
return(new MessageBirdSmsSender(
client,
serviceProvider.GetRequiredService <ISmsCallback>(),
serviceProvider.GetRequiredService <ISmsUrl>(),
id));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var apiKey = ApiKeyProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(apiKey))
{
return(null);
}
var fromEmail = FromEmailProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromEmail))
{
return(null);
}
var fromName = FromNameProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromName))
{
return(null);
}
return(new MailchimpEmailSender(
serviceProvider.GetRequiredService <IHttpClientFactory>(),
apiKey,
fromEmail,
fromName));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var url = HttpUrlProperty.GetString(configured);
if (url == null)
{
return(null);
}
var httpMethod = HttpMethodProperty.GetString(configured);
return(new WebhookDefinition
{
Name = NameProperty.GetString(configured),
HttpUrl = url,
HttpMethod = httpMethod ?? "POST",
SendAlways = SendAlwaysProperty.GetBoolean(configured),
SendConfirm = SendConfirmProperty.GetBoolean(configured)
});
}
return(null);
}
public async Task OnConfiguredAsync(App app, string id, ConfiguredIntegration configured, ConfiguredIntegration?previous,
CancellationToken ct)
{
var client = GetBotClient(configured);
var url = messagingUrl.MessagingWebhookUrl(app.Id, id);
await client.SetWebhookAsync(url, cancellationToken : ct);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
return(new MessageBirdSmsSender(
serviceProvider.GetRequiredService <IMessageBirdClient>(),
serviceProvider.GetRequiredService <ISmsCallback>(),
serviceProvider.GetRequiredService <ISmsUrl>(),
id));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var host = HostProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(host))
{
return(null);
}
var port = HostPortProperty.GetNumber(configured);
if (port == 0)
{
return(null);
}
var fromEmail = FromEmailProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromEmail))
{
return(null);
}
var fromName = FromNameProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromName))
{
return(null);
}
var options = new SmtpOptions
{
Username = UsernameProperty.GetString(configured),
Host = host,
HostPort = (int)port,
Password = PasswordProperty.GetString(configured)
};
return(new SmtpEmailSender(
() => serverPool.GetServer(options),
fromEmail,
fromName));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var accessToken = AccessToken.GetString(configured);
if (string.IsNullOrWhiteSpace(accessToken))
{
return(null);
}
return(new TelegramMessagingSender(
() => botClientPool.GetBotClient(accessToken),
serviceProvider.GetRequiredService <IUserStore>()));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var publicKey = ApiKeyProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(publicKey))
{
return(null);
}
var privateKey = ApiSecretProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(privateKey))
{
return(null);
}
var fromEmail = FromEmailProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromEmail))
{
return(null);
}
var fromName = FromNameProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromName))
{
return(null);
}
return(new MailjetEmailSender(
() => serverPool.GetServer(publicKey, privateKey),
fromEmail,
fromName));
}
return(null);
}
public async Task OnConfiguredAsync(App app, string id, ConfiguredIntegration configured, ConfiguredIntegration?previous,
CancellationToken ct)
{
var fromEmails = GetEmailAddresses(configured).ToList();
if (fromEmails.Count == 0)
{
return;
}
// Ensure that the email address is not used by another app.
await ValidateEmailAddressesAsync(app, fromEmails, ct);
var previousEmails = GetEmailAddresses(previous).ToList();
if (previousEmails.SetEquals(fromEmails, StringComparer.OrdinalIgnoreCase))
{
return;
}
// Remove unused email addresses to make them available for other apps.
await CleanEmailsAsync(previousEmails.Except(fromEmails), ct);
var unconfirmed = await GetUnconfirmedAsync(fromEmails, ct);
// If all email addresses are already confirmed, we can use the integration.
if (unconfirmed.Count == 0)
{
configured.Status = IntegrationStatus.Verified;
return;
}
foreach (var email in unconfirmed)
{
await VerifyAsync(email, default);
}
configured.Status = IntegrationStatus.Pending;
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var fromEmail = FromEmailProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromEmail))
{
return(null);
}
var fromName = FromNameProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(fromName))
{
return(null);
}
return(new SmtpEmailSender(() => smtpEmailServer, fromEmail, fromName));
}
return(null);
}
public object?Create(Type serviceType, string id, ConfiguredIntegration configured, IServiceProvider serviceProvider)
{
if (CanCreate(serviceType, id, configured))
{
var accountSid = AccountSidProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(accountSid))
{
return(null);
}
var authToken = AuthTokenProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(authToken))
{
return(null);
}
var phoneNumber = PhoneNumberProperty.GetNumber(configured);
if (phoneNumber == 0)
{
return(null);
}
var client = clientPool.GetServer(accountSid, authToken);
return(new TwilioSmsSender(
phoneNumber.ToString(CultureInfo.InvariantCulture),
client,
serviceProvider.GetRequiredService <ISmsCallback>(),
serviceProvider.GetRequiredService <ISmsUrl>(),
id));
}
return(null);
}
public bool CanCreate(Type serviceType, string id, ConfiguredIntegration configured)
{
return(serviceType == typeof(IEmailSender));
}
public async ValueTask <App?> ExecuteAsync(App app, IServiceProvider serviceProvider,
CancellationToken ct)
{
var integrationManager = serviceProvider.GetRequiredService <IIntegrationManager>();
ConfiguredIntegration configured;
if (app.Integrations.TryGetValue(Id, out var previousIntegration))
{
Validate <UpdateValidator> .It(this);
configured = previousIntegration with {
Properties = Properties
};
}
else
{
Validate <CreateValidator> .It(this);
configured = new ConfiguredIntegration(Type, Properties);
}
if (Is.Changed(Test, configured.Test))
{
configured = configured with {
Test = Test
};
}
if (Is.Changed(Enabled, configured.Enabled))
{
configured = configured with {
Enabled = Enabled.Value
};
}
if (Is.Changed(Priority, configured.Priority))
{
configured = configured with {
Priority = Priority.Value
};
}
if (Is.Changed(Condition, configured.Condition))
{
configured = configured with {
Condition = Condition
};
}
await integrationManager.ValidateAsync(configured, ct);
await integrationManager.HandleConfiguredAsync(Id, app, configured, previousIntegration, ct);
var newIntegrations = new Dictionary <string, ConfiguredIntegration>(app.Integrations)
{
[Id] = configured
};
var newApp = app with
{
Integrations = newIntegrations.ToReadonlyDictionary()
};
return(newApp);
}
}
}
private ITelegramBotClient GetBotClient(ConfiguredIntegration configured)
{
var accessToken = AccessToken.GetString(configured);
return(botClientPool.GetBotClient(accessToken !));
}
public bool CanCreate(Type serviceType, string id, ConfiguredIntegration configured)
{
return(serviceType == typeof(WebhookDefinition));
}
public async Task CheckStatusAsync(ConfiguredIntegration configured,
CancellationToken ct)
{
// Check the status every few minutes to update the integration.
configured.Status = await GetStatusAsync(GetEmailAddresses(configured).ToList(), ct);
}
public async Task OnRemovedAsync(App app, string id, ConfiguredIntegration configured,
CancellationToken ct)
{
// Remove unused email addresses to make them available for other apps.
await CleanEmailsAsync(GetEmailAddresses(configured), ct);
}
public static ConfiguredIntegrationDto FromDomainObject(ConfiguredIntegration source)
{
var result = SimpleMapper.Map(source, new ConfiguredIntegrationDto());
return(result);
}
