Joseph Doherty
538 lines
29 KiB
C#
538 lines
29 KiB
C#
using System.CommandLine;
|
|
using System.CommandLine.Parsing;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.CLI.Commands;
|
|
|
|
public static class NotificationCommands
|
|
{
|
|
/// <summary>
|
|
/// Builds the <c>notification</c> command group with sub-commands for managing notification lists and SMTP configuration.
|
|
/// </summary>
|
|
/// <param name="urlOption">Global <c>--url</c> option for the management API endpoint.</param>
|
|
/// <param name="formatOption">Global <c>--format</c> option for output format.</param>
|
|
/// <param name="usernameOption">Global <c>--username</c> option for authentication.</param>
|
|
/// <param name="passwordOption">Global <c>--password</c> option for authentication.</param>
|
|
/// <returns>The configured <c>notification</c> command with all sub-commands registered.</returns>
|
|
public static Command Build(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var command = new Command("notification") { Description = "Manage notification lists" };
|
|
|
|
command.Add(BuildList(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildGet(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildCreate(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildUpdate(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildRename(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildRecipient(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildDelete(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildSmtp(urlOption, formatOption, usernameOption, passwordOption));
|
|
command.Add(BuildSms(urlOption, formatOption, usernameOption, passwordOption));
|
|
|
|
return command;
|
|
}
|
|
|
|
private static Option<int> RequiredId(string name, string description)
|
|
{
|
|
var option = new Option<int>(name) { Description = description, Required = true };
|
|
option.Validators.Add(result => { if (result.GetValueOrDefault<int>() <= 0) result.AddError($"{name} must be positive."); });
|
|
return option;
|
|
}
|
|
|
|
private static Command BuildRename(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var cmd = new Command("rename") { Description = "Rename a list, preserving all recipients and their IDs" };
|
|
var id = RequiredId("--id", "Notification list ID");
|
|
var name = new Option<string>("--name") { Required = true, Description = "New list name" };
|
|
cmd.Add(id); cmd.Add(name);
|
|
cmd.SetAction(async result => await CommandHelpers.ExecuteCommandAsync(result, urlOption, formatOption, usernameOption, passwordOption,
|
|
new RenameNotificationListCommand(result.GetValue(id), result.GetValue(name)!)));
|
|
return cmd;
|
|
}
|
|
|
|
private static Command BuildRecipient(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var group = new Command("recipient") { Description = "Manage individual named recipients without replacing the list" };
|
|
var add = new Command("add") { Description = "Add a named recipient (address must match the list delivery channel)" };
|
|
var listId = RequiredId("--list-id", "Notification list ID");
|
|
var name = new Option<string>("--name") { Required = true, Description = "Recipient name" };
|
|
var email = new Option<string?>("--email") { Description = "Email address" };
|
|
var phone = new Option<string?>("--phone") { Description = "Phone number in E.164 format" };
|
|
add.Add(listId); add.Add(name); add.Add(email); add.Add(phone);
|
|
add.Validators.Add(result =>
|
|
{
|
|
if (string.IsNullOrWhiteSpace(result.GetValue(email)) && string.IsNullOrWhiteSpace(result.GetValue(phone)))
|
|
result.AddError("Provide --email and/or --phone for the recipient.");
|
|
});
|
|
add.SetAction(async result => await CommandHelpers.ExecuteCommandAsync(result, urlOption, formatOption, usernameOption, passwordOption,
|
|
new AddNotificationRecipientCommand(result.GetValue(listId), result.GetValue(name)!, result.GetValue(email), result.GetValue(phone))));
|
|
var delete = new Command("delete") { Description = "Delete one recipient by its recipient ID" };
|
|
var id = RequiredId("--id", "Recipient ID");
|
|
delete.Add(id);
|
|
delete.SetAction(async result => await CommandHelpers.ExecuteCommandAsync(result, urlOption, formatOption, usernameOption, passwordOption,
|
|
new DeleteNotificationRecipientCommand(result.GetValue(id))));
|
|
group.Add(add); group.Add(delete);
|
|
return group;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Notification list create/update options (static so the parsed values can
|
|
// be read back both from the SetAction and from the testable Build* helpers).
|
|
// ------------------------------------------------------------------------
|
|
private static readonly Option<string> ListCreateNameOption =
|
|
new("--name") { Description = "Notification list name", Required = true };
|
|
private static readonly Option<string?> ListCreateEmailsOption =
|
|
new("--emails") { Description = "Comma-separated recipient emails (required for --type email; rejected for --type sms)" };
|
|
private static readonly Option<string?> ListCreatePhonesOption =
|
|
new("--phones") { Description = "Comma-separated recipient phone numbers in E.164 (required for --type sms; rejected for --type email)" };
|
|
private static readonly Option<string> ListCreateTypeOption = CreateListTypeOption();
|
|
|
|
private static readonly Option<int> ListUpdateIdOption =
|
|
new("--id") { Description = "Notification list ID", Required = true };
|
|
private static readonly Option<string> ListUpdateNameOption =
|
|
new("--name") { Description = "List name", Required = true };
|
|
private static readonly Option<string?> ListUpdateEmailsOption =
|
|
new("--emails") { Description = "Comma-separated recipient emails (required for --type email; rejected for --type sms)" };
|
|
private static readonly Option<string?> ListUpdatePhonesOption =
|
|
new("--phones") { Description = "Comma-separated recipient phone numbers in E.164 (required for --type sms; rejected for --type email)" };
|
|
private static readonly Option<string> ListUpdateTypeOption = CreateListTypeOption();
|
|
|
|
private static Option<string> CreateListTypeOption()
|
|
{
|
|
var option = new Option<string>("--type")
|
|
{
|
|
Description = "Delivery channel: email or sms (case-insensitive; default email)",
|
|
DefaultValueFactory = _ => "email",
|
|
};
|
|
return option;
|
|
}
|
|
|
|
private static Command BuildGet(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var idOption = new Option<int>("--id") { Description = "Notification list ID", Required = true };
|
|
var cmd = new Command("get") { Description = "Get a notification list by ID" };
|
|
cmd.Add(idOption);
|
|
cmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
var id = result.GetValue(idOption);
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption, new GetNotificationListCommand(id));
|
|
});
|
|
return cmd;
|
|
}
|
|
|
|
private static Command BuildUpdate(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var cmd = new Command("update") { Description = "Update a notification list" };
|
|
cmd.Add(ListUpdateIdOption);
|
|
cmd.Add(ListUpdateNameOption);
|
|
cmd.Add(ListUpdateTypeOption);
|
|
cmd.Add(ListUpdateEmailsOption);
|
|
cmd.Add(ListUpdatePhonesOption);
|
|
cmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
UpdateNotificationListCommand command;
|
|
try
|
|
{
|
|
command = BuildUpdateNotificationListCommand(result);
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
OutputFormatter.WriteError(ex.Message, "INVALID_ARGUMENT");
|
|
return 1;
|
|
}
|
|
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption, command);
|
|
});
|
|
return cmd;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds the <see cref="UpdateNotificationListCommand"/> from a parsed
|
|
/// <c>notification list update</c> invocation, applying the channel-aware
|
|
/// recipient validation. Throws <see cref="ArgumentException"/> when the
|
|
/// channel and the supplied recipient flags are inconsistent.
|
|
/// </summary>
|
|
/// <param name="result">The parsed command-line result.</param>
|
|
/// <returns>A validated <see cref="UpdateNotificationListCommand"/>.</returns>
|
|
internal static UpdateNotificationListCommand BuildUpdateNotificationListCommand(ParseResult result)
|
|
{
|
|
var id = result.GetValue(ListUpdateIdOption);
|
|
var name = result.GetValue(ListUpdateNameOption)!;
|
|
var (type, emails, phones) = ResolveListChannel(
|
|
result.GetValue(ListUpdateTypeOption)!,
|
|
result.GetValue(ListUpdateEmailsOption),
|
|
result.GetValue(ListUpdatePhonesOption));
|
|
return new UpdateNotificationListCommand(id, name, emails, type, phones);
|
|
}
|
|
|
|
private static Command BuildSmtp(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var group = new Command("smtp") { Description = "Manage SMTP configuration" };
|
|
|
|
var listCmd = new Command("list") { Description = "List SMTP configurations" };
|
|
listCmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption, new ListSmtpConfigsCommand());
|
|
});
|
|
group.Add(listCmd);
|
|
|
|
var createCmd = new Command("create") { Description = "Create SMTP configuration" };
|
|
foreach (var option in new Option[] { SmtpServerOption, SmtpPortOption, SmtpAuthModeOption, SmtpFromOption, SmtpTlsModeOption,
|
|
SmtpCredentialsOption, SmtpOAuth2AuthorityOption, SmtpOAuth2ScopeOption, SmtpTransportOption }) createCmd.Add(option);
|
|
createCmd.SetAction(async result => await CommandHelpers.ExecuteCommandAsync(result, urlOption, formatOption, usernameOption, passwordOption,
|
|
new CreateSmtpConfigCommand(result.GetValue(SmtpServerOption)!, result.GetValue(SmtpPortOption), result.GetValue(SmtpAuthModeOption)!,
|
|
result.GetValue(SmtpFromOption)!, result.GetValue(SmtpTlsModeOption), result.GetValue(SmtpCredentialsOption),
|
|
result.GetValue(SmtpOAuth2AuthorityOption), result.GetValue(SmtpOAuth2ScopeOption), result.GetValue(SmtpTransportOption))));
|
|
group.Add(createCmd);
|
|
|
|
var updateCmd = new Command("update") { Description = "Update SMTP configuration" };
|
|
updateCmd.Add(SmtpIdOption);
|
|
updateCmd.Add(SmtpServerOption);
|
|
updateCmd.Add(SmtpPortOption);
|
|
updateCmd.Add(SmtpAuthModeOption);
|
|
updateCmd.Add(SmtpFromOption);
|
|
updateCmd.Add(SmtpTlsModeOption);
|
|
updateCmd.Add(SmtpCredentialsOption);
|
|
updateCmd.Add(SmtpOAuth2AuthorityOption);
|
|
updateCmd.Add(SmtpOAuth2ScopeOption);
|
|
updateCmd.Add(SmtpTransportOption);
|
|
updateCmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption,
|
|
BuildUpdateSmtpConfigCommand(result));
|
|
});
|
|
group.Add(updateCmd);
|
|
|
|
return group;
|
|
}
|
|
|
|
// SMTP update options are static so the parsed values can be read back both
|
|
// from the SetAction and from BuildUpdateSmtpConfigCommand (used by tests).
|
|
private static readonly Option<int> SmtpIdOption =
|
|
new("--id") { Description = "SMTP config ID", Required = true };
|
|
private static readonly Option<string> SmtpServerOption =
|
|
new("--server") { Description = "SMTP server", Required = true };
|
|
private static readonly Option<int> SmtpPortOption =
|
|
new("--port") { Description = "SMTP port", Required = true };
|
|
private static readonly Option<string> SmtpAuthModeOption =
|
|
new("--auth-mode") { Description = "Auth mode", Required = true };
|
|
private static readonly Option<string> SmtpFromOption =
|
|
new("--from-address") { Description = "From email address", Required = true };
|
|
private static readonly Option<string?> SmtpTlsModeOption = CreateTlsModeOption();
|
|
private static readonly Option<string?> SmtpCredentialsOption =
|
|
new("--credentials")
|
|
{
|
|
Description = "SMTP credentials — 'username:password' for Basic, or client secret " +
|
|
"for OAuth2 (optional; preserves existing if omitted)",
|
|
};
|
|
private static readonly Option<string?> SmtpOAuth2AuthorityOption =
|
|
new("--oauth2-authority")
|
|
{
|
|
Description = "OAuth2 token-endpoint URL (optional; a '{tenant}' placeholder is " +
|
|
"substituted from the credential; preserves existing / M365 default if omitted)",
|
|
};
|
|
private static readonly Option<string?> SmtpOAuth2ScopeOption =
|
|
new("--oauth2-scope")
|
|
{
|
|
Description = "OAuth2 scope requested from the token endpoint " +
|
|
"(optional; preserves existing / M365 default if omitted)",
|
|
};
|
|
|
|
private static readonly Option<string?> SmtpTransportOption = CreateTransportOption();
|
|
|
|
private static Option<string?> CreateTransportOption()
|
|
{
|
|
var option = new Option<string?>("--transport")
|
|
{
|
|
Description = "Email transport: Smtp or Ews (optional; preserves existing if omitted). " +
|
|
"Under Ews, --server is the full EWS URL (https://…/ews/exchange.asmx), " +
|
|
"--auth-mode must be basic, and --port/--tls-mode are unused.",
|
|
};
|
|
option.AcceptOnlyFromAmong("Smtp", "Ews");
|
|
return option;
|
|
}
|
|
|
|
private static Option<string?> CreateTlsModeOption()
|
|
{
|
|
var option = new Option<string?>("--tls-mode")
|
|
{
|
|
Description = "TLS mode: None, StartTLS, or SSL (optional; preserves existing if omitted)",
|
|
};
|
|
option.AcceptOnlyFromAmong("None", "StartTLS", "SSL");
|
|
return option;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds the <see cref="UpdateSmtpConfigCommand"/> from a parsed <c>smtp update</c>
|
|
/// invocation. The optional <c>--tls-mode</c> / <c>--credentials</c> /
|
|
/// <c>--oauth2-authority</c> / <c>--oauth2-scope</c> / <c>--transport</c> flags map to
|
|
/// null when omitted so the server-side handler preserves the existing values.
|
|
/// </summary>
|
|
/// <param name="result">The parsed command-line result from the <c>smtp update</c> invocation.</param>
|
|
/// <returns>An <see cref="UpdateSmtpConfigCommand"/> populated from the parsed result.</returns>
|
|
internal static UpdateSmtpConfigCommand BuildUpdateSmtpConfigCommand(ParseResult result)
|
|
{
|
|
var id = result.GetValue(SmtpIdOption);
|
|
var server = result.GetValue(SmtpServerOption)!;
|
|
var port = result.GetValue(SmtpPortOption);
|
|
var authMode = result.GetValue(SmtpAuthModeOption)!;
|
|
var from = result.GetValue(SmtpFromOption)!;
|
|
var tlsMode = result.GetValue(SmtpTlsModeOption);
|
|
var credentials = result.GetValue(SmtpCredentialsOption);
|
|
var oauth2Authority = result.GetValue(SmtpOAuth2AuthorityOption);
|
|
var oauth2Scope = result.GetValue(SmtpOAuth2ScopeOption);
|
|
var transport = result.GetValue(SmtpTransportOption);
|
|
return new UpdateSmtpConfigCommand(id, server, port, authMode, from, tlsMode, credentials, oauth2Authority, oauth2Scope, transport);
|
|
}
|
|
|
|
private static Command BuildSms(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var group = new Command("sms") { Description = "Manage SMS (Twilio) configuration" };
|
|
|
|
var listCmd = new Command("list") { Description = "List SMS configurations (Auth Token shown as a presence flag only)" };
|
|
listCmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption, new ListSmsConfigsCommand());
|
|
});
|
|
group.Add(listCmd);
|
|
|
|
var createCmd = new Command("create") { Description = "Create SMS configuration (Auth Token required)" };
|
|
foreach (var option in new Option[] { SmsAccountSidOption, SmsFromNumberOption, SmsMessagingServiceSidOption, SmsApiBaseUrlOption,
|
|
SmsAuthTokenOption, SmsTimeoutOption, SmsMaxRetriesOption, SmsRetryDelayOption }) createCmd.Add(option);
|
|
createCmd.Validators.Add(result =>
|
|
{
|
|
if (string.IsNullOrWhiteSpace(result.GetValue(SmsAuthTokenOption))) result.AddError("--auth-token is required when creating SMS configuration.");
|
|
if (string.IsNullOrWhiteSpace(result.GetValue(SmsFromNumberOption)) && string.IsNullOrWhiteSpace(result.GetValue(SmsMessagingServiceSidOption)))
|
|
result.AddError("Provide --from-number and/or --messaging-service-sid.");
|
|
});
|
|
createCmd.SetAction(async result => await CommandHelpers.ExecuteCommandAsync(result, urlOption, formatOption, usernameOption, passwordOption,
|
|
new CreateSmsConfigCommand(result.GetValue(SmsAccountSidOption)!, result.GetValue(SmsFromNumberOption), result.GetValue(SmsMessagingServiceSidOption),
|
|
result.GetValue(SmsApiBaseUrlOption), result.GetValue(SmsAuthTokenOption), result.GetValue(SmsTimeoutOption),
|
|
result.GetValue(SmsMaxRetriesOption), SmsRetryDelay(result))));
|
|
group.Add(createCmd);
|
|
|
|
var updateCmd = new Command("update") { Description = "Update SMS configuration" };
|
|
updateCmd.Add(SmsIdOption);
|
|
updateCmd.Add(SmsAccountSidOption);
|
|
updateCmd.Add(SmsFromNumberOption);
|
|
updateCmd.Add(SmsMessagingServiceSidOption);
|
|
updateCmd.Add(SmsApiBaseUrlOption);
|
|
updateCmd.Add(SmsAuthTokenOption);
|
|
updateCmd.Add(SmsTimeoutOption);
|
|
updateCmd.Add(SmsMaxRetriesOption);
|
|
updateCmd.Add(SmsRetryDelayOption);
|
|
updateCmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption,
|
|
BuildUpdateSmsConfigCommand(result));
|
|
});
|
|
group.Add(updateCmd);
|
|
|
|
return group;
|
|
}
|
|
|
|
private static readonly Option<int?> SmsTimeoutOption = SmsPolicyOption("--connection-timeout-seconds", "Connection timeout in seconds", 1);
|
|
private static readonly Option<int?> SmsMaxRetriesOption = SmsPolicyOption("--max-retries", "Retry count (zero uses the outbox fallback)", 0);
|
|
private static readonly Option<int?> SmsRetryDelayOption = SmsPolicyOption("--retry-delay-seconds", "Retry delay in seconds (zero uses the outbox fallback)", 0);
|
|
|
|
private static Option<int?> SmsPolicyOption(string name, string description, int minimum)
|
|
{
|
|
var option = new Option<int?>(name) { Description = description + "; omission preserves updates or uses create defaults" };
|
|
option.Validators.Add(result =>
|
|
{
|
|
if (result.GetValueOrDefault<int?>() is { } value && value < minimum)
|
|
result.AddError($"{name} must be at least {minimum}.");
|
|
});
|
|
return option;
|
|
}
|
|
|
|
private static TimeSpan? SmsRetryDelay(ParseResult result) =>
|
|
result.GetValue(SmsRetryDelayOption) is { } seconds ? TimeSpan.FromSeconds(seconds) : null;
|
|
|
|
// SMS update options are static so the parsed values can be read back both
|
|
// from the SetAction and from BuildUpdateSmsConfigCommand (used by tests).
|
|
private static readonly Option<int> SmsIdOption =
|
|
new("--id") { Description = "SMS config ID", Required = true };
|
|
private static readonly Option<string> SmsAccountSidOption =
|
|
new("--account-sid") { Description = "Twilio Account SID", Required = true };
|
|
private static readonly Option<string?> SmsFromNumberOption =
|
|
new("--from-number")
|
|
{
|
|
Description = "Sender phone number (E.164). Provide this and/or --messaging-service-sid.",
|
|
};
|
|
private static readonly Option<string?> SmsMessagingServiceSidOption =
|
|
new("--messaging-service-sid")
|
|
{
|
|
Description = "Twilio Messaging Service SID (optional; OMITTING IT CLEARS the stored value)",
|
|
};
|
|
private static readonly Option<string?> SmsApiBaseUrlOption =
|
|
new("--api-base-url")
|
|
{
|
|
Description = "API base URL override (optional; preserves existing if omitted)",
|
|
};
|
|
private static readonly Option<string?> SmsAuthTokenOption =
|
|
new("--auth-token")
|
|
{
|
|
Description = "Twilio Auth Token (optional; PRESERVES the stored token if omitted; never printed back)",
|
|
};
|
|
|
|
/// <summary>
|
|
/// Builds the <see cref="UpdateSmsConfigCommand"/> from a parsed <c>sms update</c>
|
|
/// invocation. Note the asymmetric preserve-vs-clear semantics enforced server-side:
|
|
/// omitting <c>--auth-token</c> / <c>--api-base-url</c> maps to null so the handler
|
|
/// PRESERVES the existing values, whereas omitting <c>--messaging-service-sid</c> also
|
|
/// maps to null but the handler OVERWRITES (clears) the stored value.
|
|
/// </summary>
|
|
/// <param name="result">The parsed command-line result from the <c>sms update</c> invocation.</param>
|
|
/// <returns>An <see cref="UpdateSmsConfigCommand"/> populated from the parsed result.</returns>
|
|
internal static UpdateSmsConfigCommand BuildUpdateSmsConfigCommand(ParseResult result)
|
|
{
|
|
var id = result.GetValue(SmsIdOption);
|
|
var accountSid = result.GetValue(SmsAccountSidOption)!;
|
|
var fromNumber = result.GetValue(SmsFromNumberOption);
|
|
var messagingServiceSid = result.GetValue(SmsMessagingServiceSidOption);
|
|
var apiBaseUrl = result.GetValue(SmsApiBaseUrlOption);
|
|
var authToken = result.GetValue(SmsAuthTokenOption);
|
|
// Whole-replace update: the sender identity must be re-supplied. A Twilio config
|
|
// needs a From number and/or a Messaging Service SID, so reject the case where the
|
|
// update would leave neither (mirrors the UI + delivery-adapter validation).
|
|
if (string.IsNullOrWhiteSpace(fromNumber) && string.IsNullOrWhiteSpace(messagingServiceSid))
|
|
{
|
|
throw new ArgumentException(
|
|
"Provide --from-number and/or --messaging-service-sid (at least one sender identity is required).");
|
|
}
|
|
return new UpdateSmsConfigCommand(id, accountSid, fromNumber, messagingServiceSid, apiBaseUrl, authToken,
|
|
result.GetValue(SmsTimeoutOption), result.GetValue(SmsMaxRetriesOption), SmsRetryDelay(result));
|
|
}
|
|
|
|
private static Command BuildList(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var cmd = new Command("list") { Description = "List all notification lists" };
|
|
cmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption, new ListNotificationListsCommand());
|
|
});
|
|
return cmd;
|
|
}
|
|
|
|
private static Command BuildCreate(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var cmd = new Command("create") { Description = "Create a notification list" };
|
|
cmd.Add(ListCreateNameOption);
|
|
cmd.Add(ListCreateTypeOption);
|
|
cmd.Add(ListCreateEmailsOption);
|
|
cmd.Add(ListCreatePhonesOption);
|
|
cmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
CreateNotificationListCommand command;
|
|
try
|
|
{
|
|
command = BuildCreateNotificationListCommand(result);
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
OutputFormatter.WriteError(ex.Message, "INVALID_ARGUMENT");
|
|
return 1;
|
|
}
|
|
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption, command);
|
|
});
|
|
return cmd;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds the <see cref="CreateNotificationListCommand"/> from a parsed
|
|
/// <c>notification list create</c> invocation, applying the channel-aware
|
|
/// recipient validation. Throws <see cref="ArgumentException"/> when the
|
|
/// channel and the supplied recipient flags are inconsistent.
|
|
/// </summary>
|
|
/// <param name="result">The parsed command-line result.</param>
|
|
/// <returns>A validated <see cref="CreateNotificationListCommand"/>.</returns>
|
|
internal static CreateNotificationListCommand BuildCreateNotificationListCommand(ParseResult result)
|
|
{
|
|
var name = result.GetValue(ListCreateNameOption)!;
|
|
var (type, emails, phones) = ResolveListChannel(
|
|
result.GetValue(ListCreateTypeOption)!,
|
|
result.GetValue(ListCreateEmailsOption),
|
|
result.GetValue(ListCreatePhonesOption));
|
|
return new CreateNotificationListCommand(name, emails, type, phones);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses the <c>--type</c> value (case-insensitive) and validates that the supplied
|
|
/// recipient flags match the channel: <c>email</c> requires <c>--emails</c> and rejects
|
|
/// <c>--phones</c>; <c>sms</c> requires <c>--phones</c> and rejects <c>--emails</c>.
|
|
/// </summary>
|
|
/// <param name="typeRaw">The raw <c>--type</c> value.</param>
|
|
/// <param name="emailsRaw">The raw <c>--emails</c> value, or null when omitted.</param>
|
|
/// <param name="phonesRaw">The raw <c>--phones</c> value, or null when omitted.</param>
|
|
/// <returns>The resolved channel and recipient lists (the off-channel list is empty).</returns>
|
|
/// <exception cref="ArgumentException">Thrown when the type is unknown or the recipient flags are inconsistent with the channel.</exception>
|
|
private static (NotificationType Type, IReadOnlyList<string> Emails, IReadOnlyList<string>? Phones) ResolveListChannel(
|
|
string typeRaw, string? emailsRaw, string? phonesRaw)
|
|
{
|
|
if (!Enum.TryParse<NotificationType>(typeRaw, ignoreCase: true, out var type))
|
|
{
|
|
throw new ArgumentException($"Invalid --type '{typeRaw}'. Expected 'email' or 'sms'.");
|
|
}
|
|
|
|
var emails = SplitRecipients(emailsRaw);
|
|
var phones = SplitRecipients(phonesRaw);
|
|
|
|
if (type == NotificationType.Email)
|
|
{
|
|
if (phones.Count > 0)
|
|
{
|
|
throw new ArgumentException("--phones is not valid for --type email; use --emails.");
|
|
}
|
|
|
|
if (emails.Count == 0)
|
|
{
|
|
throw new ArgumentException("--emails is required for --type email.");
|
|
}
|
|
|
|
return (type, emails, null);
|
|
}
|
|
|
|
// Sms
|
|
if (emails.Count > 0)
|
|
{
|
|
throw new ArgumentException("--emails is not valid for --type sms; use --phones.");
|
|
}
|
|
|
|
if (phones.Count == 0)
|
|
{
|
|
throw new ArgumentException("--phones is required for --type sms.");
|
|
}
|
|
|
|
return (type, Array.Empty<string>(), phones);
|
|
}
|
|
|
|
private static IReadOnlyList<string> SplitRecipients(string? raw) =>
|
|
string.IsNullOrWhiteSpace(raw)
|
|
? Array.Empty<string>()
|
|
: raw.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToList();
|
|
|
|
private static Command BuildDelete(Option<string> urlOption, Option<string> formatOption, Option<string> usernameOption, Option<string> passwordOption)
|
|
{
|
|
var idOption = new Option<int>("--id") { Description = "Notification list ID", Required = true };
|
|
var cmd = new Command("delete") { Description = "Delete a notification list" };
|
|
cmd.Add(idOption);
|
|
cmd.SetAction(async (ParseResult result) =>
|
|
{
|
|
var id = result.GetValue(idOption);
|
|
return await CommandHelpers.ExecuteCommandAsync(
|
|
result, urlOption, formatOption, usernameOption, passwordOption, new DeleteNotificationListCommand(id));
|
|
});
|
|
return cmd;
|
|
}
|
|
}
|